Storia

Hai visto questo post da 9gag ? Forse hai la sensazione di fare le tue frasi. Ma poi ti rendi conto che potresti giocare a golf con una sceneggiatura in mezz'ora e non dovrai mai occupartene.

La presentazione

Il programma riceverà una stringa di input che restituirà con virgolette aggiunte come spiegato di seguito. Sono vietate le scappatoie standard. L'output come elenco di righe è consentito. Sono consentiti spazi finali e righe vuote che non interrompono l'output.

Le regole di input

• L'input contiene solo caratteri ASCII stampabili.
• L'input può contenere spazi. Le parole sono determinate con loro.
• È garantito che uno spazio non sarà mai seguito da un altro spazio.
• Il caso di nessun input o stringa vuota non ha importanza.

Le regole dell'output

Se viene fornita una parola, il programma deve restituire la stringa tra virgolette.

Se la stringa di input ha 2 o più parole, restituisce innanzitutto l'input iniziale, ma la prima parola è racchiusa tra virgolette. Quindi sulla riga successiva, restituisce l'input iniziale, ma con la seconda parola tra virgolette. E così via per le parole rimanenti.

In generale, il programma deve restituire tante righe quante sono le parole nell'input.

Esempi:

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"

Questo è code-golf , quindi vince la risposta con meno byte!

vim, 38 byte

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

Provalo online!

Richiede il plug-in vim-surround .

Se l'input non contiene "caratteri, questo può essere fatto in 19 byte :

qqysW"Ypds"W@qq@qdk

Qui, registriamo una macro ricorsiva ( qq ... @qq@q) che circonda una parola tra virgolette ( ysW"), duplica la linea ( Yp), cancella le virgolette ( ds") e passa alla parola successiva ( W) prima di chiamarsi ricorsivamente. Al termine, ci sono due linee estranee, che vengono eliminate con dk.

La soluzione completa lo avvolge semplicemente :s/"/<C-d>/gall'inizio, che sostituisce i "caratteri esistenti con un carattere non stampabile, e :%s/<C-d>/"/galla fine, che annulla la sostituzione.

Haskell, 65 byte

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

Restituisce un elenco di righe.

Provalo online!

Retina 0.8.2 , 17 byte

 
" $'¶$` "
^|$
"

Provalo online! Il link include la suite di test. Spiegazione:

 
" $'¶$` "

Espandere ogni spazio duplicando la riga e quindi inserendo le virgolette.

^|$
"

Correggi la prima e l'ultima riga.

Gelatina ,  15  14 byte

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

Provalo online!

Come?

Ḳ⁾""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 byte

Salvato 3 byte grazie a @mazzy

Utilizza il non standard ma ampiamente supportato RegExp.left​Contexte RegExp.rightContext. Sono molte citazioni diverse ...

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

Provalo online!

Java, 235 183 132 byte

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 byte abusando di una varietà di cose (accesso statico, elenco vs array, stampa invece di tornare, ecc. Grazie @ValueInk!)
-51 byte di beung pigro e lasciando che @KevinCruijssen faccia il lavoro per me
Provalo online

Spero che il primo tentativo di golf con codice non sia terribile e speriamo che non infranga le regole

Kotlin, 105 112 147 117 byte / caratteri

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

Provalo online!

05AB1E , 14 byte

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

Provalo online!

+1 byte (e funziona per il caso limite) grazie a Emigna. -1 byte grazie a Kevin!

JavaScript, 91 97 75 78 byte

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

Emette un elenco di linee come un array JavaScript. L'ultima voce ha uno spazio finale come consentito nella domanda. Il codice di test scrive ogni voce sulla console su una riga separata a scopo dimostrativo.

Grazie a Shaggy per 19 byte di spazio libero e senza spazi iniziali - quando l'operatore di diffusione viene utilizzato su un array vuoto per inizializzare un array letterale, non vengono creati slot nell'array prodotto dall'operatore di spread:

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

_{(La versione a 91 byte aveva uno spazio iniziale sulla prima riga, la versione a 97 byte impiegava 6 byte per rimuoverla.)}

Python 3 , 79 , 69 , 65 byte

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

Provalo online!

Rasato 10 byte grazie a xnor. E ora questo è 65 byte secondo Erik la soluzione Outgolfer. Il programma termina con IndexError ma questo va bene.

Java 8, 72 71 67 62 byte

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

Provalo online.

Spiegazione:

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

