Fabuła

Widziałeś ten post z 9gag ? Może masz ochotę tworzyć własne zdania. Ale wtedy zdajesz sobie sprawę, że możesz po prostu zagrać w golfa w ciągu pół godziny i nigdy nie będziesz musiał sobie z tym poradzić.

Złożenie

Twój program otrzyma ciąg wejściowy, który zwróci z dodanymi znakami cudzysłowu, jak wyjaśniono poniżej. Standardowe luki są zabronione. Wyjście jako lista wierszy jest dozwolone. Dozwolone są końcowe spacje i puste linie, które nie przerywają wydruku.

Zasady wprowadzania

• Dane wejściowe zawierają tylko drukowalne znaki ASCII.
• Dane wejściowe mogą zawierać spacje. Słowa są z nimi określone.
• Gwarantujemy, że po jednym miejscu nigdy nie będzie następnej przestrzeni.
• Przypadek braku danych wejściowych lub pustego łańcucha nie ma znaczenia.

Reguły produkcji

Jeśli podano jedno słowo, program musi zwrócić ciąg znaków między cudzysłowami.

Jeśli ciąg wejściowy zawiera 2 lub więcej słów, najpierw zwraca początkowe wejście, ale pierwsze słowo jest w cudzysłowie. Następnie w następnym wierszu zwraca początkowe wejście, ale z drugim słowem w cudzysłowie. I tak dalej dla pozostałych słów.

Ogólnie rzecz biorąc, program musi zwrócić tyle wierszy, ile jest słów na wejściu.

Przykłady:

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"

To jest golf golfowy , więc wygrywa odpowiedź najmniej bajtowa!

vim, 38 bajtów

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

Wypróbuj online!

Wymaga wtyczki vim-surround .

Jeśli dane wejściowe nie zawierają "znaków, można to zrobić w 19 bajtach :

qqysW"Ypds"W@qq@qdk

W tym przypadku rejestrujemy makro rekurencyjne ( qq ... @qq@q), które otacza słowo cudzysłowami ( ysW"), powiela wiersz ( Yp), usuwa znaki cudzysłowu ( ds") i przechodzi do następnego słowa ( W) przed wywołaniem się rekurencyjnie. Po zakończeniu są dwie linie zewnętrzne, które są usuwane za pomocądk .

Pełne rozwiązanie po prostu owija to :s/"/<C-d>/gna początku, który zastępuje istniejące "znaki niedrukowalnymi, a :%s/<C-d>/"/gna końcu, co zastępuje zamianę.

Haskell, 65 bajtów

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

Zwraca listę linii.

Wypróbuj online!

Retina 0.8.2 , 17 bajtów

 
" $'¶$` "
^|$
"

Wypróbuj online! Link zawiera pakiet testowy. Wyjaśnienie:

 
" $'¶$` "

Rozwiń każdą spację, powielając wiersz, a następnie wstawiając cudzysłowy.

^|$
"

Napraw pierwszą i ostatnią linię.

Galaretka ,  15  14 bajtów

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

Wypróbuj online!

W jaki sposób?

Ḳ⁾""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 bajtów

Zaoszczędzono 3 bajty dzięki @mazzy

Korzysta z niestandardowych, ale szeroko obsługiwanych RegExp.left​Contexti RegExp.rightContext. To wiele różnych cytatów ...

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

Wypróbuj online!

Java, 235 183 132 bajty

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 bajtów poprzez nadużywanie różnych rzeczy (dostęp statyczny, lista vs. tablica, drukowanie zamiast zwracania itp. Dzięki @ValueInk!)
-51 bajtów przez beung leniwy i pozwalanie @KevinCruijssen na wykonanie pracy dla mnie
Wypróbuj online

Mam nadzieję, że pierwsza próba golfa nie jest straszna i mam nadzieję, że nie łamie zasad

Kotlin, 105 112 147 117 bajtów / znaków

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

Wypróbuj online!

05AB1E , 14 bajtów

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

Wypróbuj online!

+1 bajt (i działa w przypadku krawędzi) dzięki Emignie. -1 bajt dzięki Kevin!

JavaScript, 91 97 75 78 bajtów

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'));

Wyświetla listę wierszy jako tablicę JavaScript. Ostatni wpis ma końcową spację dozwoloną w pytaniu. Kod testowy zapisuje każdy wpis do konsoli w osobnym wierszu dla celów demonstracyjnych.

