Історія

Ви бачили цю публікацію з 9гаг ? Можливо, у вас з’явилося відчуття складати власні речення. Але потім ти розумієш, що за півгодини ти можеш просто розіграти сценарій, і ніколи не будеш мати справу з цим.

Подання

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

Правила введення

• Вхід містить лише друковані символи 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-surround .

Якщо вхід не містить "символів, це можна зробити в 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

Спробуйте в Інтернеті!

Поголений 10 байт завдяки xnor. А зараз це 65 байт згідно з рішенням Еріка Аутгольфера. Програма закінчується IndexError, але це добре.

Java 8, 72 71 67 62 байт

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

Спробуйте в Інтернеті.

Пояснення:

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:

(?<=(^.*))(\\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

Рубін з -an53 байт

Прапори -anчитаються в кожному рядку і розділяються на $F.

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

Спробуйте в Інтернеті!

Рубі , 98 ч.

Перше подання будь-коли. Це однозначно можна скоротити. Я просто хотів швидко отримати відповідь.

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

Спробуйте в Інтернеті!

Perl 6 , 43 40 байт

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

Спробуйте в Інтернеті!

Збігає всі можливі слова, а потім приєднується до кожного списку цитатами. Це може бути на один байт коротше, якби ми могли виводити рядки у зворотному порядку.

Пояснення:

{                                      }  # 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

Роздуми , 229 байт

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

Перевірте!

Я "швидко" "гольфував" це "смішною" "гольфною" мовою.

Дивлячись на весь цей пробіл, він, ймовірно, може бути коротшим.

Haskell , 64 байти

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

Спробуйте в Інтернеті!

Виводить список рядків. На основі відповіді німі .

Стакс , 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

Це мій перший гольф з кодом. сподіваємось, це не лайно.

EDIT: зменшив її до 54 байт з кращим регулярним виразом.

** EDIT 2: за пропозиціями, виправили помилку та скоротили її **

JavaScript (V8) , 46 байт

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

Спробуйте в Інтернеті!

C # (Visual C # Interactive Compiler) з /u:System.Text.RegularExpressions.Regexпрапором, 59 40 байт

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

Порт моєї відповіді Java 8 , тому шукайте там пояснення.
-19 байт по портированию @Arnauld «s регулярного виразу , так $`і $'підтримуються в C # .NET.

Спробуйте в Інтернеті.

В'яз Використовуючи рекурсію, 132,130,121,111,100 99 байт

Завдяки техніці Кевіна Круїйссена в 9 байтах було знищено 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

Версія без вогків (за допомогою хвостової рекурсії)

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

Attache , 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

Спробуйте в Інтернеті!