Spiegazione 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 with-an 53 byte

I flag -anvengono letti su ogni riga e divisi in $F.

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

Provalo online!

Rubino , 98 caratteri.

Prima presentazione in assoluto. Questo può sicuramente essere abbreviato. Volevo solo ottenere una risposta rapidamente.

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

Provalo online!

Perl 6 , 43 40 byte

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

Provalo online!

Trova tutte le parole possibili, quindi unisce ogni elenco tra virgolette. Questo potrebbe essere più corto di un byte se potessimo produrre linee in ordine inverso.

Spiegazione:

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

Riflessioni , 229 byte

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

Provalo!

Ho "rapidamente" "giocato a golf" in una lingua "divertente" "da golf".

Guardando tutto quello spazio bianco, probabilmente potrebbe essere più breve.

Haskell , 64 byte

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

Provalo online!

Emette un elenco di stringhe. Basato sulla risposta di Nimi .

Stax , 10 byte

▓¼MY@≈╢∞◙╗

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

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

Esegui questo

C (gcc) , 136 133 byte

Poiché le funzioni di tokenizzazione di C incasinerebbero la stringa su letture future, calcolo invece il numero e gli offset per ogni parola e poi finisco quando il numero totale di iterazioni del ciclo esterno corrisponde al numero di parole.

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

Provalo online!

PowerShell , 60 40 36 byte

-20 byte ispirati ad Arnauld

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

Provalo online!

Il risultato ha uno spazio in più e una linea vuota nella coda.

Powershell, nessuna regexp, 60 byte

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

Provalo online!

Meno golf:

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

Grazie @Shaggy per giocare a golf con 10 byte

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

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

Spiegazione

• La funzione divide la stringa in ogni spazio (x.split``)
• Per ciascun elemento dell'array risultante, eseguire la seguente funzione
• Crea una copia superficiale dell'array (s = [... a])
• Sostituisci l'ennesimo elemento dell'array con se stesso racchiuso tra virgolette (s [i] = `" $ {c} "`)
• restituisce la copia superficiale unita con spazi (s.join``)

Java (JDK) , 104 byte

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

Provalo online!

R , 94 76 byte

-18 byte grazie a Giuseppe

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

Provalo online!

Grazie a digEmAll per impostare correttamente il TIO. Accetta ad es. Ed This is codegolfemette correttamente

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

Utilizza un formato matrice con i ntempi ripetuti frase ; allora dobbiamo solo cambiare le voci diagonali. Nota che di solito, in R code-golf, le stringhe vengono lette con scan(,""), ma qualsiasi stringa può essere utilizzata al posto della stringa vuota come what(ow parametro ).

Spiegazione della vecchia versione non golfata:

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

Questo è il mio primo codice golf. speriamo non sia una merda.

EDIT: ridotto a 54 byte con una migliore espressione regolare.

** MODIFICA 2: per suggerimenti, risolto un bug e reso più breve **

JavaScript (V8) , 46 byte

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

Provalo online!

C # (compilatore interattivo Visual C #) con /u:System.Text.RegularExpressions.Regexflag, 59 40 byte

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

Porta della mia risposta Java 8 , quindi cerca lì una spiegazione.
-19 byte eseguendo il porting della regex di @Arnauld , poiché i $`e $'sono supportati in C # .NET.

Provalo online.

Olmo mediante ricorsione, 132.130.121.111.100 99 byte

Sconfitto di 9 byte grazie alla tecnica di Kevin Cruijssen e altri 22 byte sono stati crackati solo da ASCII . Rivolto alla ricorsione non di coda durante il golf.

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

Provalo online

85 byte dopo aver esposto le Stringfunzioni all'ambito corrente

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

Versione non golfata (usando la ricorsione della coda)

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

Prova ungolfed

Japt , 14 12 byte

¸£¸hYQ²i1X)¸

Provalo

2 byte salvati grazie a 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 byte

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

Provalo online!

Ha una suite di test in prova. Ha 1 spazio iniziale sulla prima riga e 1 spazio finale sull'ultima riga. Tentativo di refactoring.

Carbone , 19 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Nota: spazio finale. Spiegazione:

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

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

Provalo online! Funzione anonima che restituisce un elenco di righe.

Spiegazione

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 # (compilatore interattivo Visual C #) , 123 byte

Mi chiedo se questo può essere abbreviato con espressioni regolari.

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

Provalo online!