Warte ... das ist kein Trolling.

Hintergrund

In diesen Tagen sind die Kommentarbereiche auf YouTube mit folgenden Mustern übersät:

S
St
Str
Stri
Strin
String
Strin
Stri
Str
St
S

Wo Stringist ein bloßer Platzhalter und bezieht sich auf eine beliebige Kombination von Zeichen. Diese Muster werden normalerweise von einem It took me a lot of time to make this, pls likeoder etwas begleitet, und oft gelingt es dem OP, eine Reihe von Likes zu sammeln.

Die Aufgabe

Obwohl Sie eine große Begabung dafür haben, mit Ihren bezaubernden Golfkünsten Aufwertungen bei PPCG zu erzielen, sind Sie definitiv nicht die erste Wahl, um witzige Bemerkungen zu machen oder Memes in YouTube-Kommentarbereichen zu referenzieren. So sammeln Ihre konstruktiven Kommentare, die Sie mit Bedacht abgegeben haben, auf YouTube ein paar „Gefällt mir nicht“. Sie möchten, dass sich dies ändert. Sie greifen also auf die oben genannten Klischeemuster zurück, um Ihr letztendliches Ziel zu erreichen, ohne jedoch Zeit damit zu verschwenden, sie manuell zu schreiben.

Einfach ausgedrückt, besteht Ihre Aufgabe darin, eine Zeichenfolge zu nehmen sund 2*s.length - 1Teilzeichenfolgen von s, die durch eine neue Zeile begrenzt sind, auszugeben, um dem folgenden Muster zu entsprechen:

(für s= "Hallo")

H
He
Hel
Hell
Hello
Hell
Hel
He
H

Eingang

Eine einzelne Zeichenfolge s. Es gelten die Eingabestandards der Community. Sie können davon ausgehen, dass die Eingabezeichenfolge nur druckbare ASCII-Zeichen enthält.

Ausgabe

Mehrere durch einen Zeilenumbruch getrennte Zeilen bilden ein geeignetes Muster, wie oben erläutert. Es gelten die Ausgabestandards der Community. Führende und nachfolgende Leerzeichen (die keine oder nicht sichtbare Zeichen wie Leerzeichen enthalten) sind in der Ausgabe zulässig.

Testfall

Ein Testfall mit mehreren Wörtern:

Input => "Oh yeah yeah"

Output =>

O
Oh
Oh 
Oh y
Oh ye
Oh yea
Oh yeah
Oh yeah 
Oh yeah y
Oh yeah ye
Oh yeah yea
Oh yeah yeah
Oh yeah yea
Oh yeah ye
Oh yeah y
Oh yeah 
Oh yeah
Oh yea
Oh ye
Oh y
Oh 
Oh
O

Beachten Sie, dass die Form der Ausgabe des obigen Testfalls offensichtlich verzerrt ist (z. B. erscheinen Zeile zwei und Zeile drei der Ausgabe gleich). Das liegt daran, dass wir die nachgestellten Leerzeichen nicht sehen können. Ihr Programm muss NICHT versuchen, diese Verzerrungen zu beheben.

Gewinnkriterium

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes in jeder Sprache!

Brainfuck , 32 Bytes

,[[<]>[.>]++++++++++.,[>>]<[-]<]

Probieren Sie es online!

Die gleiche Schleife wird für beide Hälften des Musters verwendet.

Erläuterung:

,             Take first input character as initial line
[             Until line to output is empty:
  [<]>        Move to beginning of line
  [.>]        Output all characters in line
  ++++++++++. Output newline
  ,           Input next character
  [>>]        Move two cells right if input character nonzero
  <[-]        Otherwise remove last character in line
  <           Move to new last character in line
]

JavaScript (ES6), 36 Byte

f=([c,...r],s=`
`)=>c?s+f(r,s+c)+s:s

Probieren Sie es online!

Kommentiert

f = (             // f is a recursive function taking:
                  //   the input string split into:
  [c,             //     c   = next character (may be undefined if we've reached the end)
      ...r],      //     r[] = array of remaining characters
  s = `\n`        //   the output string s, initialized to a linefeed
) =>              // 
  c ?             // if c is defined:
    s +           //   append s (top of the ASCII art)
    f(r, s + c) + //   append the result of a recursive call to f, using r[] and s + c
    s             //   append s again (bottom of the ASCII art)
  :               // else:
    s             //   append s just once (this is the final middle row) and stop recursion

