História

Você já viu este post do 9gag ? Talvez você tenha a sensação de fazer suas próprias frases. Mas então você percebe que poderá jogar um script em meia hora e nunca terá que lidar com isso.

A submissão

Seu programa receberá uma string de entrada que retornará com aspas adicionais, conforme explicado abaixo. As brechas padrão são proibidas. A saída como uma lista de linhas é permitida. Espaços à direita e linhas vazias que não interrompem a saída são permitidos.

As regras de entrada

• A entrada contém apenas caracteres ASCII imprimíveis.
• A entrada pode conter espaços. As palavras são determinadas com eles.
• É garantido que um espaço nunca será seguido por outro espaço.
• O caso de nenhuma entrada ou sequência vazia não importa.

As regras de saída

Se uma palavra for dada, o programa deverá retornar a string entre aspas.

Se a sequência de entrada tiver 2 ou mais palavras, ela retornará primeiro a entrada inicial, mas a primeira palavra estará entre aspas. Em seguida, na próxima linha, ele retorna a entrada inicial, mas com a segunda palavra entre aspas. E assim por diante pelas palavras restantes.

Em geral, o programa deve retornar quantas linhas houver palavras na entrada.

Exemplos:

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"

Isso é código-golfe , então a resposta de menos byte vence!

vim, 38 bytes

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

Experimente online!

Requer o plug-in vim-surround .

Se a entrada não contiver "caracteres, isso poderá ser feito em 19 bytes :

qqysW"Ypds"W@qq@qdk

Aqui, registramos uma macro recursiva ( qq ... @qq@q) que envolve uma palavra entre aspas ( ysW"), duplica a linha ( Yp), exclui as aspas ( ds") e passa para a próxima palavra ( W) antes de se chamar recursivamente. Após o término, há duas linhas estranhas, que são excluídas com dk.

A solução completa simplesmente encapsula isso :s/"/<C-d>/gno início, que substitui os "caracteres existentes por um caractere não imprimível, e :%s/<C-d>/"/gno final, que desfaz a substituição.

Haskell, 65 bytes

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

Retorna uma lista de linhas.

Experimente online!

Retina 0.8.2 , 17 bytes

 
" $'¶$` "
^|$
"

Experimente online! O link inclui o conjunto de testes. Explicação:

 
" $'¶$` "

Expanda cada espaço duplicando a linha e inserindo aspas.

^|$
"

Corrija a primeira e a última linha.

Geléia ,  15  14 bytes

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

Experimente online!

Quão?

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

Guardado 3 bytes graças a @mazzy

Usa o não-padrão, mas é amplamente suportado RegExp.left​Contexte RegExp.rightContext. São muitas citações diferentes ...

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

Experimente online!

Java, 235 183 132 bytes

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 bytes por abusar de uma variedade de coisas (acesso estática, lista vs matriz, imprimir ao invés de retornar, etc. @ValueInk Thanks!)
-51 bytes por Beung @KevinCruijssen preguiçosos e deixar fazer o trabalho para me
Tente-lo online

Primeira tentativa de golfe com código, espero que não seja terrível e espero que não seja quebra de regra

Kotlin, 105 112 147 117 bytes / caracteres

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

Experimente online!

05AB1E , 14 bytes

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

Experimente online!

+1 byte (e funciona para o caso de ponta) graças a Emigna. -1 byte graças a Kevin!

JavaScript, 91 97 75 78 bytes

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

Produz uma lista de linhas como uma matriz JavaScript. A última entrada possui um espaço à direita, conforme permitido na pergunta. O código de teste grava cada entrada no console em uma linha separada para fins de demonstração.

Graças a Shaggy por 19 bytes de folga e sem espaços à esquerda - quando o operador de propagação é usado em uma matriz vazia para inicializar uma literal de matriz, nenhum slot é criado na matriz produzida pelo operador de propagação:

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

_{(A versão de 91 bytes tinha um espaço à esquerda na primeira linha, a versão de 97 bytes levou 6 bytes para removê-la.)}

Python 3 , 79 , 69 , 65 bytes

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

Experimente online!

Raspou 10 bytes graças ao xnor. E agora são 65 bytes, conforme Erik, a solução Outgolfer. Programa termina com IndexError, mas isso é bom.

Java 8, 72 71 67 62 bytes

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

Experimente online.

Explicação:

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

