История

Вы видели этот пост от 9gag ? Может быть, у вас есть чувство, чтобы сделать свои собственные предложения. Но потом вы понимаете, что вы можете просто сыграть сценарий за полчаса, и вам никогда не придется иметь дело с этим.

Представление

Ваша программа получит входную строку, которая будет возвращена с добавленными кавычками, как описано ниже. Стандартные лазейки запрещены. Вывод в виде списка строк разрешен. Конечные пробелы и пустые строки, которые не нарушают вывод, разрешены.

Правила ввода

• Ввод содержит только печатные символы ASCII.
• Входные данные могут содержать пробелы. Слова определяются с ними.
• Гарантируется, что за пробелом никогда не последует другое пробел.
• Случай отсутствия ввода или пустой строки не имеет значения.

Правила вывода

Если дано одно слово, то программа должна вернуть строку между кавычками.

Если во входной строке 2 или более слов, сначала возвращается начальный ввод, но первое слово в кавычках. Затем на следующей строке он возвращает начальный ввод, но со вторым словом в кавычках. И так далее для остальных слов.

В общем, программа должна вернуть столько строк, сколько есть слов на входе.

Примеры:

test -> "test"

This is codegolf -> "This" is codegolf
                    This "is" codegolf
                    This is "codegolf"

This is a significantly longer, but not the longest testcase -> "This" is a significantly longer, but not the longest testcase
                                                                This "is" a significantly longer, but not the longest testcase
                                                                This is "a" significantly longer, but not the longest testcase
                                                                This is a "significantly" longer, but not the longest testcase
                                                                This is a significantly "longer," but not the longest testcase
                                                                This is a significantly longer, "but" not the longest testcase
                                                                This is a significantly longer, but "not" the longest testcase
                                                                This is a significantly longer, but not "the" longest testcase
                                                                This is a significantly longer, but not the "longest" testcase
                                                                This is a significantly longer, but not the longest "testcase"

Here is an another one -> "Here" is an another one
                          Here "is" an another one
                          Here is "an" another one
                          Here is an "another" one
                          Here is an another "one"

Это код-гольф , поэтому побеждает наименее байтовый ответ!

vim, 38 байт

:s/"/<C-d>/g
qqysW"Ypds"W@qq@qdk:%s/<C-d>/"/g

Попробуйте онлайн!

Требуется плагин vim -round .

Если ввод не содержит "символов, это может быть сделано в 19 байтах :

qqysW"Ypds"W@qq@qdk

Здесь мы записываем рекурсивный макрос ( qq ... @qq@q), который окружает слово кавычками ( ysW"), дублирует строку ( Yp), удаляет кавычки ( ds") и переходит к следующему слову ( W) перед рекурсивным вызовом самого себя. После его завершения появляются две посторонние строки, которые удаляются с помощью dk.

Полное решение просто оборачивает это :s/"/<C-d>/gв начало, которое заменяет существующие "символы непечатаемым символом, и :%s/<C-d>/"/gв конце, которое отменяет замену.

Haskell, 65 байт

([]#).words
a#(b:c)=unwords(a++('"':b++"\""):c):(a++[b])#c
_#_=[]

Возвращает список строк.

Попробуйте онлайн!

Сетчатка 0.8.2 , 17 байт

 
" $'¶$` "
^|$
"

Попробуйте онлайн! Ссылка включает тестовый набор. Объяснение:

 
" $'¶$` "

Разверните каждый пробел, продублировав строку и вставив кавычки.

^|$
"

Исправьте первую и последнюю строчки.

Желе ,  15  14 байт

Ḳ⁾""j$€⁹¦K¥ⱮJ$

Попробуйте онлайн!

Как?

Ḳ⁾""j$€⁹¦K¥ⱮJ$ - Link: list of characters, S
Ḳ              - split (S) at spaces -> A
             $ - last two links as a monad:
           Ɱ   -   map...
            J  -   ...across: range of length -> I = [1,2,...len(A)]
          ¥    -   ...doing: last two links as a dyad: i.e. f(A, i) for i in I
      € ¦      -     sparse application...
       ⁹       -     ...to indices: chain's right argument, i
     $         -     ...action: last two links as a monad:
 ⁾""           -       literal list of characters = ['"', '"']
    j          -       join (with A[i]) -> (e.g. with ['i','s']) ['"','i','s','"']
         K     -     join with spaces

JavaScript (ES6),  43 42 41  38 байт

Сохранено 3 байта благодаря @mazzy

Использует нестандартные, но широко поддерживаемые RegExp.left​Contextи RegExp.rightContext. Это много разных цитат ...

s=>s.replace(/(\S+) ?/g,`$\`"$1" $'
`)

Попробуйте онлайн!

Java, 235 183 132 байта

s->{String a[]=s.split(" "),r="",t;for(int l=a.length,i=0,j;i<l;i++,r+="\n")for(j=0;j<l;)r+=(t=i==j?"\"":"")+a[j++]+t+" ";return r;}

-52 байта, злоупотребляя различными вещами (статический доступ, список по сравнению с массивом, печать вместо возврата и т. Д. Спасибо @ValueInk!)
-51 байт, ленивый и позволяющий @KevinCruijssen делать работу за меня
Попробуйте онлайн

Первая попытка игры в гольф кода, надеюсь, это не страшно, и, надеюсь, это не нарушение правил

Котлин, 105 112 147 117 байт / символов

fun main(a:Array<String>){val q=a[0].split(" ")
q.forEach{println(q.fold(""){i,n->i+if(it==n)"\"$n\" " else n+" "})}}

Попробуйте онлайн!

05AB1E , 14 байтов

ð¡©ε®y…"ÿ"Nǝ}»

