Historia

¿Has visto esta publicación de 9gag ? Tal vez tienes la sensación de hacer tus propias oraciones. Pero luego te das cuenta de que podrías jugar un guión en media hora, y nunca tendrás que lidiar con eso.

La sumisión

Su programa obtendrá una cadena de entrada que devolverá con comillas agregadas como se explica a continuación. Las lagunas estándar están prohibidas. Se permite la salida como una lista de líneas. Se permiten espacios finales y líneas vacías que no rompen la salida.

Las reglas de entrada

• La entrada solo contiene caracteres ASCII imprimibles.
• La entrada puede contener espacios. Las palabras se determinan con ellos.
• Se garantiza que un espacio nunca será seguido por otro espacio.
• El caso de no entrada o cadena vacía no importa.

Las reglas de salida

Si se da una palabra, el programa debe devolver la cadena entre comillas.

Si la cadena de entrada tiene 2 o más palabras, primero devuelve la entrada inicial, pero la primera palabra está entre comillas. Luego, en la línea siguiente, devuelve la entrada inicial, pero con la segunda palabra entre comillas. Y así sucesivamente para las palabras restantes.

En general, el programa tiene que devolver tantas líneas como palabras haya en la entrada.

Ejemplos:

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"

Este es el código de golf , por lo que gana la respuesta de menos bytes.

vim, 38 bytes

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

Pruébalo en línea!

Requiere el complemento vim-surround .

Si la entrada no contiene "caracteres, esto se puede hacer en 19 bytes :

qqysW"Ypds"W@qq@qdk

Aquí, registramos una macro recursiva ( qq ... @qq@q) que rodea una palabra con comillas ( ysW"), duplica la línea ( Yp), elimina las comillas ( ds") y pasa a la siguiente palabra ( W) antes de llamarse recursivamente. Después de que termina, hay dos líneas extrañas, que se eliminan con dk.

La solución completa simplemente envuelve esto :s/"/<C-d>/gal principio, que reemplaza los "caracteres existentes con un carácter no imprimible, y :%s/<C-d>/"/gal final, que deshace el reemplazo.

Haskell, 65 bytes

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

Devuelve una lista de líneas.

Pruébalo en línea!

Retina 0.8.2 , 17 bytes

 
" $'¶$` "
^|$
"

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Explicación:

 
" $'¶$` "

Expanda cada espacio duplicando la línea y luego insertando comillas.

^|$
"

Repara la primera y última línea.

Jalea ,  15  14 bytes

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

Pruébalo en línea!

¿Cómo?

Ḳ⁾""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 gracias a @mazzy

Utiliza el no estándar pero ampliamente compatible RegExp.left​Contexty RegExp.rightContext. Son muchas citas diferentes ...

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

Pruébalo en línea!

Java, 235183132 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 al abusar de una variedad de cosas (acceso estático, lista vs matriz, imprimir en lugar de regresar, etc. ¡Gracias @ValueInk!)
-51 bytes por ser perezoso y dejar que @KevinCruijssen haga el trabajo por mí
Pruébalo en línea

Primer intento de golf de código con suerte no es terrible y con suerte no es romper las reglas

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+" "})}}

Pruébalo en línea!

05AB1E , 14 bytes

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

Pruébalo en línea!

+1 byte (y funciona para el caso de borde) gracias a Emigna. -1 byte gracias 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'));

Emite una lista de líneas como una matriz de JavaScript. La última entrada tiene un espacio final como se permite en la pregunta. El código de prueba escribe cada entrada en la consola en una línea separada para fines de demostración.

Gracias a Shaggy por 19 bytes desactivados y sin espacios iniciales: cuando el operador de propagación se utiliza en una matriz vacía para inicializar un literal de matriz, no se crean ranuras en la matriz producida por el operador de expansión:

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

_{(La versión de 91 bytes tenía un espacio inicial en la primera línea, la versión de 97 bytes tomó 6 bytes para eliminarla).}

Python 3 , 79 , 69 , 65 bytes

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

Pruébalo en línea!

Afeitado 10 bytes gracias a xnor. Y ahora esto es 65 bytes según Erik, la solución Outgolfer. El programa termina con IndexError pero esto está bien.

Java 8, 72 71 67 62 bytes

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

Pruébalo en línea.

Explicació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

Explicación de expresiones regulares:

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

Rubí con-an 53 bytes