Explicação 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 com-an 53 bytes

Os sinalizadores -ansão lidos em cada linha e divididos em $F.

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

Experimente online!

Rubi , 98 caracteres.

Primeira submissão de todos os tempos. Definitivamente, isso pode ser reduzido. Eu só queria obter uma resposta rapidamente.

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

Experimente online!

Perl 6 , 43 40 bytes

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

Experimente online!

Corresponde a todas as palavras possíveis e junta-se a cada lista entre aspas. Isso poderia ser um byte mais curto se pudéssemos produzir linhas na ordem inversa.

Explicação:

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

Reflexões , 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~
                 \ ^\
\                   /

Teste-o!

Eu "rapidamente" "joguei" isso em uma linguagem "engraçada" de "jogar golfe".

Olhando para todo esse espaço em branco, provavelmente poderia ser mais curto.

Haskell , 64 bytes

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

Experimente online!

Produz uma lista de strings. Com base na resposta de nimi .

Stax , 10 bytes

▓¼MY@≈╢∞◙╗

Execute e depure

Descompactado, não jogado e comentado, parece com isso.

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

Execute este

C (gcc) , 136 133 bytes

Como as funções de tokenização de C atrapalhariam a string em futuras leituras, em vez disso, calculo o número e as compensações de cada palavra e termino quando o número total de iterações do loop externo corresponder ao número de palavras.

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

Experimente online!

PowerShell , 60 40 36 bytes

-20 bytes inspirados em Arnauld

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

Experimente online!

O resultado tem um espaço extra e uma linha vazia na cauda.

PowerShell, sem regexp, 60 bytes

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

Experimente online!

Menos golfe:

$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

Obrigado @Shaggy por jogar fora 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'));

Explicação

• A função divide a string em cada espaço (x.split` `)
• Para cada elemento na matriz resultante, execute a seguinte função
• Crie uma cópia superficial da matriz (s = [... a])
• Substitua o enésimo elemento da matriz por ele mesmo, entre aspas (s [i] = `" $ {c} "`)
• retornar a cópia rasa unida a espaços (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;}}

Experimente online!

R , 94 76 bytes

-18 bytes graças a Giuseppe

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

Experimente online!

Agradecemos ao digEmAll por configurar o TIO corretamente. Recebe, por exemplo, This is codegolfe sai corretamente

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

Ele usa um formato de matriz com a frase repetida nvezes; só precisamos alterar as entradas diagonais. Observe que geralmente, no código-golfe R, as strings são lidas com scan(,""), mas qualquer string pode ser usada em vez da string vazia como parâmetro what(ou w).

Explicação da versão antiga não destruída:

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

Este é o meu primeiro código de golfe. espero que não seja uma merda.

EDIT: reduziu para 54 bytes com uma melhor expressão regular.

** EDIÇÃO 2: por sugestões, corrigido um erro e diminuído **

JavaScript (V8) , 46 bytes

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

Experimente online!

C # (compilador interativo do Visual C #) com /u:System.Text.RegularExpressions.Regexsinalizador, 59 40 bytes

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

Porta da minha resposta do Java 8 , então procure uma explicação.
-19 bytes por portar @Arnauld regex 's , uma vez que o $`e$' são suportados em C # .NET.

Experimente online.

Elm Usando recursão, 132.130.121.111.100 99 bytes

Golpeou 9 bytes graças à técnica de Kevin Cruijssen e outros 22 bytes foram quebrados pelo ASCII-only . Transformado em recursão não-cauda durante o golfe.

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

Experimente online

85 bytes após a exposição String funções ao escopo atual

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

Versão não destruída (Usando recursão da cauda)

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

Tente sem golfe

Japonês , 14 12 bytes

¸£¸hYQ²i1X)¸

Tente

2 bytes salvos graças 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 bytes

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

Experimente online!

Possui suíte de teste em avaliação. Possui 1 espaço à esquerda na primeira linha e 1 à direita na última linha. Tentativa de refatorar.

Carvão , 19 bytes

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

Experimente online! Link é a versão detalhada do código. Nota: Espaço à direita. Explicação:

  θ                     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

Anexo , 34 bytes

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

Experimente online! Função anônima retornando uma lista de linhas.

Explicação

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 # (compilador interativo do Visual C #) , 123 bytes

Gostaria de saber se isso pode ser abreviado com expressões regulares.

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

Experimente online!