05AB1E (Legacy) ,  4  3 Bytes

^{Durchgestrichen  4 ist nicht mehr 4 :)}

η.∊

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

η     # Get the prefixes of the (implicit) input-string
 .∊   # Vertically mirror everything with the last line overlapping
      # (which implicitly joins by newlines in the legacy version of 05AB1E)
      # (and output the result implicitly)

In der neuen Version von 05AB1E »ist nach dem expliziten und erforderlich η, weshalb ich hier die Legacy-Version von 05AB1E verwende, um ein Byte zu speichern.

IBM PC DOS, 8088-Assembly,  44  43

d1ee ad8b d6b4 0948 8af8 8ac8 d0e1 49b3 243a cf7d 024e
4e46 861c cd21 861c 52ba 2901 cd21 5ae2 eac3 0d0a 24

Zerlegt:

    SHR  SI, 1              ; point SI to DOS PSP at 80H (SI intialized at 100H)
    LODSW                   ; load arg length into AL, advance SI to 82H
    MOV  DX, SI             ; save start of string pointer
    MOV  AH, 9              ; DOS API display string function
    DEC  AX                 ; remove leading space from string length
    MOV  BH, AL             ; save string len in BH (AL gets mangled by INT 21H,9)
    MOV  CL, AL             ; set up loop counter in CL
    SHL  CL, 1              ; number of lines = 2 * string length - 1
    DEC  CX
    MOV  BL, '$'            ; end of string marker
LINE_LOOP:
    CMP  CL, BH             ; if CL >= string length, ascend
    JGE  ASCEND
    DEC  SI                 ; descend by backing up two places (always increments)
    DEC  SI                 ; (this is fewer bytes than 'SUB SI, 2' or two branches)
ASCEND:
    INC  SI                 ; increment current string position
    XCHG BL, [SI]           ; swap current string byte with end of string delimiter
    INT  21H                ; write substring to console
    XCHG BL, [SI]           ; restore string byte
    PUSH DX                 ; save output string pointer
    MOV  DX, OFFSET CRLF    ; load CRLF string
    INT  21H                ; write to console
    POP  DX                 ; restore output string pointer
    LOOP LINE_LOOP          ; move to next line
    RET
CRLF DB 0DH,0AH,'$'

Erläuterung

Schleife 2 * input length - 1für jede Reihe. Die String-Anzeigefunktion ( INT 21H,9) der DOS-API schreibt einen durch $-terminierten String auf den Bildschirm, sodass jedes Mal, wenn die Schleife durchlaufen wird, das Zeichen nach dem zuletzt anzuzeigenden mit dem Endterminator des Strings ausgetauscht wird.

Der Schleifenzähler wird mit der Länge der Zeichenfolge verglichen, und wenn er größer ist (dh der aufsteigende Teil der Ausgabe), wird die Zeichenfolge / Swap-Position inkrementiert, andernfalls wird sie dekrementiert (tatsächlich sind es -1-1+1weniger Bytes als bei einer if / else-Verzweigungsstruktur).

Ein eigenständiges ausführbares Programm, das die Eingabezeichenfolge von der Befehlszeile übernimmt.

Ausgabe

YT2.COM herunterladen (43 bytes)

• -1 Bytes dank Gastropner !

Python 2 , 60 52 Bytes

f=lambda s,n=1:s[n:]and[s[:n]]+f(s,n+1)+[s[:n]]or[s]

Probieren Sie es online!

Python 3.8 (Vorabversion) , 50 Byte

f=lambda s,n=1:s>(x:=s[:n])and[x,*f(s,n+1),x]or[s]

Probieren Sie es online!

MATL , 8 Bytes

nZv"G@:)

Probieren Sie es online!

Bitte mag diesen Beitrag für den Smiley :)im Code, für dessen Erstellung ich viel Zeit gebraucht habe.

