Câu chuyện

Bạn đã thấy bài này từ 9gag ? Có lẽ bạn có cảm giác để làm cho câu của riêng bạn. Nhưng sau đó bạn nhận ra rằng bạn chỉ có thể chơi một kịch bản trong nửa giờ và bạn sẽ không bao giờ phải đối phó với điều đó.

Nộp

Chương trình của bạn sẽ nhận được một chuỗi đầu vào mà nó sẽ trả về với các dấu ngoặc kép được thêm vào như được giải thích dưới đây. Sơ hở tiêu chuẩn bị cấm. Đầu ra như một danh sách các dòng được cho phép. Không gian lưu trữ và các dòng trống không phá vỡ đầu ra được cho phép.

Quy tắc đầu vào

• Đầu vào chỉ chứa các ký tự ASCII có thể in được.
• Đầu vào có thể chứa khoảng trắng. Các từ được xác định với họ.
• Nó được đảm bảo rằng một không gian sẽ không bao giờ bị theo sau bởi một không gian khác.
• Trường hợp không có đầu vào hoặc chuỗi rỗng không quan trọng.

Quy tắc đầu ra

Nếu một từ được đưa ra thì chương trình phải trả về chuỗi giữa các dấu ngoặc kép.

Nếu chuỗi đầu vào có 2 từ trở lên, đầu tiên nó sẽ trả về đầu vào ban đầu, nhưng từ đầu tiên nằm trong dấu ngoặc kép. Sau đó, trên dòng tiếp theo, nó trả về đầu vào ban đầu, nhưng với từ thứ hai trong dấu ngoặc kép. Và như vậy cho các từ còn lại.

Nói chung, chương trình phải trả lại nhiều dòng như có từ trong đầu vào.

Ví dụ:

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"

Đây là môn đánh gôn , vì vậy câu trả lời ít byte nhất sẽ thắng!

vim, 38 byte

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

Hãy thử trực tuyến!

Yêu cầu plugin vim-Surround .

Nếu đầu vào không chứa "ký tự, điều này có thể được thực hiện trong 19 byte :

qqysW"Ypds"W@qq@qdk

Ở đây, chúng tôi ghi lại một macro đệ quy ( qq ... @qq@q) bao quanh một từ có dấu ngoặc kép ( ysW"), sao chép dòng ( Yp), xóa dấu ngoặc kép ( ds") và di chuyển sang từ tiếp theo ( W) trước khi tự gọi đệ quy. Sau khi nó chấm dứt, có hai dòng ngoại lai, được xóa bằng dk.

Giải pháp đầy đủ chỉ đơn giản là kết thúc điều này với :s/"/<C-d>/g ngay từ đầu, thay thế các "ký tự hiện có bằng một ký tự không thể in được và :%s/<C-d>/"/gở cuối, hoàn tác thay thế.

Haskell, 65 byte

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

Trả về một danh sách các dòng.

Hãy thử trực tuyến!

Võng mạc 0.8.2 , 17 byte

 
" $'¶$` "
^|$
"

Hãy thử trực tuyến! Liên kết bao gồm bộ kiểm tra. Giải trình:

 
" $'¶$` "

Mở rộng mỗi không gian bằng cách nhân đôi dòng và sau đó chèn dấu ngoặc kép.

^|$
"

Sửa các dòng đầu tiên và cuối cùng.

Thạch ,  15  14 byte

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

Hãy thử trực tuyến!

Làm sao?

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

Đã lưu 3 byte nhờ @mazzy

Sử dụng không chuẩn nhưng được hỗ trợ rộng rãi RegExp.left​Contextvà RegExp.rightContext. Đó là rất nhiều trích dẫn khác nhau ...

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

Hãy thử trực tuyến!

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 bằng cách lạm dụng nhiều thứ (truy cập tĩnh, liệt kê so với mảng, in thay vì trả về, v.v ... Cảm ơn @ValueInk!)
-51 byte bằng cách lười biếng và để @KevinCruijssen thực hiện công việc cho tôi
Hãy thử trực tuyến

Nỗ lực chơi gôn mã đầu tiên hy vọng nó không khủng khiếp và hy vọng nó không phá vỡ quy tắc

Kotlin, 105 112 147 117 byte / ký tự

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

Hãy thử trực tuyến!

05AB1E , 14 byte

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

Hãy thử trực tuyến!

+1 byte (và nó hoạt động cho trường hợp cạnh) nhờ Emigna. -1 byte nhờ 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'));

Xuất ra một danh sách các dòng dưới dạng một mảng JavaScript. Mục cuối cùng có một dấu cách như được cho phép trong câu hỏi. Mã kiểm tra ghi từng mục vào bảng điều khiển trên một dòng riêng cho mục đích trình diễn.

Nhờ Shaggy tắt 19 byte và không có khoảng trắng hàng đầu - khi toán tử trải được sử dụng trên một mảng trống để khởi tạo một mảng bằng chữ, không có khe nào được tạo trong mảng do toán tử trải rộng tạo ra:

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

_{(Phiên bản 91 byte có không gian hàng đầu trên dòng đầu tiên, phiên bản 97 byte mất 6 byte để loại bỏ nó.)}

Python 3 , 79 , 69 , 65 byte

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

Hãy thử trực tuyến!

Cạo 10 byte nhờ xnor. Và bây giờ, đây là 65 byte theo giải pháp Outgolfer của Erik. Chương trình kết thúc với IndexError nhưng điều này là tốt.

Java 8, 72 71 67 62 byte

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

Hãy thử trực tuyến.

