Espere ... isso não é corrico.

fundo

Atualmente, no YouTube, as seções de comentários estão repletas de padrões:

S
St
Str
Stri
Strin
String
Strin
Stri
Str
St
S

onde Stringé um mero marcador de posição e refere-se a qualquer combinação de caracteres. Esses padrões são geralmente acompanhados por um It took me a lot of time to make this, pls likeou algo assim, e muitas vezes o OP consegue reunir vários gostos.

A tarefa

Embora você tenha um grande talento para acumular votos positivos no PPCG com suas habilidades encantadoras de golfe, você definitivamente não é a melhor opção para fazer comentários espirituosos ou fazer referência a memes nas seções de comentários do YouTube. Assim, seus comentários construtivos feitos com pensamento deliberado acumulam alguns "gostos" no YouTube. Você quer que isso mude. Portanto, você recorre aos padrões clichês mencionados acima para alcançar sua ambição final, mas sem perder tempo tentando escrevê-los manualmente.

Simplificando, sua tarefa é pegar uma string, digamos s, e 2*s.length - 1gerar substrings sdelimitadas por uma nova linha, de modo a cumprir o seguinte padrão:

(para s= "Olá")

H
He
Hel
Hell
Hello
Hell
Hel
He
H

Entrada

Uma única sequência s. Os padrões de entrada da comunidade se aplicam. Você pode assumir que a sequência de entrada conterá apenas caracteres ASCII imprimíveis.

Resultado

Várias linhas separadas por uma nova linha, constituindo um padrão apropriado, conforme explicado acima. Os padrões de saída da comunidade se aplicam. Linhas em branco à esquerda e à direita (que não contêm caracteres ou caracteres que não podem ser vistos, como um espaço) na saída são permitidas.

Caso de teste

Um caso de teste com várias palavras:

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

Observe que há distorções aparentes no formato da saída do caso de teste acima (por exemplo, a linha dois e a linha três da saída parecem iguais). Isso ocorre porque não podemos ver os espaços em branco à direita. Seu programa NÃO precisa tentar corrigir essas distorções.

Critério vencedor

Isso é código-golfe , então o código mais curto em bytes em cada idioma vence!

brainfuck , 32 bytes

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

Experimente online!

O mesmo loop é usado para as duas metades do padrão.

Explicação:

,             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

Experimente online!

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

^{Riscado  4 já não é 4 :)}

η.∊

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Na nova versão do 05AB1E, »é necessário explícito após o η, e é por isso que eu uso a versão herdada do 05AB1E aqui para salvar um byte.

IBM PC DOS, montagem 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,'$'

Explicação

Loop 2 * input length - 1para cada linha. A função de exibição de seqüência de caracteres da API do DOS ( INT 21H,9) grava uma $seqüência de caracteres terminada na tela, portanto, toda vez que o loop é executado, o caractere após o último a ser exibido é trocado pelo terminador de fim de sequência.

O contador de loop é comparado com o comprimento da string e, se for maior (significando a parte ascendente da saída), a posição da string / swap é incrementada; caso contrário, é decrementada (na verdade, -1-1+1são menos bytes que uma estrutura de ramificação if / else).

Programa executável autônomo, pega a string de entrada da linha de comando.

Resultado

Download YT2.COM (43 bytes)

• -1 bytes graças ao gastropner !

Python 2 , 60 52 bytes

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

Experimente online!

Python 3.8 (pré-lançamento) , 50 bytes

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

Experimente online!

MATL , 8 bytes

nZv"G@:)

Experimente online!

Por favor, goste deste post para o smiley :)no código que demorei muito tempo para fazer.

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

Função de prefixo tácito anônimo. Retorna uma matriz de caracteres preenchida com espaço.

[:(}:,|.)]\

Experimente online!

]\ a lista de prefixos

[:(… ) Aplique a seguinte função a essa lista

 |. a lista inversa

 , anexado com

 }: a lista reduzida (sem último item)

Perl 6 , 31 bytes

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

Experimente online!

Bloco de código anônimo que pega uma string e retorna uma lista de linhas.

Explicação:

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

å+ ê

Redução cumulativa em uma string.

-1 byte graças a @Shaggy

Experimente online!

Japonês -R , 9 7 bytes

-2 bytes graças a Shaggy

Êõ@¯XÃê

Experimente 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 por uma variante do truque de Ørjan Johansen
• -6 bytes, aproveitando as vantagensinstance Semigroup b => Semigroup (a -> b)

Experimente online!

R , 79 65 62 58 bytes

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

Experimente online!

-14 pelo conhecimento da função superior de Giuseppe

-3 com indexação mais limpa

-4 graças à mudança de Nick Kennedy e Giuseppe para scanewrite

Evitar loops (e substr) é bom.

Geléia , 5 4 bytes

-1 byte graças a @ JonathanAllan !

¹ƤŒḄ

Experimente online! Eu acho que esta é a minha segunda resposta Jelly? Não sei se isso é ótimo. Estou mais convencido de que isso é ótimo. Retorna uma matriz de linhas.

Explicação

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

Outra abordagem, proposta por @ JonathanAllan, é a ;\ŒḄque reduz cumulativamente ( \) a concatenação ( ;), que é outra maneira de gerar prefixos.

