Récit

Avez-vous vu ce post de 9gag ? Vous avez peut-être le sentiment de faire vos propres phrases. Mais alors vous vous rendez compte que vous pourriez simplement jouer un script en une demi-heure, et vous n'aurez jamais à vous en occuper.

La soumission

Votre programme recevra une chaîne d'entrée qu'il renverra avec des guillemets ajoutés comme expliqué ci-dessous. Les failles standard sont interdites. La sortie sous forme de liste de lignes est autorisée. Les espaces de fin et les lignes vides qui ne cassent pas la sortie sont autorisés.

Les règles de saisie

• L'entrée contient uniquement des caractères ASCII imprimables.
• L'entrée peut contenir des espaces. Les mots sont déterminés avec eux.
• Il est garanti qu'un espace ne sera jamais suivi d'un autre espace.
• Le cas d'aucune entrée ou chaîne vide n'a pas d'importance.

Les règles de sortie

Si un mot est donné, le programme doit renvoyer la chaîne entre guillemets.

Si la chaîne d'entrée contient 2 mots ou plus, elle renvoie d'abord l'entrée initiale, mais le premier mot est entre guillemets. Ensuite, sur la ligne suivante, il renvoie l'entrée initiale, mais avec le deuxième mot entre guillemets. Et ainsi de suite pour les mots restants.

En général, le programme doit renvoyer autant de lignes qu'il y a de mots dans l'entrée.

Exemples:

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"

C'est le code-golf , donc la réponse du moindre octet gagne!

vim, 38 octets

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

Essayez-le en ligne!

Nécessite le plugin vim-surround .

Si l'entrée ne contient pas de "caractères, cela peut être fait en 19 octets :

qqysW"Ypds"W@qq@qdk

Ici, nous enregistrons une macro récursive ( qq ... @qq@q) qui entoure un mot avec des guillemets ( ysW"), duplique la ligne ( Yp), supprime les guillemets ( ds") et passe au mot suivant ( W) avant de s'appeler récursivement. Après sa fin, il y a deux lignes superflues, qui sont supprimées avec dk.

La solution complète enveloppe simplement cela :s/"/<C-d>/gau début, qui remplace les "caractères existants par un caractère non imprimable, et :%s/<C-d>/"/gà la fin, ce qui annule le remplacement.

Haskell, 65 octets

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

Renvoie une liste de lignes.

Essayez-le en ligne!

Retina 0.8.2 , 17 octets

 
" $'¶$` "
^|$
"

Essayez-le en ligne! Le lien inclut une suite de tests. Explication:

 
" $'¶$` "

Développez chaque espace en dupliquant la ligne, puis en insérant des guillemets.

^|$
"

Fixez les première et dernière lignes.

Gelée ,  15  14 octets

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

Essayez-le en ligne!

Comment?

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

Sauvegardé 3 octets grâce à @mazzy

Utilise le non standard mais largement pris en charge RegExp.left​Contextet RegExp.rightContext. C'est beaucoup de citations différentes ...

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

Essayez-le en ligne!

Java, 235183132 octets

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 octets en abusant d'une variété de choses (accès statique, liste vs tableau, imprimer au lieu de retourner, etc. Merci @ValueInk!)
-51 octets par beung paresseux et laisser @KevinCruijssen faire le travail pour moi
Essayez-le en ligne

J'espère que ce n'est pas terrible

Kotlin, 105 112 147 117 octets / caractères

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

Essayez-le en ligne!

05AB1E , 14 octets

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

Essayez-le en ligne!

+1 octet (et cela fonctionne pour le cas de bord) grâce à Emigna. -1 octet merci à Kevin!

JavaScript, 91 97 75 78 octets

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

Génère une liste de lignes sous forme de tableau JavaScript. La dernière entrée a un espace de fin comme autorisé dans la question. Le code de test écrit chaque entrée dans la console sur une ligne distincte à des fins de démonstration.

Grâce à Shaggy pour 19 octets de moins et aucun espace de tête - lorsque l'opérateur de propagation est utilisé sur un tableau vide pour initialiser un littéral de tableau, aucun emplacement n'est créé dans le tableau produit par l'opérateur de propagation:

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

_{(La version 91 octets avait un espace de tête sur la première ligne, la version 97 octets prenait 6 octets pour le supprimer.)}

Python 3 , 79 , 69 , 65 octets

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

Essayez-le en ligne!

Rasé de 10 octets grâce à xnor. Et maintenant, c'est 65 octets selon Erik la solution Outgolfer. Le programme se termine avec IndexError mais c'est très bien.

Java 8, 72 71 67 62 octets

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

Essayez-le en ligne.

Explication:

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

Explication de l'expression régulière:

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

Rubis avec-an , 53 octets

Les drapeaux -ansont lus sur chaque ligne et divisés en $F.

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

Essayez-le en ligne!

Rubis , 98 caractères.

Première soumission jamais. Cela peut certainement être raccourci. Je voulais juste obtenir une réponse rapidement.

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

Essayez-le en ligne!

Perl 6 , 43 40 octets

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

Essayez-le en ligne!

Correspond à tous les mots possibles, puis joint chaque liste par des guillemets. Cela pourrait être un octet plus court si nous pouvions produire des lignes dans l'ordre inverse.

Explication:

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

Réflexions , 229 octets

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

Essaye-le!

J'ai "rapidement" "joué au golf" dans une langue "drôle" de "golf".

En regardant tout cet espace, il pourrait probablement être plus court.

Haskell , 64 octets

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

Essayez-le en ligne!

Génère une liste de chaînes. Basé sur la réponse de Nimi .

Stax , 10 octets

▓¼MY@≈╢∞◙╗

Exécuter et déboguer

Déballé, non golfé et commenté, il ressemble à ceci.

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

Exécutez celui-ci

C (gcc) , 136133 octets

Comme les fonctions de tokenisation de C gâcheraient la chaîne lors des lectures futures, je calcule plutôt le nombre et les décalages pour chaque mot, puis je termine lorsque le nombre total d'itérations de la boucle externe correspond au nombre de mots.

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

Essayez-le en ligne!

PowerShell , 60 40 36 octets

-20 octets inspirés par Arnauld

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

Essayez-le en ligne!

Le résultat a un espace supplémentaire et une ligne vide dans la queue.

Powershell, pas d'expression régulière, 60 octets

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

Essayez-le en ligne!

Moins 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 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!