Giải trình:

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

Regex giải thích:

(?<=(^.*))(\\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 với -an, 53 byte

Các cờ -anđược đọc từng dòng và chia thành $F.

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

Hãy thử trực tuyến!

Ruby , 98 ký tự.

Trình đầu tiên bao giờ hết. Điều này chắc chắn có thể được rút ngắn. Tôi chỉ muốn nhận được một câu trả lời nhanh chóng.

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

Hãy thử trực tuyến!

Perl 6 , 43 40 byte

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

Hãy thử trực tuyến!

Nối tất cả các từ có thể, sau đó nối từng danh sách bằng dấu ngoặc kép. Điều này có thể ngắn hơn một byte nếu chúng ta có thể xuất các dòng theo thứ tự ngược lại.

Giải trình:

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

Những phản ánh , 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~
                 \ ^\
\                   /

Kiểm tra nó!

Tôi "nhanh chóng" "đánh gôn" điều này bằng một ngôn ngữ "vui nhộn" "chơi gôn".

Nhìn vào tất cả khoảng trắng đó, nó có thể ngắn hơn.

Haskell , 64 byte

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

Hãy thử trực tuyến!

Xuất ra một danh sách các chuỗi. Dựa trên câu trả lời của nimi .

Stax , 10 byte

▓¼MY@≈╢∞◙╗

Chạy và gỡ lỗi nó

Giải nén, không được chỉnh sửa và nhận xét, nó trông như thế này.

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

Chạy cái này

C (gcc) , 136 133 byte

Vì các hàm tokenizing của C sẽ làm xáo trộn chuỗi trong các lần đọc trong tương lai, thay vào đó tôi tính toán số lượng và độ lệch cho mỗi từ và sau đó kết thúc khi tổng số lần lặp của vòng lặp bên ngoài khớp với số lượng từ.

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

Hãy thử trực tuyến!

PowerShell , 60 40 36 byte

-20 byte lấy cảm hứng từ Arnauld

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

Hãy thử trực tuyến!

Kết quả có thêm một khoảng trắng và một dòng trống ở đuôi.

Powershell, không có biểu thức chính quy, 60 byte

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

Hãy thử trực tuyến!

Ít chơi gôn hơn:

$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

Cảm ơn @Shaggy đã chơi golf 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'));

Giải trình

• Hàm chia chuỗi tại mỗi không gian (x.split` `)
• Đối với mỗi phần tử trong mảng kết quả thực hiện chức năng sau
• Tạo một bản sao nông của mảng (s = [... a])
• Thay thế phần tử thứ n trong mảng bằng chính nó được bao quanh bằng dấu ngoặc kép (s [i] = `" $ {c} "`)
• trả về bản sao nông được nối với dấu cách (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;}}

Hãy thử trực tuyến!

R , 94 76 byte

-18 byte nhờ Giuseppe

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

Hãy thử trực tuyến!

Cảm ơn digEmAll đã thiết lập TIO đúng cách. Nó lấy ví dụ This is codegolfvà đầu ra chính xác

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

Nó sử dụng một định dạng ma trận với câu lặp đi lặp lại n; sau đó chúng ta chỉ cần thay đổi các mục chéo. Lưu ý rằng thông thường, trong mã R-golf, các chuỗi được đọc cùng scan(,""), nhưng bất kỳ chuỗi nào cũng có thể được sử dụng thay vì chuỗi trống như what(hoặcw tham số ).

Giải thích về phiên bản cũ chưa được chỉnh sửa:

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

Đây là mã golf đầu tiên của tôi. hy vọng nó không phải là shit.

EDIT: giảm xuống còn 54 byte với biểu thức chính quy tốt hơn.

** EDIT 2: theo đề xuất, sửa lỗi và rút ngắn **

JavaScript (V8) , 46 byte

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

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) với /u:System.Text.RegularExpressions.Regexcờ, 59 40 byte

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

Cổng câu trả lời Java 8 của tôi , vì vậy hãy nhìn vào đó để giải thích.
-19 byte bằng cách chuyển regex của @Arnauld , vì $`và $'được hỗ trợ trong C # .NET.

Hãy thử trực tuyến.

Cây du sử dụng đệ quy, 132.130.121.111.100 99 byte

Đánh xuống 9 byte nhờ kỹ thuật Kevin Cruijssen và 22 byte khác đã bị bẻ khóa bởi ASCII . Chuyển sang đệ quy không đuôi trong golf.

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

Dùng thử trực tuyến

85 byte sau khi phơi bày String chức năng cho phạm vi hiện tại

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

Phiên bản Ungolfed (Sử dụng đệ quy đuôi)

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

Hãy thử

Japt , 14 12 byte

¸£¸hYQ²i1X)¸

Thử nó

2 byte được lưu nhờ 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]"( |^)$_( |$)"," ""$_"" "}

Hãy thử trực tuyến!

Có bộ thử nghiệm trong thử nghiệm. Có 1 không gian hàng đầu trên hàng đầu tiên và 1 không gian ở hàng cuối cùng. Cố gắng tái cấu trúc.

Than , 19 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lưu ý: Không gian lưu trữ. Giải trình:

  θ                     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

Tùy viên , 34 byte

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

Hãy thử trực tuyến!Hàm ẩn danh trả về một danh sách các dòng.

Giải trình

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 # (Trình biên dịch tương tác Visual C #) , 123 byte

Tôi tự hỏi nếu điều này có thể được rút ngắn với các biểu thức thông thường.

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

Hãy thử trực tuyến!