Hold up ..... questo non è traina.

sfondo

In questi giorni su YouTube, le sezioni dei commenti sono disseminate di tali schemi:

S
St
Str
Stri
Strin
String
Strin
Stri
Str
St
S

dove Stringè un semplice segnaposto e si riferisce a qualsiasi combinazione di personaggi. Questi schemi sono generalmente accompagnati da una It took me a lot of time to make this, pls likeo qualcosa del genere e spesso l'OP riesce ad accumulare un numero di Mi piace.

L'obiettivo

Sebbene tu abbia un grande talento nell'accumulare voti su PPCG con le tue affascinanti abilità nel golf, non sei sicuramente la scelta migliore per fare commenti arguti o fare riferimento a meme nelle sezioni dei commenti di YouTube. Pertanto, i tuoi commenti costruttivi fatti con pensiero deliberato accumulano pochi o nessun "mi piace" su YouTube. Vuoi che questo cambi. Quindi, ricorri a creare i modelli di cliché sopra menzionati per raggiungere la tua massima ambizione, ma senza perdere tempo a cercare di scriverli manualmente.

In poche parole, il tuo compito è quello di prendere una stringa, diciamo s, e produrre 2*s.length - 1sottostringhe di s, delimitate da una nuova riga, in modo da rispettare il seguente schema:

(per s= "Ciao")

H
He
Hel
Hell
Hello
Hell
Hel
He
H

Ingresso

Una singola stringa s. Si applicano le impostazioni predefinite di input della community. Si può presumere che la stringa di input conterrà solo caratteri ASCII stampabili.

Produzione

Diverse linee separate da una nuova riga, che costituisce un modello appropriato come spiegato sopra. Si applicano le impostazioni predefinite di output della community. Sono consentite linee vuote iniziali e finali (che non contengono caratteri o caratteri che non possono essere visti, come uno spazio) nell'output.

Test Case

Un caso di test composto da più parole:

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

Si noti che ci sono distorsioni apparenti nella forma dell'output del test case sopra (ad esempio, la riga due e la riga tre dell'output appaiono uguali). Questi sono perché non possiamo vedere gli spazi bianchi finali. Il tuo programma NON deve cercare di correggere queste distorsioni.

Criterio vincente

Questo è code-golf , quindi vince il codice più breve in byte in ogni lingua!

Brainfuck , 32 byte

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

Provalo online!

Lo stesso loop viene utilizzato per entrambe le metà del motivo.

Spiegazione:

,             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

Provalo online!

Commentate

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 byte

^{Cancellato non  4 è più 4 :)}

η.∊

Provalo online o verifica tutti i casi di test .

Spiegazione:

η     # 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)

Nella nuova versione di 05AB1E, ed esplicito »è richiesto dopo il η, motivo per cui uso la versione legacy di 05AB1E qui per salvare un byte.

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

smontato:

    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,'$'

Spiegazione

Loop 2 * input length - 1per ogni riga. La funzione di visualizzazione delle stringhe dell'API DOS ( INT 21H,9) scrive una $stringa terminata sullo schermo, quindi ogni volta attraverso il ciclo il carattere dopo l'ultimo da visualizzare viene scambiato con il terminatore di fine stringa.

Il contatore di loop viene confrontato con la lunghezza della stringa e se è maggiore (ovvero la parte ascendente dell'output) la posizione stringa / scambio viene incrementata, altrimenti viene diminuita (in realtà è -1-1+1che è meno byte di una struttura ramificata if / else).

Programma eseguibile autonomo, accetta la stringa di input dalla riga di comando.

Produzione

Scarica YT2.COM (43 byte)

• -1 byte grazie a gastropner !

Python 2 , 60 52 byte

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

Provalo online!

Python 3.8 (pre-release) , 50 byte

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

Provalo online!

MATL , 8 byte

nZv"G@:)

Provalo online!

Per favore, mi piace questo post per lo smiley :)nel codice che mi ci è voluto molto tempo per farlo.

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 byte

Funzione prefisso tacito anonimo. Restituisce una matrice di caratteri riempita di spazio.

[:(}:,|.)]\

Provalo online!

]\ l'elenco dei prefissi

[:(... ) applica la seguente funzione a quell'elenco

 |. l'elenco inverso

 , anteposto a

 }: l'elenco ridotto (senza l'ultimo elemento)

Perl 6 , 31 byte

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

Provalo online!

Blocco di codice anonimo che accetta una stringa e restituisce un elenco di righe.

Spiegazione:

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

å+ ê

Riduzione cumulativa su una stringa.

-1 byte grazie a @Shaggy

Provalo online!

Japt -R , 9 7 byte

-2 byte grazie a Shaggy

Êõ@¯XÃê

Provalo online!

Perl 5 ( -p), 26 byte

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

TIO

Haskell, 52 50 44 byte

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

• -2 byte da una variante del trucco di Ørjan Johansen
• -6 byte sfruttandoinstance Semigroup b => Semigroup (a -> b)

Provalo online!

R , 79 65 62 58 byte

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

Provalo online!

-14 dalla conoscenza della funzione superiore di Giuseppe

-3 con indicizzazione più pulita

-4 grazie al passaggio di Nick Kennedy e Giuseppe a scanewrite

Evitare i loop (e substr) è bello.

Gelatina , 5 4 byte

-1 byte grazie a @JonathanAllan !

¹ƤŒḄ

Provalo online! Penso che questa sia la mia seconda risposta Jelly? Non so se sia ottimale. Sono più convinto che sia ottimale. Restituisce una matrice di linee.

Spiegazione

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

Un altro approccio, proposto da @JonathanAllan, è ;\ŒḄ, che riduce cumulativamente ( \) la concatenazione ( ;), che è un altro modo per generare prefissi.