Las banderas -anse leen en cada línea y se dividen en $F.

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

Pruébalo en línea!

Rubí , 98 caracteres.

Primera presentación de la historia. Esto definitivamente se puede acortar. Solo quería obtener una respuesta rápidamente.

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

Pruébalo en línea!

Perl 6 , 43 40 bytes

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

Pruébalo en línea!

Coincide con todas las palabras posibles, luego une cada lista por comillas. Esto podría ser un byte más corto si pudiéramos generar líneas en orden inverso.

Explicación:

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

Reflexiones , 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~
                 \ ^\
\                   /

¡Pruébalo!

"Rápidamente" "jugué al golf" en un lenguaje "divertido" de "golf".

Mirando todo ese espacio en blanco, probablemente podría ser más corto.

Haskell , 64 bytes

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

Pruébalo en línea!

Emite una lista de cadenas. Basado en la respuesta de nimi .

Stax , 10 bytes

▓¼MY@≈╢∞◙╗

Ejecutar y depurarlo

Desempaquetado, sin golf y comentado, se ve así.

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

Ejecute este

C (gcc) , 136 bytes

Como las funciones de tokenización de C estropearían la cadena en lecturas futuras, en su lugar calculo el número y las compensaciones para cada palabra y luego termino cuando el número total de iteraciones del bucle externo coincide con el número de palabras.

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

Pruébalo en línea!

PowerShell , 60 40 36 bytes

-20 bytes inspirados en Arnauld

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

Pruébalo en línea!

El resultado tiene un espacio extra y una línea vacía en la cola.

Powershell, sin expresiones regulares, 60 bytes

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

Pruébalo en línea!

Menos golfizado:

$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

Gracias @Shaggy por jugar 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'));

Explicación

• La función divide la cadena en cada espacio (x.split``)
• Para cada elemento en la matriz resultante, realice la siguiente función
• Crear una copia superficial de la matriz (s = [... a])
• Reemplace el enésimo elemento en la matriz rodeado de comillas (s [i] = `" $ {c} "`)
• devolver la copia superficial unida con espacios (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;}}

Pruébalo en línea!

R , 94 76 bytes

-18 bytes gracias a Giuseppe

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

Pruébalo en línea!

Gracias a digEmAll por configurar el TIO correctamente. Toma en eg This is codegolfy sale correctamente

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

Utiliza un formato matricial con la oración repetida nveces; entonces solo necesitamos cambiar las entradas diagonales. Tenga en cuenta que, por lo general, en R code-golf, las cadenas se leen conscan(,"") , pero se puede usar cualquier cadena en lugar de la cadena vacía como what(ow parámetro ).

Explicación de la antigua versión sin golf:

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 es mi primer código de golf. Ojalá no sea una mierda.

EDITAR: lo bajó a 54 bytes con una mejor expresión regular.

** EDIT 2: por sugerencias, reparó un error y lo hizo más corto **

JavaScript (V8) , 46 bytes

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) con /u:System.Text.RegularExpressions.Regexindicador, 59 40 bytes

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

El puerto de mi respuesta Java 8 , así que busca una explicación.
-19 bytes portando la expresión regular de @Arnauld , ya que el $`y$' son compatibles con C # .NET.

Pruébalo en línea.

Olmo usando recursividad, 132,130,121,111,100 99 bytes

Bajó 9 bytes gracias a la técnica Kevin Cruijssen y otros 22 bytes fueron descifrados solo por ASCII . Se convirtió en recursión sin cola durante el golf.

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

Pruébalo en línea

85 bytes después de exponer Stringfunciones al alcance actual

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

Versión sin golf (usando la recursión de cola)

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

Prueba sin golf

Japt , 14 12 bytes

¸£¸hYQ²i1X)¸

Intentalo

2 bytes guardados gracias 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]"( |^)$_( |$)"," ""$_"" "}

Pruébalo en línea!

Tiene un conjunto de pruebas en prueba. Tiene 1 espacio inicial en la primera fila y 1 espacio final en la última fila. Intentando refactorizar.

Carbón de leña , 19 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Nota: espacio final. Explicación:

  θ                     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

Adjunto , 34 bytes

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

Pruébalo en línea!Función anónima que devuelve una lista de líneas.

Explicación

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 interactivo de Visual C #) , 123 bytes

Me pregunto si esto se puede acortar con expresiones regulares.

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

Pruébalo en línea!