Geschichte

Haben Sie diesen Beitrag von 9gag gesehen ? Vielleicht hast du das Gefühl, deine eigenen Sätze zu bilden. Aber dann merkt man, dass man in einer halben Stunde nur ein Drehbuch spielen kann, und man muss sich nie damit auseinandersetzen.

Die Vorlage

Ihr Programm erhält eine Eingabezeichenfolge, die in Anführungszeichen gesetzt wird (siehe unten). Standardlücken sind verboten. Die Ausgabe als Zeilenliste ist zulässig. Leerzeichen und Leerzeilen, die die Ausgabe nicht unterbrechen, sind zulässig.

Die Regeln der Eingabe

• Die Eingabe enthält nur druckbare ASCII-Zeichen.
• Die Eingabe kann Leerzeichen enthalten. Die Wörter werden mit ihnen bestimmt.
• Es ist garantiert, dass einem Leerzeichen niemals ein anderes Leerzeichen folgt.
• Der Fall, dass keine Eingabe oder leere Zeichenfolge vorhanden ist, spielt keine Rolle.

Die Regeln der Ausgabe

Wenn ein Wort angegeben wird, muss das Programm die Zeichenfolge zwischen Anführungszeichen zurückgeben.

Wenn die Eingabezeichenfolge 2 oder mehr Wörter enthält, wird zuerst die ursprüngliche Eingabe zurückgegeben, das erste Wort befindet sich jedoch in Anführungszeichen. In der nächsten Zeile wird dann die ursprüngliche Eingabe zurückgegeben, jedoch mit dem zweiten Wort in Anführungszeichen. Und so weiter für die restlichen Wörter.

Im Allgemeinen muss das Programm so viele Zeilen zurückgeben, wie Wörter in der Eingabe enthalten sind.

Beispiele:

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"

Das ist Code-Golf , also gewinnt die Antwort mit dem geringsten Byte!

vim, 38 bytes

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

Probieren Sie es online!

Benötigt das Vim-Surround-Plugin .

Wenn die Eingabe keine "Zeichen enthält , kann dies in 19 Bytes erfolgen :

qqysW"Ypds"W@qq@qdk

Hier zeichnen wir ein rekursives Makro ( qq ... @qq@q) auf, das ein Wort mit Anführungszeichen ( ) umgibt ysW", die Zeile ( Yp) dupliziert und die Anführungszeichen löscht (ds" ) und zum nächsten Wort ( W) wechselt, bevor aufrufen. Nach dem Beenden gibt es zwei Nebenzeilen, die mit gelöscht werden dk.

Die vollständige Lösung :s/"/<C-d>/gschließt dies einfach am Anfang "mit ein , wobei vorhandene Zeichen durch ein nicht druckbares Zeichen ersetzt werden und :%s/<C-d>/"/gam Ende die Ersetzung rückgängig gemacht wird.

Haskell, 65 Bytes

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

Gibt eine Liste von Zeilen zurück.

Probieren Sie es online!

Retina 0.8.2 , 17 Bytes

 
" $'¶$` "
^|$
"

Probieren Sie es online! Link enthält Testsuite. Erläuterung:

 
" $'¶$` "

Erweitern Sie jedes Leerzeichen, indem Sie die Zeile duplizieren und dann Anführungszeichen einfügen.

^|$
"

Korrigieren Sie die erste und letzte Zeile.

Jelly ,  15 bis  14 Bytes

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

Probieren Sie es online!

Wie?

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

Saved 3 bytes thanks to @mazzy

Uses the non-standard but widely supported RegExp.left​Context and RegExp.rightContext. That's a lot of different quotes...

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

Try it 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 by abusing a variety of things (static access, list vs array, print instead of returning, etc. Thanks @ValueInk!)
-51 bytes by beung lazy and letting @KevinCruijssen do the work for me
Try it online

First code golf attempt hopefully it's not terrible and hopefully it's not rule breaking

Kotlin, 105 112 147 117 bytes/chars

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

Try it online!

05AB1E, 14 bytes

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

Try it online!

+1 byte (and it works for the edge case) thanks to Emigna. -1 byte thanks to 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'));

Outputs a list of lines as a JavaScript array. The last entry has a trailing space as allowed in the question. The test code writes each entry to the console on a separate line for demonstration purposes.

Thanks to Shaggy for 19 bytes off and no leading spaces - when the spread operator is used on an empty array to initialize an array literal, no slots are created in the array produced by the spread operator:

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

_{(The 91 byte version had a leading space on the first line, the 97 byte version took 6 bytes to remove it.)}

Python 3, 79, 69, 65 bytes

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

Try it online!

Shaved 10 bytes thanks to xnor. And now this is 65 bytes as per Erik the Outgolfer solution. Program ends with IndexError but this is fine.

Java 8, 72 71 67 62 bytes

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

Try it online.

Explanation:

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 explanation:

(?<=(^.*))(\\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 with -an, 53 bytes

The flags -an are read each line and split to $F.

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

Try it online!

Rubin , 98 Zeichen.

Erste Einreichung überhaupt. Dies kann definitiv verkürzt werden. Ich wollte nur schnell eine Antwort bekommen.

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

Probieren Sie es online!

Perl 6 , 43 40 Bytes

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

Probieren Sie es online!

Stimmt mit allen möglichen Wörtern überein und fügt dann jede Liste in Anführungszeichen ein. Dies könnte ein Byte kürzer sein, wenn wir die Zeilen in umgekehrter Reihenfolge ausgeben könnten.

Erläuterung:

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

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

Probier es aus!

Ich habe dies "schnell" in einer "lustigen" "Golf" -Sprache "golfen".

Wenn man das ganze Leerzeichen betrachtet, könnte es wahrscheinlich kürzer sein.

Haskell , 64 Bytes

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

Probieren Sie es online!

Gibt eine Liste von Zeichenfolgen aus. Basierend auf Nimis Antwort .

Stax , 10 Bytes

▓¼MY@≈╢∞◙╗

Führen Sie es aus und debuggen Sie es

Ausgepackt, ungolfed und kommentiert sieht es so aus.

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

Führen Sie dieses aus

C (gcc) , 136 133 Bytes

Da die Tokenisierungsfunktionen von C die Zeichenfolge bei zukünftigen Lesevorgängen durcheinander bringen würden, berechne ich stattdessen die Anzahl und die Offsets für jedes Wort und beende den Vorgang, wenn die Gesamtzahl der Iterationen der äußeren Schleife mit der Anzahl der Wörter übereinstimmt.

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

Probieren Sie es online!

PowerShell , 60 40 36 Byte

-20 Bytes, inspiriert von Arnauld

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

Probieren Sie es online!

Das Ergebnis enthält ein zusätzliches Leerzeichen und eine leere Zeile im Schwanz.

PowerShell, kein regulärer Ausdruck, 60 Bytes

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

Probieren Sie es online!

Weniger golfen:

$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

Vielen Dank an @Shaggy für das Golfen mit 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'));

Erläuterung

• Die Funktion teilt den String an jedem Leerzeichen auf (x.split``)
• Führen Sie für jedes Element im resultierenden Array die folgende Funktion aus
• Erstellen Sie eine flache Kopie des Arrays (s = [... a])
• Ersetzen Sie das n-te Element im Array durch Anführungszeichen (s [i] = `" $ {c} "`)
• Gib die flache Kopie zurück, die mit Leerzeichen verbunden ist (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;}}

Probieren Sie es online!

R , 94 76 Bytes

-18 Bytes dank Giuseppe

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

Probieren Sie es online!

Vielen Dank an digEmAll für die korrekte Einrichtung des TIO. Es nimmt zB auf This is codegolfund gibt richtig aus

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

Es wird ein Matrixformat verwendet, bei dem der Satz nmehrmals vorkommt. dann müssen wir nur noch die diagonalen einträge ändern. Beachten Sie, dass in der Regel in R-Code-Golf Zeichenfolgen mit eingelesen werden scan(,""), aber eine beliebige Zeichenfolge anstelle der leeren Zeichenfolge als what(oder w) -Parameter verwendet werden kann.

Erklärung der alten 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

Dies ist mein erster Code Golf. hoffentlich ist es nicht scheiße.

BEARBEITEN: mit einem besseren regulären Ausdruck auf 54 Bytes reduziert.

** BEARBEITEN 2: pro Vorschläge, Fehler behoben und kürzer gemacht **

JavaScript (V8) , 46 Byte

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

Probieren Sie es online!

C # (Visual C # Interactive Compiler) mit/u:System.Text.RegularExpressions.Regex Flag, 59 bis 40 Byte

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

Port meiner Java 8 Antwort , schauen Sie dort nach einer Erklärung.
-19 Bytes durch Portierung von @Arnauld 's Regex , seit dem $`und$' in C # unterstützt werden.

Probieren Sie es online aus.

Ulme Unter Verwendung der Rekursion 132.130.121.111.100 99 Bytes

Dank Kevin Cruijssen- Technik 9 Bytes weniger als erwartet , und weitere 22 Bytes wurden nur von ASCII geknackt . Rekursion ohne Schwanz während des Golfspiels.

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

Probieren Sie es online aus

85 Bytes, nachdem StringFunktionen dem aktuellen Bereich ausgesetzt wurden

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

Ungolfed-Version (Verwendung der Schwanzrekursion)

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

Versuchen Sie es ungolfed

Japt , 14 12 Bytes

¸£¸hYQ²i1X)¸

Versuch es

2 Bytes gespart dank 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 bis 65 Byte

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

Probieren Sie es online!

Test-Suite in Prüfung. Hat 1 Leerzeichen in der ersten Zeile und 1 Leerzeichen in der letzten Zeile. Versuch einer Umgestaltung.

Holzkohle , 19 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Hinweis: Leerzeichen am Ende. Erläuterung:

  θ                     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

Probieren Sie es online!Anonyme Funktion, die eine Liste von Zeilen zurückgibt.

Erläuterung

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 Byte

Ich frage mich, ob dies mit regulären Ausdrücken verkürzt werden kann.

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

Probieren Sie es online!