Python 3.8 (pre-release) , 48 byte

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

Provalo online!

Utilizza espressioni di assegnazione con :=per accumulare un elenco di prefissi e poi di nuovo per salvare il risultato per concatenare il suo contrario (senza il primo carattere).

Python 2 , 51 byte

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

Provalo online!

Abbiamo quasi la seguente bella soluzione a 45 byte, ma ha la stringa originale due volte e non vedo un modo breve per risolvere questo problema.

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

Provalo online!

Carbone , 5 byte

Ｇ^Ｌθθ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: Ｇdisegna un poligono pieno, ^specifica che i lati sono in basso a destra e in basso a sinistra (il poligono si chiude automaticamente), Ｌθspecifica la lunghezza di quei lati come la lunghezza dell'input originale e il finale θspecifica la stringa di riempimento.

C # (compilatore interattivo Visual C #) , 123 109 94 84 74 byte

Presuppone che possiamo restituire un array di array di caratteri (credo che possiamo, poiché un array di caratteri è una rappresentazione valida per una stringa e un array di stringhe è una rappresentazione valida per più righe)

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

Provalo online!

Attache , 15 byte

Bounce@Prefixes

Provalo online!

Abbastanza semplice. Bounces (aggiunge il rovescio senza centro) Prefixesdell'input.

In alternativa, 21 byte Bounce@{_[0..0:~-#_]} :, reimplementazione del prefisso.

Brachylog (v2), 6 byte

a₀ᶠ⊆.↔

Provalo online!

Invio di funzioni, restituendo una matrice di righe. Liberamente basato sulla risposta di @ Fatalize .

Spiegazione

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

L'ordine di tie-break qui è impostato da ⊆, che, se usato con questo schema di flusso, preferisce il più breve output possibile, interrotto posizionando gli elementi dati il ​​prima possibile . L'output più breve possibile è ciò che vogliamo qui (poiché non è possibile avere prefissi duplicati) e posizionando gli elementi dati (cioè i prefissi) il prima possibile li inserirai nella prima metà (arrotondata per eccesso) del produzione. Dato che stiamo anche richiedendo che vengano posizionati nello stesso ordine, ci capita di ottenere esattamente lo schema di cui abbiamo bisogno anche se la descrizione che abbiamo dato a Brachylog è molto generale; i tiebreak si risolvono esattamente, facendo sì che Brachylog scelga l'output che vogliamo piuttosto che qualche altro output che obbedisce alla descrizione.

PowerShell, 89 87 66 byte

-2 byte grazie a @AdmBorkBork

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

Provalo online!

In realtà non ha funzionato come specificato prima, mi dispiace per quello! L'ho modificato e sono anche riuscito a radere qualche byte.

PowerShell , 46 byte

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

Provalo online!

PowerShell , 42 byte (YouTube Special, sporco)

È noto che la lunghezza massima di un commento su YouTube è di 10.000 caratteri. Ok, usa questo come limite superiore.

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

Provalo online!

APL (Dyalog Unicode) , ^{SBCS da} 9 byte

Funzione prefisso tacito anonimo. Restituisce un elenco di stringhe.

(⊢,1↓⌽),\

Provalo online!

,\ l'elenco dei prefissi (acceso, la concatenazione cumulativa)

(... ) applica la seguente funzione a quell'elenco:

 ⌽ l'elenco invertito

 1↓ rilascia il primo oggetto

 , anteporre

 ⊢ l'elenco non modificato

Rubino , 51 42 40 byte

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

Provalo online!

Grazie a Doorknob per -2 byte.

JavaScript (Node.js) , 90 byte

Probabilmente questo può essere giocato molto di più, Arnauld ha già un modo più breve ma mi sono divertito almeno!

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

Provalo online!

SNOBOL4 (CSNOBOL4) , 118 byte

	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

Provalo online!

Sembra che ci sia un bug in questa implementazione di SNOBOL; il tentativo di sostituire l'etichetta Dcon l'etichetta 2provoca un errore, sebbene il manuale di Vanilla SNOBOL indichi che (enfasi aggiunta)

Se è presente un'etichetta, deve iniziare con il primo carattere della riga. Le etichette forniscono un nome per l'istruzione e fungono da destinazione per il trasferimento del controllo dal campo GOTO di qualsiasi istruzione. Le etichette devono iniziare con una lettera o una cifra, eventualmente seguita da una stringa arbitraria di caratteri. Il campo dell'etichetta viene terminato dal carattere vuoto, dalla scheda o dal punto e virgola. Se il primo carattere di una riga è vuoto o tab, il campo etichetta è assente.

La mia supposizione è che l'interprete CSNOBOL supporti solo una singola etichetta che inizia con un numero intero.

APL + WIN, 31 byte

Richiede l'immissione di una stringa:

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

Spiegazione:

(¯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 byte

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

Provalo online!

Input è a stringe output è aseq<string>

Un'altra soluzione potrebbe essere let f(s:string)=for i=1 to s.Length*2-1 do printfn"%s"s.[..s.Length-abs(i-s.Length)-1]per 80 byte ... Non sono sicuro che valga la pena esaminarlo.

sed , 31 35 byte

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

Provalo online!

Spiegazione

All'inizio di ogni iterazione del ciclo, lo spazio del modello è un "pezzo centrale" dell'output desiderato e ogni ciclo aggiunge una copia abbreviata all'inizio e alla fine.

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

La mia prima risposta su Code Golf!

-47 byte complessivi grazie a @ 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)

Provalo online!

J , 12 byte

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

Provalo online!

Ancora 1 byte più lungo di quello di Adám

K (oK) , 12 11 byte

-1 byte grazie a ngn

{x,1_|x}@,\

Provalo online!