Dzięki Shaggy za 19 bajtów off i brak spacji wiodących - gdy operator rozkładania jest używany do pustej tablicy do inicjalizacji literału tablicy, żadne szczeliny nie są tworzone w tablicy wytwarzanej przez operatora rozkładania:

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

_{(Wersja 91-bajtowa miała wiodące miejsce w pierwszym wierszu, wersja 97-bajtowa zajęła 6 bajtów).}

Python 3 , 79 , 69 , 65 bajtów

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

Wypróbuj online!

Ogolono 10 bajtów dzięki xnor. A teraz jest to 65 bajtów według rozwiązania Erika Outgolfera. Program kończy się na IndexError, ale jest w porządku.

Java 8, 72 71 67 62 bajtów

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

Wypróbuj online.

Wyjaśnienie:

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

Wyjaśnienie 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

Ruby z-an 53 bajtami

Flagi -ansą odczytywane w każdej linii i dzielone na $F.

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

Wypróbuj online!

Ruby , 98 znaków.

Pierwsze zgłoszenie w historii. Można to zdecydowanie skrócić. Chciałem tylko szybko uzyskać odpowiedź.

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

Wypróbuj online!

Perl 6 , 43 40 bajtów

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

Wypróbuj 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.

Wyjaśnienie:

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

Looking at all that whitespace, it could probably be shorter.

Haskell, 64 bytes

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

Try it online!

Outputs a list of strings. Based on nimi's answer.

Stax, 10 bytes

▓¼MY@≈╢∞◙╗

Run and debug it

Unpacked, ungolfed, and commented, it looks like this.

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

Run this one

C (gcc), 136 133 bytes

As C's tokenizing functions would mess up the string on future reads, I instead calculate the number and offsets for each word and then finish when the total number of iterations of the outer loop matches the number of words.

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));}

Try it online!

PowerShell, 60 40 36 bytes

-20 bytes inspired by Arnauld

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

Try it online!

The result has one extra space and one empty line in the tail.

Powershell, no regexp, 60 bytes

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

Try it online!

Less golfed:

$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 bytes

Thanks @Shaggy for golfing off 10 bytes

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

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

Explanation

• The function splits the string at each space (x.split` `)
• For each element in the resulting array perform the following function
• Create a shallow copy of the array (s=[...a])
• Replace the nth element in the array with itself surrounded with quotation marks (s[i]=`"${c}"`)
• return the shallow copy joined with spaces (s.join` `)

Java (JDK), 104 bytes

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

Try it online!

R, 94 76 bytes

-18 bytes thanks to Giuseppe

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

Try it online!

Thanks to digEmAll for setting up the TIO properly. It takes in e.g. This is codegolf and outputs correctly

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

It uses a matrix format with the sentence repeated n times; then we only need to change the diagonal entries. Note that usually, in R code-golf, strings are read in with scan(,""), but any string can be used instead of the empty string as the what (or w) parameter.

Explanation of old ungolfed version:

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

This is my first code golf. hopefully its not shit.

EDIT: got it down to 54 bytes with a better regular expression.

**EDIT 2: per suggestions, fixed a bug and made it shorter **

JavaScript (V8), 46 bytes

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

Try it online!

C# (Visual C# Interactive Compiler) with /u:System.Text.RegularExpressions.Regex flag, 59 40 bytes

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

Port of my Java 8 answer, so look there for an explanation.
-19 bytes by porting @Arnauld's regex, since the $` and $' are supported in C# .NET.

Try it online.

Elm Using recursion, 132,130,121,111,100 99 bytes

Golfed down 9 bytes thanks to Kevin Cruijssen technique and another 22 bytes were cracked by ASCII-only. Turned to non-tail recursion during the golf.

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

Try it online

85 bytes after exposing String functions to the current scope

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

Ungolfed version (Using tail recursion)

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") []

Try ungolfed

Japt, 14 12 bytes

¸£¸hYQ²i1X)¸

Try it

2 bytes saved thanks to Oliver.

¸£¸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 bytes

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

Try it online!

Has test suite in trial. Has 1 leading space on first row, and 1 trailing space on last row. Attempting to refactor.

Charcoal, 19 bytes

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

Try it online! Link is to verbose version of code. Note: Trailing space. Explanation:

  θ                     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 bytes

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

Try it online! Anonymous function returning a list of lines.

Explanation

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# Interactive Compiler), 123 bytes

I wonder if can this be shortened with regular expressions.

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

Try it online!