Espera ... esto no es trolling.

Antecedentes

En estos días en YouTube, las secciones de comentarios están llenas de tales patrones:

S
St
Str
Stri
Strin
String
Strin
Stri
Str
St
S

donde Stringes un simple marcador de posición y se refiere a cualquier combinación de caracteres. Estos patrones suelen ir acompañados de un It took me a lot of time to make this, pls likeo algo, y a menudo el OP tiene éxito en acumular una serie de Me gusta.

La tarea

Aunque tiene un gran talento para acumular votos positivos en PPCG con sus encantadoras habilidades de golf, definitivamente no es la mejor opción para hacer comentarios ingeniosos o hacer memes de referencia en las secciones de comentarios de YouTube. Por lo tanto, sus comentarios constructivos hechos con un pensamiento deliberado acumulan algunos 'me gusta' en YouTube. Quieres que esto cambie. Por lo tanto, recurre a hacer los patrones cliché mencionados anteriormente para lograr su máxima ambición, pero sin perder tiempo tratando de escribirlos manualmente.

En pocas palabras, su tarea es tomar una cadena, digamos s, y generar 2*s.length - 1subcadenas de s, delimitadas por una nueva línea, para cumplir con el siguiente patrón:

(para s= "Hola")

H
He
Hel
Hell
Hello
Hell
Hel
He
H

Entrada

Una sola cuerda s. Se aplican los valores predeterminados de entrada de la comunidad. Puede suponer que la cadena de entrada solo contendrá caracteres ASCII imprimibles.

Salida

Varias líneas separadas por una nueva línea, que constituyen un patrón apropiado como se explicó anteriormente. Se aplican los valores predeterminados de salida de la comunidad. Se permiten líneas en blanco iniciales y finales (que no contienen caracteres o caracteres que no se pueden ver, como un espacio) en la salida.

Caso de prueba

Un caso de prueba de varias palabras:

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

Tenga en cuenta que hay distorsiones aparentes en la forma de salida del caso de prueba anterior (por ejemplo, la línea dos y la línea tres de la salida parecen iguales). Esos son porque no podemos ver los espacios en blanco finales. Su programa NO necesita tratar de corregir estas distorsiones.

Criterio ganador

Este es el código de golf , por lo que gana el código más corto en bytes en cada idioma.

brainfuck , 32 bytes

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

Pruébalo en línea!

El mismo bucle se usa para ambas mitades del patrón.

Explicación:

,             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 bytes

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

Pruébalo en línea!

Comentado

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 (heredado) ,  4  3 bytes

^{Tachado ya  4 no es 4 :)}

η.∊

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

En la nueva versión de 05AB1E, y »se requiere explícito después de η, por lo que uso la versión heredada de 05AB1E aquí para guardar un byte.

IBM PC DOS, ensamblaje 8088,  44  43

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

Desmontado:

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

Explicación

Bucle 2 * input length - 1para cada fila. La función de visualización de cadenas ( INT 21H,9) de la API de DOS escribe una $cadena terminada en la pantalla, por lo que cada vez que se realiza el bucle, el carácter después del último que se muestra se intercambia con el terminador de fin de cadena.

El contador de bucle se compara con la longitud de la cadena, y si es mayor (es decir, la parte ascendente de la salida), la posición de cadena / intercambio se incrementa, de lo contrario, se reduce (en realidad, -1-1+1es menos bytes que una estructura de ramificación if / else).

Programa ejecutable independiente, toma la cadena de entrada de la línea de comando.

Salida

Descargar YT2.COM (43 bytes)

• -1 bytes gracias a gastropner !

Python 2 , 60 52 bytes

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

Pruébalo en línea!

Python 3.8 (prelanzamiento) , 50 bytes

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

Pruébalo en línea!

MATL , 8 bytes

nZv"G@:)

Pruébalo en línea!

:)Me gusta esta publicación para el smiley en el código que me tomó mucho tiempo hacer.

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

Función de prefijo tácito anónimo. Devuelve una matriz de caracteres rellena de espacio.

[:(}:,|.)]\

Pruébalo en línea!

]\ la lista de prefijos

[:(... ) aplique la siguiente función a esa lista

 |. la lista inversa

 , antepuesto con

 }: la lista restringida (sin el último elemento)

Perl 6 , 31 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma una cadena y devuelve una lista de líneas.

Explicación:

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

å+ ê

Reducción acumulativa en una cadena.

-1 byte gracias a @Shaggy

Pruébalo en línea!

Japt -R , 9 7 bytes

-2 bytes gracias a Shaggy

Êõ@¯XÃê

Pruébalo en línea!

Perl 5 ( -p), 26 bytes

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

TIO

Haskell 52 50 44 bytes

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

• -2 bytes por una variante del truco de Ørjan Johansen
• -6 bytes aprovechandoinstance Semigroup b => Semigroup (a -> b)

Pruébalo en línea!

R , 79 65 62 58 bytes

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

Pruébalo en línea!

-14 por el conocimiento superior de la función de Giuseppe

-3 con indexación más limpia

-4 gracias al movimiento de Nick Kennedy y Giuseppe hacia scanywrite

Evitar bucles (y substr) es bueno.

Jalea , 5 4 bytes

-1 byte gracias a @JonathanAllan !

¹ƤŒḄ

Pruébalo en línea! Creo que esta es mi segunda respuesta Jelly? No sé si esto es óptimo. Estoy más convencido de que es óptimo. Devuelve una matriz de líneas.

Explicación

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

Otro enfoque, propuesto por @JonathanAllan, es ;\ŒḄ, que reduce de forma acumulativa ( \) la concatenación ( ;), que es otra forma de generar prefijos.