Python 3.8 (pré-lançamento) , 48 bytes

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

Experimente online!

Usa expressões de atribuição com :=para acumular uma lista de prefixos e, em seguida, novamente para salvar o resultado para concatenar seu reverso (sem o primeiro caractere).

Python 2 , 51 bytes

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

Experimente online!

Quase temos a seguinte solução agradável de 45 bytes, mas ela possui a string original duas vezes e não vejo uma maneira curta de corrigir isso.

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

Experimente online!

Carvão , 5 bytes

Ｇ^Ｌθθ

Experimente online! Link é a versão detalhada do código. Explicação: Ｇdesenha um polígono preenchido, ^especifica que os lados estão para baixo à direita e para baixo à esquerda (o polígono se fecha automaticamente), Ｌθespecifica o comprimento desses lados como sendo o comprimento da entrada original e o final θespecifica a sequência de preenchimento.

C # (Compilador interativo do Visual C #) , 123 109 94 84 84 bytes

Supõe que podemos retornar uma matriz de matriz de caracteres (acredito que podemos, pois uma matriz de caracteres é uma representação válida para uma string e uma matriz de strings é uma representação válida para várias linhas)

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

Experimente online!

Anexo , 15 bytes

Bounce@Prefixes

Experimente online!

Bem simples. Bounces (acrescenta reverso sem centro) o Prefixesda entrada.

Como alternativa, 21 bytes Bounce@{_[0..0:~-#_]} :, reimplementando o prefixo.

Braquilog (v2), 6 bytes

a₀ᶠ⊆.↔

Experimente online!

Envio de função, retornando uma matriz de linhas. Vagamente baseado na resposta de @ Fatalize .

Explicação

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

A ordem de desempate aqui é definida pelo ⊆, que, quando usado com esse padrão de fluxo, prefere a saída mais curta possível, com quebra de empate, colocando os elementos fornecidos o mais cedo possível . A saída mais curta possível é o que queremos aqui (porque não é possível ter prefixos duplicados), e colocar os elementos fornecidos (ou seja, os prefixos) o mais cedo possível os colocará na primeira metade (arredondada para cima) do resultado. Como também exigimos que eles sejam colocados na mesma ordem, obtemos exatamente o padrão necessário, embora a descrição que fornecemos ao Brachylog seja muito geral; acontece que os tiebreaks funcionam exatamente da maneira certa, fazendo com que o Brachylog escolha a saída que queremos, em vez de alguma outra saída que obedeça à descrição.

PowerShell, 89 87 66 bytes

-2 bytes graças a @AdmBorkBork

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

Experimente online!

Na verdade, não funcionou como especificado antes, desculpe por isso! Eu editei e também consegui raspar alguns bytes.

PowerShell , 46 bytes

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

Experimente online!

PowerShell , 42 bytes (especial do YouTube, sujo)

Sabe-se que o tamanho máximo de um comentário no youtube é de 10.000 caracteres. Ok, use isso como o limite superior.

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

Experimente online!

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

Função de prefixo tácito anônimo. Retorna a lista de strings.

(⊢,1↓⌽),\

Experimente online!

,\ a lista de prefixos (lit, a concatenação cumulativa)

(… ) Aplique a seguinte função a essa lista:

 ⌽ a lista invertida

 1↓ largue o primeiro item

 , preceder

 ⊢ a lista não modificada

Ruby , 51 42 40 bytes

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

Experimente online!

Graças à maçaneta da porta por -2 bytes.

JavaScript (Node.js) , 90 bytes

Provavelmente isso pode ser jogado muito mais, Arnauld já tem um caminho bem mais curto, mas eu me diverti pelo menos!

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

Experimente 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

Experimente online!

Parece haver um erro nesta implementação do SNOBOL; tentar substituir o rótulo Dpelo rótulo 2causa um erro, embora o manual do Vanilla SNOBOL indique isso (ênfase adicionada)

Se um rótulo estiver presente, ele deverá começar com o primeiro caractere da linha. Os rótulos fornecem um nome para a declaração e servem como destino para a transferência de controle do campo GOTO de qualquer declaração. Os rótulos devem começar com uma letra ou dígito, opcionalmente seguido por uma sequência arbitrária de caracteres. O campo do rótulo é finalizado pelo caractere em branco, guia ou ponto e vírgula. Se o primeiro caractere de uma linha estiver em branco ou tabulado, o campo do rótulo estará ausente.

Minha suposição é que o interpretador CSNOBOL suporta apenas um único rótulo que começa com um número inteiro.

APL + WIN, 31 bytes

Solicita a entrada da string:

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

Explicação:

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

Experimente online!

A entrada é a stringe a saída é umaseq<string>

Outra solução pode 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 bytes 80ish ... Não tenho certeza de que vale a pena investigar.

sed , 31 35 bytes

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

Experimente online!

Explicação

No início de cada iteração do loop, o espaço do padrão é um "pedaço central" da saída desejada e cada loop adiciona uma cópia abreviada à 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

Minha primeira resposta no Code Golf!

-47 bytes em geral, graças 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)

Experimente online!

J , 12 bytes

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

Experimente online!

Ainda 1 byte mais longo que o de Adám

K (oK) , 12 11 bytes

-1 byte graças a ngn

{x,1_|x}@,\

Experimente online!