n  % Length of the input string
Zv % Symmetric range ([1 2 ... n ... 1])
"  % For each k in above range
G  % Push input
@: % Push [1 2 ... k]
)  % Index

J , 11 Bytes

Anonyme implizite Präfixfunktion. Gibt eine mit Leerzeichen aufgefüllte Zeichenmatrix zurück.

[:(}:,|.)]\

Probieren Sie es online!

]\ die Liste der Präfixe

[:(… ) Wende die folgende Funktion auf diese Liste an

 |. die umgekehrte Liste

 , vorangestellt mit

 }: die verkürzte (ohne letzten Punkt) Liste

Perl 6 , 31 Bytes

{[\~](@_)[0...@_-1...0]}o*.comb

Probieren Sie es online!

Anonymer Codeblock, der eine Zeichenfolge akzeptiert und eine Liste von Zeilen zurückgibt.

Erläuterung:

{                      }o*.comb   # Pass the list of characters into the codeblock
 [\~](@_)                 # Triangular reduce by concatenation
                          # e.g. The list [1,2,3,4] turns into [1,12,123,1234]
         [0...@_-1        # Return the elements from 0 to length of string minus 1
                  ...0]   # And back down to 0

Japt- R , 4 Bytes

å+ ê

Kumulative Reduzierung einer Zeichenfolge.

-1 Byte dank @Shaggy

Probieren Sie es online!

Japt -R , 9 7 Bytes

-2 Bytes dank Shaggy

Êõ@¯XÃê

Probieren Sie es online!

Perl 5 ( -p), 26 Bytes

s,.,$\=$`.$/.$\;"$`$&
",ge

TIO

Haskell, 52 50 44 Bytes

f x=unlines$init<>reverse$scanr(\_->init)x x

• -2 Bytes durch eine Variante von Ørjan Johansens Trick
• -6 Bytes durch Ausnutzen voninstance Semigroup b => Semigroup (a -> b)

Probieren Sie es online!

R , 79 65 62 58 Byte

write(substring(s<-scan(,""),1,c(1:(r=nchar(s)),r-1:r)),1)

Probieren Sie es online!

-14 durch Giuseppes überlegenes Funktionswissen

-3 mit sauberer Indexierung

-4 dank Nick Kennedy und Giuseppes Umzug zu scanundwrite

Schleifen (und substr) zu vermeiden ist schön.

Gelee , 5 4 Bytes

-1 Byte Danke an @JonathanAllan !

¹ƤŒḄ

Probieren Sie es online! Ich denke, das ist meine zweite Gelee-Antwort? Ich weiß nicht, ob das optimal ist. Ich bin mehr davon überzeugt, dass es optimal ist. Gibt ein Array von Zeilen zurück.

Erläuterung

¹ƤŒḄ     input: "Hi!"
¹Ƥ       prefixes of the input: [["H"], ["H", "i"], ["H", "i", "!"]]
  ŒḄ     bounce, using each array: [["H"], ["H", "i"], ["H", "i", "!"], ["H", "i"], ["H"]]

Ein weiterer Ansatz, der von @JonathanAllan vorgeschlagen wurde, besteht darin ;\ŒḄ, die \Verkettung ( ;) kumulativ zu reduzieren , was eine weitere Möglichkeit darstellt, Präfixe zu generieren.

Python 3.8 (Vorabversion) , 48 Byte

lambda s,r='':(l:=[r:=r+c for c in s])+l[-2::-1]

Probieren Sie es online!

Verwendet Zuweisungsausdrücke mit :=, um eine Liste von Präfixen zu erstellen und das Ergebnis dann erneut zu speichern, um seine Umkehrung zu verketten (ohne das erste Zeichen).

Python 2 , 51 Bytes

f=lambda s,l=[]:s and f(s[:-1],[s]+l)or l+l[-2::-1]

Probieren Sie es online!

Wir haben fast die folgende schöne 45-Byte-Lösung, aber es hat die ursprüngliche Zeichenfolge zweimal und ich sehe keinen kurzen Weg, um dies zu beheben.

f=lambda s,l=[]:s and f(s[:-1],[s]+l+[s])or l

Probieren Sie es online!

Kohle , 5 Bytes