Python 3.8 (prelanzamiento) , 48 bytes

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

Pruébalo en línea!

Utiliza expresiones de asignación con :=para acumular una lista de prefijos y luego nuevamente para guardar el resultado para concatenar su reverso (sin el primer carácter).

Python 2 , 51 bytes

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

Pruébalo en línea!

Casi tenemos la siguiente buena solución de 45 bytes, pero tiene la cadena original dos veces y no veo una forma corta de solucionarlo.

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

Pruébalo en línea!

Carbón de leña , 5 bytes

Ｇ^Ｌθθ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: Ｇdibuja un polígono relleno, ^especifica que los lados están abajo a la derecha y abajo a la izquierda (el polígono se cierra automáticamente), Ｌθespecifica la longitud de esos lados como la longitud de la entrada original y el final θespecifica la cadena de relleno.

C # (Visual C # interactivo Compilador) , 123 109 94 84 74 bytes

Asume que podemos devolver una matriz de matriz de caracteres (creo que podemos hacerlo, ya que una matriz de caracteres es una representación válida para una cadena y una matriz de cadenas es una representación válida para varias líneas)

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

Pruébalo en línea!

Adjunto , 15 bytes

Bounce@Prefixes

Pruébalo en línea!

Bastante simple. Bounces (se agrega al reverso sin centro) Prefixesde la entrada.

Alternativamente, 21 bytes: Bounce@{_[0..0:~-#_]} reiniciando el prefijo.

Brachylog (v2), 6 bytes

a₀ᶠ⊆.↔

Pruébalo en línea!

Envío de funciones, devolviendo una serie de líneas. Basada en la respuesta de @ Fatalize .

Explicación

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

El orden de desempate aquí se establece mediante el ⊆que, cuando se usa con este patrón de flujo, prefiere la salida más corta posible, se rompe al colocar los elementos dados lo antes posible . El resultado más corto posible es lo que queremos aquí (debido a que no es posible tener prefijos duplicados), y colocar los elementos dados (es decir, los prefijos) lo antes posible los colocará en la primera mitad (redondeada) salida. Dado que también estamos exigiendo que se coloquen en el mismo orden, obtenemos exactamente el patrón que necesitamos a pesar de que la descripción que le dimos a Brachylog es muy general; los desempates resultan exactamente correctos, lo que hace que Brachylog elija la salida que queremos en lugar de alguna otra salida que obedezca a la descripción.

PowerShell, 89 87 66 bytes

-2 bytes gracias a @AdmBorkBork

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

Pruébalo en línea!

En realidad no funcionó como se especificó antes, ¡perdón por eso! Lo edité y también logré eliminar algunos bytes.

PowerShell , 46 bytes

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

Pruébalo en línea!

PowerShell , 42 bytes (especial de YouTube, sucio)

Se sabe que la longitud máxima de un comentario en YouTube es de 10.000 caracteres. Ok, usa esto como el límite superior.

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

Pruébalo en línea!

APL (Dyalog Unicode) , ^{SBCS de} 9 bytes

Función de prefijo tácito anónimo. Devuelve la lista de cadenas.

(⊢,1↓⌽),\

Pruébalo en línea!

,\ la lista de prefijos (encendido, la concatenación acumulativa)

(... ) aplique la siguiente función a esa lista:

 ⌽ la lista invertida

 1↓ suelte el primer elemento

 , anteponer

 ⊢ la lista no modificada

Ruby , 51 42 40 bytes

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

Pruébalo en línea!

Gracias a Doorknob por -2 bytes.

JavaScript (Node.js) , 90 bytes

Esto probablemente se pueda jugar mucho más, Arnauld ya tiene uno mucho más corto, ¡pero me divertí al menos!

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

Pruébalo en línea!

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

Pruébalo en línea!

Parece que hay un error en esta implementación de SNOBOL; intentar reemplazar la etiqueta Dcon la etiqueta 2causa un error, aunque el manual de Vanilla SNOBOL indica que (énfasis agregado)

Si hay una etiqueta, debe comenzar con el primer carácter de la línea. Las etiquetas proporcionan un nombre para la declaración y sirven como objetivo para la transferencia de control desde el campo GOTO de cualquier declaración. Las etiquetas deben comenzar con una letra o dígito, opcionalmente seguido de una cadena arbitraria de caracteres. El campo de etiqueta termina con el carácter en blanco, tabulador o punto y coma. Si el primer carácter de una línea está en blanco o tabulador, el campo de etiqueta está ausente.

Mi suposición es que el intérprete CSNOBOL solo admite una sola etiqueta que comienza con un número entero.

APL + WIN, 31 bytes

Solicitudes de entrada de cadena:

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

Explicación:

(¯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])

Pruébalo en línea!

La entrada es un string y la salida es aseq<string>

Otra solución podría ser let f(s:string)=for i=1 to s.Length*2-1 do printfn"%s"s.[..s.Length-abs(i-s.Length)-1]para 80ish bytes ... No estoy seguro de que valga la pena analizarlo.

sed , 31 35 bytes

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

Pruébalo en línea!

Explicación

Al comienzo de cada iteración del bucle, el espacio del patrón es un "fragmento central" de la salida deseada, y cada bucle agrega una copia acortada en la parte superior e inferior.

: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

Mi primera respuesta en Code Golf!

-47 bytes en general gracias 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)

Pruébalo en línea!

J , 12 bytes

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

Pruébalo en línea!

Todavía 1 byte más que el de Adám

K (oK) , 12 11 bytes

-1 byte gracias a ngn

{x,1_|x}@,\

Pruébalo en línea!