Попробуйте онлайн!

+1 байт (и это работает для крайнего случая) благодаря Emigna. -1 байт благодаря Кевину!

JavaScript, 91 97 75 78 байт

f= 

t=>t.split` `.map((c,i,a)=>[...a.slice(0,i),`"${c}"`,...a.slice(i+1)].join` `)

// and test
console.log(f("Hello folks and world").join('\n'));

Выводит список строк в виде массива JavaScript. Последняя запись имеет завершающий пробел, как это разрешено в вопросе. Тестовый код записывает каждую запись в консоль в отдельной строке для демонстрационных целей.

Благодаря Shaggy за 19 байт и отсутствие начальных пробелов - когда оператор расширения используется в пустом массиве для инициализации литерала массива, в массиве, созданном оператором распространения, не создаются слоты:

let empty = [];
let array = [...empty, value]
//  produces an array of length 1 containing value 

_{(91-байтовая версия имела начальный пробел в первой строке, 97-байтовая версия заняла 6 байт, чтобы удалить ее.)}

Python 3 , 79 , 69 , 65 байт

w,i=input(),0
while~i:m=w.split();m[i]='"%s"'%m[i];print(*m);i+=1

Попробуйте онлайн!

Shaved 10 bytes thanks to xnor. And now this is 65 bytes as per Erik the Outgolfer solution. Program ends with IndexError but this is fine.

Java 8, 72 71 67 62 bytes

s->s.replaceAll("(?<=(^.*))(\\S+) ?(?=(.*$))","$1\"$2\" $3\n")

Try it online.

Explanation:

s->                    // Method with String as both parameter and return-type
  s.replaceAll("...",  //  Replace all matches in this regex
               "...")  //  With this
                       //  And then return the result

Regex explanation:

(?<=(^.*))(\\S+) ?(?=(.*$))   # === MATCH ===
(?<=     )                    # A positive look-behind to:
     ^.*                      #  The optional leading portion of the string
    (   )                     #  (which is captured in capture group 1)
           \\S+               # Followed by one or more non-space characters,
                              # so the next word in line
          (    )              # (which is captured in capture group 2)
                 ?            # Followed by an optional space
                  (?=     )   # Followed by a positive look-ahead to:
                      .*$     #  The trailing optional portion of the string
                     (   )    #  (which is captured in capture group 3)

$1\"$2\" $3\n                 # === REPLACEMENT ===
$1                            # The match of capture group 1
                              # (the leading portion)
    $2                        # Followed by the match of capture group 2
                              # (the current word in the 'iteration'),
  \"  \"                      # surrounded by quotation marks
                              # Followed by a space character
         $3                   # Followed by the match of capture group 3
                              # (the trailing portion)
           \n                 # Followed by a trailing newline

Ruby with -an, 53 bytes

The flags -an are read each line and split to $F.

$F.size.times{|i|a=$F.dup;a[i]=?"+a[i]+?";puts a*' '}

Try it online!

Ruby, 98 chars.

First submission ever. This can definitely be shortened. I just wanted to get an answer in quickly.

a=->s{s.split.each_index{|i|puts s.split.each_with_index.map{|a,j|i==j ? "\"#{a}\"":a}.join(" ")}}

Try it online!

Perl 6, 43 40 bytes

{m:ex/^(.*?<<)(\S+)(>>.*)$/>>.join('"')}

Try it online!

Matches all possible words, then joins each list by quotes. This could be one byte shorter if we could output lines in reverse order.

Explanation:

{                                      }  # Anonymous code block
 m:ex/^                  $/               # Match all strings
       (.*?)         (.*)                 # Match before and after sections
            <<(\S+)>>                     # And the actual word (with no spaces)
                           >>.join('"')   # And join each line by "s

Reflections, 229 bytes

  _1 +\ /\/(3\  /(0\
/+_:   # \#_: v1=2#_ \
\     /_+/:3; / 1/\:1)
/v(3(2/ \3)(3 ;\#@ \ /
   /:#_(0\:_ / (0*  /0  \
 0 >~    <>~   <0 \  *#_/
 \       /     /\/ v/ 
   \=2#_1/\2#_>  (0~
                 \ ^\
\                   /

Test it!

I "quickly" "golfed" this in a "funny" "golfing" language.

Глядя на все эти пробелы, он может быть короче.

Haskell , 64 байта

map unwords.g.words
g(h:t)=(('"':h++"\""):t):map(h:)(g t)
g _=[]

Попробуйте онлайн!

Выводит список строк. На основании ответа Ними .

Stax , 10 байт

▓¼MY@≈╢∞◙╗

Запустите и отладьте его

Распакованный, размазанный и прокомментированный, это выглядит так.

jY      split on spaces and store in y register
m       for each word, run the rest of the program and implicitly output
  '"|S  surround with double quotes
  yia&  start with register y, and replace the ith element, where i is the iteration index
  J     join with spaces

Запустите этот

C (gcc) , 136 133 байта

Поскольку токенизирующие функции C будут портить строку при будущих чтениях, я вместо этого вычисляю число и смещения для каждого слова, а затем заканчиваю, когда общее количество итераций внешнего цикла совпадает с количеством слов.

i,j=1;f(s,c,t)char*s,*c,*t;{for(i=0;i++<j;puts(""))for(j=0,c=t=s;t;t=c+!!c)printf("%3$s%.*s%s ",(c=index(t,32))-t,t,"\""+!!(i-++j));}

Попробуйте онлайн!

PowerShell , 60 40 36 байт

-20 байтов, вдохновленных Арно

$args-replace'(\S+) ?','$`"$1" $''
'

Попробуйте онлайн!

Результат имеет один дополнительный пробел и одну пустую строку в хвосте.

Powershell, без регулярных выражений, 60 байтов

($w=-split$args)|%{$p=++$c
"$($w|%{$q='"'*!--$p
"$q$_$q"})"}

Попробуйте онлайн!

Менее гольф:

$words=-split $args                     # split by whitespaces
$words|%{
    $position=++$counter
    $array=$words|%{
        $quotation='"'*!--$position     # empty string or quotation char
        "$quotation$_$quotation"
    }
    "$($array)"                         # equivalent to $array-join' '
}

JavaScript, 62 байта

Спасибо @Shaggy за 10 байтов

f=
x=>x.split` `.map((c,i,a)=>(s=[...a],s[i]=`"${c}"`,s.join` `))

console.log(f("Hello folks and world").join('\n'));

объяснение

• Функция разбивает строку на каждый пробел (x.split` `)
• Для каждого элемента в полученном массиве выполняют следующую функцию
• Создать поверхностную копию массива (s = [... a])
• Замените n-й элемент массива на себя, заключив его в кавычки (s [i] = `" $ {c} "`)
• вернуть мелкую копию с пробелами (s.join` `)

Java (JDK) , 104 байта

t->{var w=t.split(" ");int i=0;for(var s:w){w[i]='"'+s+'"';System.out.println(s.join(" ",w));w[i++]=s;}}

Попробуйте онлайн!

R , 94 76 байт

-18 байт благодаря Джузеппе

m=matrix(s<-scan(,a<-'"'),n<-length(s),n);diag(m)=paste0(a,s,a);write(m,1,n)

Попробуйте онлайн!

Спасибо digEmAll за правильную настройку TIO. Он принимает, например, This is codegolfи выводит правильно

"This" is codegolf 
 This "is" codegolf 
 This is "codegolf" 

Он использует матричный формат с повторением предложения n; тогда нам нужно только изменить диагональные записи. Обратите внимание, что обычно в R-гольф-коде строки считываются с scan(,""), но вместо пустой строки можно использовать любую строку вместоwhat (илиw ) .

Объяснение старой версии без золота:

s <- scan(t=scan(,''),w=t)    # read in input and separate by spaces
n <- length(s)                # number of words
m = matrix(s, n, n)           # fill a matrix, one word per entry, each column corresponds to the whole sentence. The sentence is repeated n times.
diag(m) = paste0('"', s, '"') # replace diagonal entries with the corresponding word surrounded by quotes
cat(rbind(m,"\n"))        # add a \n at the end of each column, then print column-wise

Это мой первый кодовый гольф. надеюсь, это не дерьмо.

РЕДАКТИРОВАТЬ: сократил до 54 байтов с лучшим регулярным выражением.

** РЕДАКТИРОВАТЬ 2: в соответствии с предложениями исправил ошибку и сделал ее короче **

JavaScript (V8) , 46 байт

t=>t.split(' ').map(v=>t.replace(v,'"'+v+'"'))

Попробуйте онлайн!

C # (интерактивный компилятор Visual C #) с /u:System.Text.RegularExpressions.Regexфлагом, 59 40 байт

s=>Replace(s,"(\\S+) ?","$`\"$1\" $'\n")

Порт моего ответа Java 8 , так что ищите объяснения.
-19 байт путем переноса регулярного выражения @Arnauld , так как $`и $'поддерживаются в C # .NET.

Попробуйте онлайн.

Elm Используя рекурсию, 132 130 121 211 100 99 байт

Благодаря технике Кевина Круйссена удалось сократить объем до 9 байт, а еще 22 байта были обработаны только ASCII . Обратился к нехвостовой рекурсии во время игры в гольф.

f b a=case a of
 c::r->String.join" "(b++("\""++c++"\"")::r)::f(b++[c])r
 _->[]
u=f[]<<String.words

Попробуйте онлайн

85 байт после выставления Stringфункций в текущей области видимости

f b a=case a of
 c::r->join" "(b++("""++c++""")::r)::f(b++[c])r
 _->[]
u=f[]<<words

Ungolfed версия (с использованием хвостовой рекурсии)

push : List a -> a -> List a
push list el =
    list ++ [ el ]

zip : (List a -> a -> List a -> b) -> List a -> List a -> List b -> List b
zip transform before after mapped =
    case after of
        [] ->
            mapped

        current :: rest ->
            transform before current rest
                |> push mapped
                |> zip transform (push before current) rest

wrap : appendable -> appendable -> appendable
wrap v str =
    v ++ str ++ v

cb : List String -> String -> List String -> String
cb before current rest =
    before ++ wrap "\"" current :: rest
        |> String.join " "

result : List String
result =
    zip cb [] (String.words "This is code golf") []

Попробуй без золота

Japt , 14 12 байт

¸£¸hYQ²i1X)¸

Попытайся

2 байта сохранены благодаря Оливеру.

¸£¸hYQ²i1X)¸     :Implicit input of string
¸                :Split on spaces
 £               :Map each X at index Y
  ¸              :  Split input on spaces
   hY            :  Set the element at index Y to
     Q           :    Quotation mark
      ²          :    Repeat twice
       i1X       :    Insert X at 0-based index 1

PowerShell , 70 65 байт

param($a)$a.Split()|%{$a-replace[regex]"( |^)$_( |$)"," ""$_"" "}

Попробуйте онлайн!

Имеет набор тестов в испытании. Имеет 1 пробел в первом ряду и 1 пробел в последнем ряду. Попытка рефакторинга.

Древесный уголь , 19 байт

Ｅ⪪θ ⪫Ｅ⪪θ ⎇⁼κμ⪫""λλ 

Попробуйте онлайн! Ссылка на подробную версию кода. Примечание: конечный пробел. Объяснение:

  θ                     Input string
 ⪪                      Split on literal space
Ｅ                       Map over words
       θ                Input string
      ⪪                 Split on literal space
     Ｅ                  Map over words
            μ           Inner index
          ⁼             Equals
           κ            Outer index
         ⎇             If true then
               ""       Literal string `""`
              ⪫         Joined i.e. wrapping
                 λ      Current word
                  λ     Otherwise current word
    ⪫                  Joined with literal space
                        Implicitly print each result on its own line

Атташе , 34 байта

Join&sp=>{On&_&Repr=>Iota@_}@Split

Попробуйте онлайн! Анонимная функция, возвращающая список строк.

объяснение

Join&sp=>{On&_&Repr=>Iota@_}@Split
                             Split      Splits the input on whitespace
         {         =>Iota@_}            Over each number K, 0 to #words - 1
          On  &Repr                     Apply the Repr (quoting) function
            &_                          on the Kth element in the input
Join&sp=>                               then rejoin the words of each inner sentence

C # (интерактивный компилятор Visual C #) , 123 байта

Интересно, можно ли это сократить с помощью регулярных выражений?

s=>(r=s.Split(' ')).Select((a,i)=>(string.Join(" ",r.Take(i))+" \""+a+"\" "+string.Join(" ",r.Skip(i+1))).Trim());string[]r

Попробуйте онлайн!