ストーリー

9gagからこの投稿を見ましたか？たぶん、あなたはあなた自身の文章を作る感覚を得た。しかし、その後、30分で脚本をゴルフするだけでよいことに気づき、それに時間をかける必要はありません。

提出

以下に説明するように、プログラムは入力文字列を取得し、引用符を追加して返します。標準的な抜け穴は禁止されています。行のリストとしての出力が許可されます。出力を中断しない末尾のスペースと空の行は許可されます。

入力の規則

• 入力には、印刷可能なASCII文字のみが含まれます。
• 入力にはスペースを含めることができます。言葉は彼らによって決定されます。
• スペースの後に別のスペースが続かないことが保証されています。
• 入力がない場合や空の文字列の場合は関係ありません。

出力のルール

1つの単語が指定されている場合、プログラムは引用符で囲まれた文字列を返す必要があります。

入力文字列に2つ以上の単語がある場合、最初の入力が最初に返されますが、最初の単語は引用符で囲まれています。次に、次の行で、最初の入力を返しますが、2番目の単語を引用符で囲みます。残りの単語についても同様です。

一般に、プログラムは入力に含まれる単語と同じ数の行を返さなければなりません。

例：

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"

これはcode-golfなので、最小バイトの答えが勝ちです！

vim、38バイト

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

オンラインでお試しください！

vim-surroundプラグインが必要です。

入力に"文字が含まれていない場合、これは19バイトで実行できます。

qqysW"Ypds"W@qq@qdk

ここではqq ... @qq@q、単語を引用符（ysW"）で囲み、行を複製し（Yp）、引用符を削除し（ds"）、次の単語に移動してW再帰的に呼び出す再帰マクロ（）を記録します。終了後、2つの無関係な行があり、それらはで削除されdkます。

完全なソリューション:s/"/<C-d>/gは、既存の"文字を印刷不可能な文字で置き換える最初でこれを単純にラップ:%s/<C-d>/"/gし、最後で置換を元に戻します。

Haskell、65バイト

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

行のリストを返します。

オンラインでお試しください！

網膜0.8.2バイト

 
" $'¶$` "
^|$
"

オンラインでお試しください！リンクにはテストスイートが含まれます。説明：

 
" $'¶$` "

行を複製し、引用符を挿入して、各スペースを展開します。

^|$
"

最初と最後の行を修正します。

ゼリー、 15  14 バイト

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

オンラインでお試しください！

どうやって？

Ḳ⁾""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バイト

@mazzyのおかげで3バイト節約

非標準ですが広くサポートされているRegExp.left​Contextを使用しRegExp.rightContextます。それは多くの異なる引用符です...

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

オンラインでお試しください！

Java、235183132バイト

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バイト（静的アクセス、リスト対配列、返される代わりに印刷など。ありがとう@ValueInk！）
-51バイトで怠け者で、@ KevinCruijssenに仕事を任せ
てオンラインで試す

最初のコードゴルフの試みは、うまくいけばひどくなく、うまくいけばルール違反ではない

Kotlin、105 112 147 117バイト/文字

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

オンラインでお試しください！

05AB1E、14バイト

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

オンラインでお試しください！

Emignaのおかげで、+ 1バイト（エッジケースでも機能します）。ケビンのおかげで-1バイト！

JavaScript、91 97 75 78バイト

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

行のリストをJavaScript配列として出力します。最後のエントリには、質問で許可されているように末尾のスペースがあります。テストコードは、デモンストレーションのために、各エントリを個別の行にコンソールに書き込みます。

Shaggyのおかげで、19バイトのオフと先頭のスペースなし-空の配列でspread演算子を使用して配列リテラルを初期化すると、spread演算子によって生成された配列にスロットは作成されません。

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

_{（91バイトバージョンは最初の行に先頭スペースがあり、97バイトバージョンはそれを削除するために6バイトを要しました。）}

Pythonの3、79、69、65のバイト

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

オンラインでお試しください！

xnorのおかげで10バイト削られました。そして今、これはErik the Outgolferソリューションによると65バイトです。プログラムはIndexErrorで終了しますが、これで問題ありません。

Java 8、72 71 67 62バイト

s->s.replaceAll("(?<=(^.*))(\\S+) ?(?=(.*$))","$1\"$2\" $3\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

正規表現の説明：

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

ルビーと-an、53のバイト

フラグ-anは各行で読み取られ、に分割され$Fます。

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

オンラインでお試しください！

ルビー、98文字。

初めての提出。これは間違いなく短縮できます。私はすぐに答えを得たいと思いました。

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

オンラインでお試しください！

Perlの6、43の、40バイト

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

オンラインでお試しください！

考えられるすべての単語に一致し、引用符で各リストを結合します。行を逆順に出力できる場合、これは1バイト短くなります。

説明：

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

反射、229バイト

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

試して！

私はこれを「面白い」「ゴルフ」言語で「すばやく」「ゴルフ」しました。

空白をすべて見ると、おそらくそれより短くなる可能性があります。

Haskell、64バイト

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

オンラインでお試しください！

文字列のリストを出力します。nimiの答えに基づきます。

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!