Ｇ^Ｌθθ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung: ＧZeichnet ein gefülltes Polygon, ^gibt an, dass die Seiten rechts und links unten sind (das Polygon schließt sich dann automatisch selbst), Ｌθgibt die Länge dieser Seiten als Länge der ursprünglichen Eingabe an und das Endergebnis θgibt die Füllzeichenfolge an.

C # (Visual C # Interactive Compiler) , 123 109 94 84 74 Byte

Angenommen, wir können ein char-Array-Array zurückgeben.

a=>new int[a.Length*2-1].Select((b,i)=>a.SkipLast(Math.Abs(a.Length-i-1)))

Probieren Sie es online!

Attache , 15 Bytes

Bounce@Prefixes

Probieren Sie es online!

Ziemlich einfach. Bounces (rückwärts ohne Mitte anhängen)Prefixes des Eingangs.

Alternativ 21 Byte: Bounce@{_[0..0:~-#_]} Präfix erneut implementieren.

Brachylog (v2), 6 Bytes

a₀ᶠ⊆.↔

Probieren Sie es online!

Funktionsübergabe, die ein Array von Zeilen zurückgibt. Lose basierend auf der Antwort von @ Fatalize .

Erläuterung

a₀ᶠ⊆.↔
    .↔  Find a palindrome
   ⊆      that contains, in order,
  ᶠ       all
a₀        prefixes of {the input}

Die Tiebreak-Reihenfolge wird hier durch die festgelegt ⊆, die bei Verwendung dieses Flussmusters die kürzestmögliche Ausgabe bevorzugt , wobei die Tiebroken durch die frühestmögliche Platzierung der angegebenen Elemente erfolgen . Die kürzestmögliche Ausgabe ist das, was wir hier wollen (da keine doppelten Präfixe möglich sind). Wenn Sie die angegebenen Elemente (dh die Präfixe) so früh wie möglich platzieren, werden sie in der ersten Hälfte (aufgerundet) der Ausgabe. Da wir auch verlangen, dass sie in der gleichen Reihenfolge angeordnet werden, erhalten wir zufällig genau das Muster, das wir benötigen, obwohl die Beschreibung, die wir Brachylog gegeben haben, sehr allgemein ist. Die Tiebreaks funktionieren genau richtig, sodass Brachylog die Ausgabe auswählt, die wir möchten, und nicht irgendeine andere Ausgabe, die der Beschreibung entspricht.

PowerShell, 89 87 66 Bytes

-2 Bytes dank @AdmBorkBork

param($a)0..($d=$a.Length-1)|%{$b+=,-join$a[0..$_]};$b+$b[--$d..0]

Probieren Sie es online!

Es hat tatsächlich nicht wie angegeben funktioniert, sorry! Ich habe es bearbeitet und es auch geschafft, einige Bytes weg zu rasieren.

PowerShell , 46 Byte

($l=$args|% t*y|%{($s+=$_);++$i})+$l[$i..0]|gu

Probieren Sie es online!

PowerShell , 42 Bytes (YouTube Spezial, Dirty)

Es ist bekannt, dass die maximale Länge eines Kommentars auf YouTube 10.000 Zeichen beträgt. Ok, benutze dies als obere Grenze.

($l=$args|% t*y|%{($s+=$_)})+$l[1e4..0]|gu

Probieren Sie es online!

APL (Dyalog Unicode) , 9 Byte ^SBCS

Anonyme implizite Präfixfunktion. Gibt eine Liste von Zeichenfolgen zurück.

(⊢,1↓⌽),\

Probieren Sie es online!

,\ die Liste der Präfixe (beleuchtet, die kumulative Verkettung)

(… ) Wende die folgende Funktion auf diese Liste an:

 ⌽ die umgekehrte Liste

 1↓ Lass den ersten Gegenstand fallen

 , voranstellen

 ⊢ die unveränderte Liste

Ruby , 51 42 40 Bytes

f=->s,i=1{s[i]?[t=s[0,i],*f[s,i+1],t]:s}

Probieren Sie es online!

Danke an Doorknob für -2 Bytes.

JavaScript (Node.js) , 90 Byte

Dies kann wahrscheinlich viel mehr Golf gespielt werden, Arnauld hat bereits einen viel kürzeren, aber ich hatte zumindest Spaß!

s=>{a=[];for(c=s.length-1;c--;)a[c]=s.slice(0,c+1);return[...a,s,...a.reverse()].join`\n`}

Probieren Sie es online!

SNOBOL4 (CSNOBOL4) , 118 Bytes

	N =INPUT
	L =1
1	X =LT(X,SIZE(N)) X + 1	:F(D)
O	N ARB . OUTPUT POS(X)	:($L)
D	X =GT(X) X - 1	:F(END)
	L ='D'	:(O)
END

Probieren Sie es online!

Es scheint einen Fehler in dieser Implementierung von SNOBOL zu geben. Der Versuch, das Etikett Ddurch das Etikett zu ersetzen, 2führt zu einem Fehler, obwohl das Handbuch für Vanilla SNOBOL dies anzeigt (Hervorhebung hinzugefügt).

Wenn eine Beschriftung vorhanden ist, muss sie mit dem ersten Zeichen der Zeile beginnen. Beschriftungen geben einen Namen für die Anweisung an und dienen als Ziel für die Übertragung der Kontrolle aus dem GOTO-Feld einer Anweisung. Beschriftungen müssen mit einem Buchstaben oder einer Ziffer beginnen, optional gefolgt von einer beliebigen Zeichenfolge. Das Beschriftungsfeld wird mit einem Leerzeichen, einem Tabulator oder einem Semikolon abgeschlossen. Wenn das erste Zeichen einer Zeile leer oder ein Tabulator ist, fehlt das Beschriftungsfeld.

Ich gehe davon aus, dass der CSNOBOL-Interpreter nur eine einzige Bezeichnung unterstützt, die mit einer Ganzzahl beginnt.

APL + WIN, 31 Bytes

Eingabeaufforderung für Zeichenfolge:

 ⊃((⍳n),1↓⌽⍳n)↑¨(¯1+2×n←⍴s)⍴⊂s←⎕

Erläuterung:

(¯1+2×n←⍴s)⍴⊂s create a nested vector of the string of length =1+2x length of string

((⍳n),1↓⌽⍳n)↑¨ progressively select elements from each element of the nested vector 
              following the pattern 1  2 ...to n to n-1 ... 1

⊃ convert nested vector into a 2d array.

F # (.NET Core) , 67 61 Bytes

let l=s.Length
[1..l*2-1]|>Seq.map(fun i->s.[..l-abs(i-l)-1])

Probieren Sie es online!

Input ist a stringund Output ist aseq<string>

Eine andere Lösung könnte let f(s:string)=for i=1 to s.Length*2-1 do printfn"%s"s.[..s.Length-abs(i-s.Length)-1]für 80ish Bytes sein ... Ich bin nicht sicher, ob es sich lohnt, sie zu untersuchen.

sed , 31 35 bytes

:x
h
s/.\n.*\|.$//
/^$/{x;q}
H
G
bx

Probieren Sie es online!

Erläuterung

Zu Beginn jeder Iteration der Schleife ist der Musterraum ein "zentraler Teil" der gewünschten Ausgabe, und jede Schleife fügt eine verkürzte Kopie oben und unten hinzu.

:x                 
h                  Copy the current chunk to hold space
s/.\n.*\|.$//      Remove the last letter of the first line, and all other lines (if there are any)
/^$/{x;q}          If pattern space is empty we're done; output hold space
H                  Add the shortened line to the end of hold space
G                  and add the new hold space to pattern space.
bx                 

Python 2 , 131 100 84 Bytes

Meine erste Antwort auf Code Golf!

-47 Bytes insgesamt dank @ SriotchilismO'Zaic

a,b=[],len(x)
for i in range(2*b-1):
 if i<b:a+=x[i]
 else:a=a[:-1]
 print''.join(a)

Probieren Sie es online!

J , 12 Bytes

]\,[:}.@|.]\

Probieren Sie es online!

Immer noch 1 Byte länger als bei Adám

K (oK) , 12 11 Bytes

-1 Byte dank ngn

{x,1_|x}@,\

Probieren Sie es online!