Obrigado a @KritixiLithos por me ajudar com esse desafio!

V é uma linguagem de programação que eu escrevi para poder usar e estender o vim para desafios de código-golfe. O primeiro commit foi em 3 de março de 2016, o que significa que hoje V faz um ano! Woo-hoo

Durante o primeiro ano de existência de V, houve 176 confirmações de quatro colaboradores diferentes, 140 respostas de 12 usuários diferentes e muitos operadores duplicados quebrados para contar . Ele tem um intérprete on - line , generosamente hospedado pelo @Dennis, que foi executado quase 8.000 vezes desde dezembro .

Vamos ter um desafio para comemorar o aniversário de V! Como a maioria dos recursos do V é projetada com a manipulação de strings e a arte ascii em mente, parece natural que qualquer desafio que celebre o V seja sobre arte ascii. Portanto, seu desafio para hoje é pegar uma palavra como entrada e remodelá-la na forma de um V. Por exemplo, a entrada "Hello" deve fornecer o seguinte V:

Hello         olleH
 Hello       olleH
  Hello     olleH
   Hello   olleH
    Hello olleH
     HellolleH
      HellleH
       HeleH
        HeH
         H

Aqui estão alguns detalhes sobre a aparência do seu V. Se a sequência de entrada tiver n caracteres, o V deverá ter n*2linhas altas. A primeira linha deve consistir em:

<input string><(n*2) - 1 spaces><input string reversed>

Em cada nova linha, um espaço é adicionado ao início e os dois lados da string se movem um em direção ao outro, removendo os caracteres sobrepostos. Até a última linha, que é apenas o primeiro caractere de entrada. O espaço em branco à direita em cada linha é aceitável e uma nova linha à direita também é permitida.

Você pode assumir que a entrada sempre será imprimível em ASCII sem nenhum espaço em branco e pode receber entradas e saídas de qualquer método razoável. Aqui estão mais algumas entradas de amostra:

Happy:

Happy         yppaH
 Happy       yppaH
  Happy     yppaH
   Happy   yppaH
    Happy yppaH
     HappyppaH
      HapppaH
       HapaH
        HaH
         H

Birthday:

Birthday               yadhtriB
 Birthday             yadhtriB
  Birthday           yadhtriB
   Birthday         yadhtriB
    Birthday       yadhtriB
     Birthday     yadhtriB
      Birthday   yadhtriB
       Birthday yadhtriB
        BirthdayadhtriB
         BirthdadhtriB
          BirthdhtriB
           BirthtriB
            BirtriB
             BiriB
              BiB
               B

V!:

V!   !V
 V! !V
  V!V
   V

~:

~ ~
 ~

Obviamente, como se trata de código-golfe , as brechas padrão são proibidas e seu objetivo é escrever o programa mais curto possível para concluir esta tarefa. Feliz golfe!

Quanto vale a pena, eu tenho uma queda por respostas do vim, portanto, pontos de bônus imaginários por usar o vim ou V, embora qualquer idioma seja aceitável. :)

MATL , 21 14 bytes

MATL deseja a V um feliz aniversário!

tnEXyY+c3MZvZ)

Experimente online!

Explicação

Considere a entrada

'Hello'

de comprimento n=5. O código calcula a convolução 2D dessa sequência com a matriz de identidade de tamanho 2*n,

[1 0 0 0 0 0 0 0 0 0;
 0 1 0 0 0 0 0 0 0 0;
 0 0 1 0 0 0 0 0 0 0;
 0 0 0 1 0 0 0 0 0 0;
 0 0 0 0 1 0 0 0 0 0;
 0 0 0 0 0 1 0 0 0 0;
 0 0 0 0 0 0 1 0 0 0;
 0 0 0 0 0 0 0 1 0 0;
 0 0 0 0 0 0 0 0 1 0;
 0 0 0 0 0 0 0 0 0 1]

O resultado da convolução, convertido em char e com char 0 mostrado como espaço, é

['Hello         ';
 ' Hello        ';
 '  Hello       ';
 '   Hello      ';
 '    Hello     ';
 '     Hello    ';
 '      Hello   ';
 '       Hello  ';
 '        Hello ';
 '         Hello']

Em seguida, as colunas [1, 2, ..., 2*n-1, 2*n, 2*n-1, ..., 2, 1]são selecionadas nessa matriz de caracteres, produzindo o resultado desejado:

['Hello         olleH';
 ' Hello       olleH ';
 '  Hello     olleH  ';
 '   Hello   olleH   ';
 '    Hello olleH    ';
 '     HellolleH     ';
 '      HellleH      ';
 '       HeleH       ';
 '        HeH        ';
 '         H         ']

Código comentado

t      % Implicitly input string. Duplicate
nE     % Length, say n. Multiply by 2
Xy     % Identity matrix of that size
Y+     % 2D convolution. This converts chars to ASCII codes
c      % Convert to char
3M     % Push 2*n, again
Zv     % Push symmetric range [1, 2, ..., 2*n, 2*n-1, ..., 1]
Z)     % Apply as column indices. This reflects the first 2*n columns
       % symmetrically, and removes the rest. Implicitly display

V , 24, 23 , 20 bytes

3Ù2Ò Íî
Xæ$òâÙHãêxx>

Experimente online!

Muito mais curto agora que V tem um operador 'reverso' .

Não é tão impressionante em comparação com as outras línguas de golfe que responderam, mas tinha que ser feito. Hexdump:

00000000: 33d9 32d2 20cd ee0a 58e6 24f2 e2d9 48e3  3.2. ...X.$...H.
00000010: ea78 783e                                .xx>

Explicação:

3Ù                  " Make three extra copies of this current line
  2Ò                " Replace each character on this line and the next line with spaces
     Íî             " Join all lines together
X                   " Delete one space
 æ$                 " Reverse the word under the cursor

Nesse ponto, o buffer fica assim:

Happy         yppaH

Não, vamos recursivamente construir o triângulo.

ò                   " Recursively:
 â                  "   Break if there is only one non-whitespace character on this line
  Ù                 "   Make a copy of this line
   H                "   Move to the first line
    ã               "   Move to the center of this line
     ê              "   Move to this column on the last line
      xx            "   Delete two characters
        >           "   Indent this line

Aqui é onde eu mostro um dos meus recursos favoritos do V. Muitos comandos requerem um argumento. Por exemplo, o >comando recuará um número variável de linhas, dependendo do argumento:

>>    " Indent this line (this command is actually a synonym for '>_')
>j    " Indent this line and the line below
>k    " Indent this line and the line above
6>>   " Indent 6 lines
>}    " Indent to the end of this paragraph
>G    " Indent to the last line
...   " Many many many more

mas a maioria dos comandos será forçada a terminar com um argumento padrão (geralmente a linha atual) se estiver no final do programa e não especificado. Por exemplo, o que V realmente executa para nosso loop recursivo é:

òâÙHãêxx>>ò

O segundo òé preenchido implicitamente. O interessante é que os comandos encerrados implicitamente aplicam várias camadas de profundidade, portanto, embora tenhamos escrito apenas >, V implicitamente implicará _em seu argumento e recuará a linha atual.

Brainfuck , 152 bytes

Essa é uma ocasião tão importante que decidi quebrar o velho intérprete de BF e dar uma olhada nisso.

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

Com Comentários

++++++++++
[->+>+++<<] Insert 0 into the first buffer (Which we don't care about) 10 into the second and 30 into the thrd
>>++    Raise the third buffer to 32 making us our space
>   This buffer is reserved for the Insertable spaces counter
>
+>>>    Raise our incrementer This will be used to fill the other half of the string with spaces
,[  Read a byte
    [<]<<   Move to the back of the string buffer which is our incrementer
    +       increment it
    >>>[>]      And move to the next space of the string
    ,       And then read a new byte
]
<[<]<<-     Decrement the incrementer and begin to add spaces
[
    -       Decrement the incrementer
    >+      Raise the incrementer in the padding
    >>[>]   Move to a new part of the string buffer
    >++++[-<++++++++>]< Write a space
    [<]<<   Move all the way back to the string counter
]
BEGIN WRITING!!
>
[->++<]>[-<+>]<Double the incrementer
[
    <[  Move to the space counter
        -<+<.>> Decrement the space counter increment the temporary one to the left of it then print the space we stored to the left of that then return
    ]<[->+<]>+> Move the temporary space counter back
    -   Decrement the incrementer
    >>[.>]  Print every character from left to right
    <[-]    Snip the end off this
    <[.<]   Print every character from right to left
    <   Move back ot the incrementer
    <<<<.>>>> Print a newline aswell
]

Experimente online!

> <> , 221 bytes

Passei maneira muito tempo com isso. Feliz aniversário, V!

l:2*01           p84*/v
 !@:$-1         /!?:$<
  1.v/ ^       v\~~>a
   vv\}o<     >ao  /
    1\/84/   :}o:$-
     \\!?<: l;!?\v
      p10-1:g10r\
       >  :>?\vv
        v:$-1/~
         </r+*
          </~
           l

Você pode experimentá-lo on-line , mas é muito mais divertido obter esse intérprete e executá-lo usando a --playbandeira

python3 fish.py v.fish -s "ppcg" --tick 0.05 --play

o que resulta na animação abaixo.

Exemplo

(demora um pouco menos de dois minutos)

Explicação

Como a parte interessante desta resposta é envolvê-la na Vforma, aqui está uma explicação que está em conformidade com ela. Usamos a seguinte versão numerada de linha para referência.

1. l:2*01           p84*/v
2.  !@:$-1         /!?:$<
3.   1.v/ ^       v\~~>a
4.    vv\}o<     >ao  /
5.     1\/84/   :}o:$-
6.      \\!?<: l;!?\v
7.       p10-1:g10r\
8.        >  :>?\vv
9.         v:$-1/~
10.         </r+*
11.          </~
12.           l

Às vezes, as setas (→ ↓ ←) são usadas para indicar a direção na qual um snippet é alcançado.

1. Inicialização

      1.→l:2*01           p84*/v
      2.  !@:$-1   X     /!?:$<
      3.   1.            \~~>a
   

   A primeira linha pressionará 2n para [0,1], deixará n na pilha e acrescentará um espaço. Em seguida, subimos e contornamos a segunda linha à direita, onde começaremos a ir para a esquerda. Existe um loop para anexar n + 1 espaços. Isso funciona da seguinte maneira.

                   Initial:                 "ppcg4 "
   !@:$-1 /!?:$<
              $     Swap.                   "ppcg 4"
             :      Duplicate.              "ppcg 44"
            ?       If more spaces to add:
       -1            Subtract 1.            "ppcg 3"
      $              Swap.                  "ppcg3 "
     :               Duplicate.             "ppcg3  "
    @                Rotate top 3.          "ppcg 3 "
   !                 Jump over stored value
                            and wrap around.
                   Else:
           /         Go to next part.
   

   Depois de concluído, ele salta para a linha 3. Lá, os dois principais elementos da pilha (0 e um espaço) são removidos ( ~~) e pulamos para o Xlocal [10,1] ( a1.), continuando para a direita. Nós batemos na /, envolvemos a linha 7 e iniciamos o loop principal do programa.

2. Laço principal ( 2n vezes)

    6.              ;!?\
    7.       p10-1:g10r\   ←
   

   Essa é a condição do loop. Inicialmente, a pilha é revertida para impressão. Em seguida, obtemos o contador de [1,0] ( 01g) e armazenamos uma versão diminuída ( :1-01p). Ao contornar e esbarrar à direita, encontramos o condicional para encerrar o programa. Se não terminarmos, saltaremos para o primeiro ciclo de impressão.

   • Primeiro loop de impressão (metade esquerda)

     5.    1\   /   :}o:$-
     6.     \\!?<: l         ←
     

     Começamos com o comprimento no topo da pilha e executamos o código a seguir, desde que o elemento superior não seja 0.

     1-$:o}
     
     1-        Subtract 1.    "ppcg3"
       $       Swap.          "ppc3g"
        :      Duplicate.     "ppc3gg"
         o     Output.        "ppc3g"
          }    Rotate right.  "gppc3"
     

     Isso imprimirá a pilha sem descartá-la. Se o loop terminar, pularemos para a direita na linha 5, preparando o próximo loop de impressão.

   • Preparação da metade direita

     5.  →    /84/   
     6.       \     
     7.            :    
     8.            >
     9.         v:$-1/~
     10.         </r+*
     11.          </~
     12.           l
     

     Essa foi uma das partes mais difíceis de ajustar. Abaixo está uma versão sem todas as direções para indicar o que acontece.

                  Initial stack:   "    gcpp0"
     84*+r~
     84*          Push 32 == " ".  "    gcpp0 "
        +         Add 32 and 0.    "    gcpp "
         r        Reverse.         " gcpp    "
          ~       Remove top.      " gcpp   "
     

     Em seguida, aumentamos o comprimento do que deve ser impresso e iniciamos o segundo loop de impressão (com uma duplicata inicial que não faz parte do loop).

   • Segundo loop de impressão (metade direita)

     3.     / ^ 
     4.     \}o<
     5.    
     6.           ↓   
     7.           
     8.       >  :>?\vv
     9.        v:$-1/~ 
     

     O código que está sendo executado é completamente o mesmo do primeiro loop de impressão, com o código sendo o}colocado um pouco mais porque havia locais disponíveis. Ao terminar, ainda temos algumas coisas a fazer antes de podermos verificar o loop principal invariável novamente. Depois que a ~linha 9 é executada, contornamos verticalmente, terminando no seguinte trecho de código.

                     ↓
     2.          X     / 
     3.  1.v/             >a
     4.              >ao  /
     

     Primeiro aoimprimirá uma nova linha. Depois, saltamos e chegamos exatamente ao mesmo local após a inicialização, ou seja, pulando para o X.

Flak cerebral , 486 + 1 = 489 bytes

Feliz aniversário V da Brain-Flak!

Também obrigado a 0 ', que forneceu parte do código usado nesta resposta

+1 devido ao -csinalizador necessário para entrada e saída de ASCII

((([]<{({}<>)<>}<>([]){({}[()]<(([][()])<{({}[()]<({}<>)<>>)}{}><>)<>({}<<>{({}[()]<({}<>)<>>)}{}><>)(({})<>)<>>)}{}([][][()]){({}[()]<((((()()()()){}){}){})>)}{}<>{({}<>)<>}<>>){}[()])<{((({})<((({}){}())){({}[()]<(({}<(({})<>)<>>)<(({}<({}<>)<>>[()])<<>({}<<>{({}[()]<({}<>)<>>)}{}>)<>>){({}[()]<({}<>)<>>)}{}<>>)>)}{}{}((()()()()()){})(<()>)<>>)<{({}[()]<({}<>)<>>)}{}{}{}{({}<>)<>}<>>[()])}{}>()())([][()]){{}(({}[()])<{({}[()]<((((()()()()){}){}){})>)}{}{({}<>)<>}{}>)([][()])}{}<>

Experimente online!

Esta é sem dúvida a coisa mais difícil que já fiz no Brain-Flak.

Brain-Flak é notoriamente terrível ao duplicar e reverter seqüências de caracteres e esse desafio consiste em nada além de duplicar e reverter seqüências de caracteres.

Consegui obter esse trecho quase funcionando em menos de uma hora de trabalho duro, mas adicionar os últimos espaços acabou sendo uma das coisas mais difíceis que já fiz no Brain-Flak.

Explicação

A idéia básica é que primeiro criaremos a parte superior do V e cada iteração removerá dois caracteres do meio e incluirá um espaço no início.

Na prática, isso se torna bastante difícil.

Existem algoritmos existentes para copiar e reverter, então usei um deles para criar uma cópia invertida do código no offstack. Depois de fazer isso, coloco 2n-1espaços no topo da pilha original e movo a pilha de volta para a pilha para criar um sanduíche.

Agora nós temos nossa linha superior. Agora queremos remover dois caracteres desde o início e adicionar um espaço à frente. Isso acaba sendo a parte mais difícil. A razão para isso é que precisamos essencialmente armazenar dois valores, um para a profundidade do snippet atual e outro para a profundidade no centro do V onde a exclusão deve ocorrer.

Isto é difícil.

Por causa de toda a duplicação e reversão que estão ocorrendo nas duas pilhas, estão em uso total o tempo todo. Realmente não há nenhum lugar nessas pilhas para colocar qualquer coisa. Mesmo com toda a Third Stack Magic no mundo, você não pode obter o tipo de acesso necessário para resolver esse problema.

então como nós consertamos isso? Em suma, nós realmente não; por ignorarmos os espaços por enquanto e corrigi-los posteriormente, adicionaremos zeros ao código para marcar para onde os espaços devem ir, mas fora isso, não faremos realmente nada.

Portanto, em cada iteração, fazemos uma cópia da última iteração e a colocamos no empilhamento. Usamos a profundidade que armazenamos para dividir isso ao meio, para que tenhamos a metade esquerda do V na pilha direita e a metade direita do V na pilha esquerda. Removemos dois elementos e juntamos os dois novamente. Adicionamos uma nova linha para uma boa medida e iniciamos a próxima iteração. Cada vez que a profundidade do centro do V diminui em um e quando atinge zero, paramos o loop.

Agora temos a maior parte do V construído. No entanto, estamos com falta de espaços adequados e nosso V atualmente está um pouco (leia-se: completamente) de cabeça para baixo.

Então nós jogamos. Para colocá-lo na outra pilha, temos que mover cada elemento um por um. Enquanto movemos elementos, verificamos zeros. Se encontrarmos um, teremos que colocar os espaços de volta onde eles pertencem. Jogamos o zero e adicionamos vários espaços. Como sabemos quantos? Nós acompanhamos; inverter uma pilha ao contrário de duplicar ou inverter uma é uma tarefa muito intensiva; portanto, temos memória para armazenar e acessar um contador adicional para controlar quantos espaços adicionar. Cada vez que adicionamos alguns espaços, diminuímos o contador em um. O contador deve atingir zero na última nova linha (a parte superior do V) e, portanto, estamos prontos para imprimir.

Por fim, limpamos algumas coisas e encerramos o programa para saída implícita.

Geléia , 15 12 bytes

⁶ṁ⁸;;\Uz⁶ŒBY

Experimente online!

Como funciona

⁶ṁ⁸;;\Uz⁶ŒBY  Main link. Argument: s (string)

⁶ṁ            Mold ' ' like s, creating a string of len(s) spaces.
  ⁸;          Prepend s to the spaces.
    ;\        Cumulative concatenation, generating all prefixes.
      U       Upend; reverse each prefix.
       z⁶     Zip/transpose, filling empty spots with spaces.
         ŒB   Bounce; map each string t to t[:-1]+t[::-1].
           Y  Join, separating by linefeeds.

Python 3 , 65 bytes

s=input();s+=' '*len(s)
for _ in s:s=' '+s[print(s+s[-2::-1]):-1]

Experimente online!

Python 2 , 65 bytes

s=input();s+=' '*len(s)
for _ in s:print s+s[-2::-1];s=' '+s[:-1]

Experimente online!

JavaScript (ES6), 108 106 98 94 bytes

f=
s=>s.repeat((j=l=s.length*4)*2).replace(/./g,_=>--j?s[j+j<l?j-i:l-i-j]||` `:(j=l,++i,`
`),i=1)

<input oninput=o.textContent=f(this.value)><pre id=o>

Retina , 51 47 bytes

Feliz aniversário de uma linguagem de processamento de strings!

A contagem de bytes assume a codificação ISO 8859-1.

$
$.`$* 
$
¶$`
O$^r`.\G

;{*`.¶

(\S.*).¶.
 $1¶

Experimente online!

Explicação

$
$.`$* 

Isso acrescenta nespaços (onde nestá o comprimento da string), correspondendo ao final da string, recuperando o comprimento da string $.`e repetindo um espaço que muitas vezes $*.

$
¶$`

Duplicamos a string inteira (separada por um avanço de linha), combinando o final da string novamente e inserindo a própria string $`.

O$^r`.\G

Isso inverte a segunda linha, correspondendo da direita para a esquerda ( r) e, em seguida, correspondendo a um caractere de cada vez ( .), mas assegurando que todos estejam adjacentes ( \G). Dessa forma, as correspondências não podem passar do avanço de linha. Isso é usado em um estágio de classificação. Usando o modo classificar por ( $), mas substituindo cada correspondência por uma sequência vazia, nenhuma classificação real é feita. Porém, devido à ^opção, as correspondências são revertidas no final, revertendo toda a segunda linha.

;{*`.¶

Esse estágio é para saída e também afeta o restante do programa. {agrupa os estágios restantes em um loop que é repetido até que esses estágios falhem na alteração da string (o que acontecerá porque o último estágio não corresponderá mais). A ;saída desativa no final do programa. o* voltas nesta fase em um prazo seca, o que significa que o estágio é processado e o resultado é impresso, mas depois a cadeia anterior é restaurado.

O palco em si simplesmente remove um avanço de linha e o caractere anterior. O que nos dá uma linha da saída desejada (começando com a primeira linha).

(\S.*).¶.
 $1¶

Finalmente, esse estágio transforma cada linha na próxima. Isso é feito inserindo um espaço na frente do primeiro caractere não espacial, removendo o último caractere na primeira linha e o primeiro caractere na segunda linha. Esse processo é interrompido quando houver apenas um caractere não-espaço deixado na primeira linha, que corresponde à última linha da saída.

05AB1E , 12 bytes

Dgð×J.p€ûR.c

Experimente online!

Explicação

D             # duplicate input
 g            # length of copy
  ð×J         # append that many spaces to input
     .p       # get a list of all prefixes
       €û     # turn each into a palindrome
         R    # reverse the list
          .c  # pad each line until centered

Ou para a mesma contagem de bytes da outra direção.

Âsgú.sí€ûR.c

Explicação

             # push a reversed copy of input
 s            # swap the input to the top of the stack
  g           # get its length
   ú          # prepend that many spaces
    .s        # get a list of all suffixes
      í       # reverse each
       €û     # turn each into a palindrome
         R    # reverse the list
          .c  # pad each line until centered

Japt, 22 20 16 14 + 2 bytes

Japt deseja muitos mais anos de sucesso no golfe!

²¬£²îU²ç iYU)ê

Requer a -Rbandeira. Teste online!

Explicação

Isso faz uso das funções çe îadicionei alguns dias atrás:

²¬£²îU²ç iYU)ê    Implicit: U = input string
²                 Double the input string.
 ¬                Split into chars.
  £               Map each char X and index Y by this function:
     U²             Take the input doubled.
       ç            Fill this with spaces.
         iYU        Insert the input at index Y.
    î       )       Mask: repeat that string until it reaches the length of
   ²                the input doubled.
                    This grabs the first U.length * 2 chars of the string.
             ê      Bounce the result ("abc" -> "abcba").
                  Implicit: output result of last expression, joined by newlines (-R flag)

A técnica de Dennis é um byte mais longo:

U+Uç)å+ mw y mê

GNU sed , 110 100 + 1 (sinalizador r) = 101 bytes

Edit: 9 bytes mais curto graças a Riley

Como outra linguagem de manipulação de strings, o sed deseja V o melhor!

h;G
:;s:\n.: \n:;t
h;:r;s:(.)(\n.*):\2\1:;tr
H;x
s:\n\n ::
:V
h;s:\n::p;g
s:^: :;s:.\n.:\n:
/\n$/!tV

Experimente online!

Explicação: supondo que a entrada seja o último caso de teste ('V!'). Mostrarei o espaço do padrão em cada etapa para maior clareza, substituindo espaços por 'S'.

h;G                       # duplicate input to 2nd line: V!\nV!
:;s:\n.: \n:;t            # shift each char from 2nd line to 1st, as space: V!SS\n
h;:r;s:(.)(\n.*):\2\1:;tr # save pattern space, then loop to reverse it: \nSS!V
H;x                       # append reversed pattern to the one saved V!SS\n\n\nSS!V
s:\n\n ::                 # convert to format, use \n as side delimiter: V!SS\nS!V
:V                        # start loop 'V', that generates the remaining output
h;s:\n::p;g               # temporarily remove the side delimiter and print pattern
s:^: :;s:.\n.:\n:         # prepend space, delete char around both sides: SV!S\n!V
/\n$/!tV                  # repeat, till no char is left on the right side
                          # implicit printing of pattern left (last output line)

Python, 110 bytes

Experimente online!

Tenho certeza de que isso não é o ideal, mas pelo menos é bastante pitônico:

def f(s):n=len(s)*2-1;return''.join(i*' '+s[:n+1-i]+(n-2*i)*' '+s[n-i-1::-1]+'\n'for i in range(n))+n*' '+s[0]

Jolf, 31 bytes

Jolf relutantemente deseja a V um feliz aniversário!

RΜwzΒώlid+γ_pq_ l+*␅Hi0ΒΒ␅ L_γ1S

Experimente aqui! ␅deve ser 0x05.

Explicação

RΜzΒώlid+γ_pq_ l+*␅Hi0ΒΒ␅ L_γ1S  i = input
     li                                  i.length
    ώ                                2 * 
   Β                             Β =
  z                              range(1, Β + 1)
 Μ     d                         map with: (S = index, from 0)
                +                 add:
                 *␅H               S spaces
                    i              and the input
               l                  slice (^) from
                     0Β            0 to Β
           pq_         Β␅         pad (^) with spaces to the right
         γ_                       γ = reverse (^)
        +                 L_γ1    γ + behead(γ)
R                             S  join with newlines

Carvão , 29 bytes

Feliz aniversário V, da sua linguagem de arte ASCII decepcionantemente longa para este desafio!

ＳσＦ…·¹Ｌσ«Ｆι§σκＭι←↖»Ｆσ«Ｐσ↖»‖Ｏ→

Experimente online!

Explicação

Nossa estratégia: imprima a metade esquerda do V, começando de baixo e movendo-se para o canto superior esquerdo; depois reflita.

Ｓσ                                    Input σ as string
                                       The bottom len(σ) half-rows:
   Ｆ…·¹Ｌσ«           »               For ι in inclusive range from 1 to length(σ):
            Ｆι                          For κ in range(ι):
               §σκ                         Print character of σ at index κ
                  Ｍι←                   Move cursor ι spaces leftward
                      ↖                  Move cursor one space up and left
                                       The top len(σ) half-rows:
                        Ｆσ«    »      For each character ι in σ:
                            Ｐσ          Print σ without moving the cursor
                               ↖         Move cursor one space up and left
                                 ‖Ｏ→  Reflect the whole thing rightward, with overlap

(Se apenas o carvão tivesse fatias de cordas ... infelizmente, parece que ainda não foi implementado.)

Pip , 32 25 bytes

a.:sX#aL#a{OaDQaPRVaaPUs}

Toma a cadeia de entrada como um argumento da linha de comandos. Experimente online!

Explicação

                           a is 1st cmdline arg, s is space (implicit)
     #a                    Len(a)
   sX                      Space, string-multiplied by the above
a.:                        Concatenate that to the end of a
       L#a{             }  Loop len(a) times (but NB, a is now twice as long as it was):
           Oa                Output a (no trailing newline)
             DQa             Dequeue one character from the end of a
                PRVa         Print reverse(a) (with trailing newline)
                    aPUs     Push one space to the front of a

R com pacote stringi, 225 bytes

library(stringi)
f=function(){
s=scan(,'',1,sep="\n")
m=2*nchar(s)
l=stri_pad(sapply(1:m-1,function(x)substr(paste(paste(rep(" ",x),collapse=""),s),1,m)),m,"right")
r=substr(stri_reverse(l),2,m)
message(paste0(l,r,"\n"))}
f()

Se você executar R no código interativo, depois de colar minha resposta, insira qualquer coisa. Você precisará instalar o pacote stringi R (espero que não seja contra as regras).

Explicação:

A idéia básica é adicionar espaços ao lado esquerdo e cortá-lo no comprimento certo. Depois disso, cole-o com a versão invertida no lado direito. Aqui está uma versão mais longa, legível por humanos, da função:

library(stringi)
make_V <- function(){                  # declaring the function
  string <- scan(, '', n=1, sep="\n")  # reading input
  max_length <- 2*nchar(string)        # number of chars in each half row

  # creating the left side of the V

  left <- stri_pad(                    
            sapply(1:max_length-1,     # for each row
                   function(x){     
                    substr(            
                      paste0(
                        paste0(rep(" ", x),
                               collapse=""), string), # add spaces to left side
                           1,
                           max_length) # cut the unneeded end
                    }),
            width=max_length,
            side="right")              # add spaces to the right side

  # creating the right side of the V

  right <- substr(stri_reverse(left), 2, max_length)

  # print it without any symbols before the strings 
  message(paste0(left, right, "\n"))
}

# run the function
make_V()

Ruby, 92 89 85 bytes

s=gets.chomp
s<<" "*n=s.size*2
n.times{s=s[0..(n-1)]
puts s+s.reverse[1..-1]
s=" "+s}

Meu processo foi remover o primeiro caractere da metade direita de cada linha depois de reverter a primeira metade. Como isso:

Hello     |    olleH
 Hello    |   olleH 
  Hello   |  olleH  
   Hello  | olleH   
    Hello |olleH    
     Hello|lleH     
      Hell|leH      
       Hel|eH       
        He|H        
         H|         

Eu não estou acostumado a tentar jogar golfe, então deixe-me saber se há algo que eu possa fazer para diminuí-lo.

Lote, 186 185 bytes

@set e=@set 
%e%/ps=
%e%t=%s%
%e%r=
:l
%e%s=%s% 
%e%r= %r%%t:~-1%
%e%t=%t:~,-1%
@if not "%t%"=="" goto l
:g
%e%r=%r:~1%
@echo %s%%r%
%e%s= %s:~,-1%
@if not "%r%"=="" goto g

As linhas 1 e 6 têm um espaço à direita. Editar: salvou 1 byte graças a @ ConorO'Brien.

Haskell , 76 bytes

vé a função principal, levando uma Stringdiscussão e dando um Stringresultado.

v i=unlines.r$i++(' '<$i)
r""=[]
r s|t<-init s=(s++reverse t):map(' ':)(r t)

Experimente online!

Notas:

• i é o argumento / entrada inicial.
• sé inicialmente icom length iespaços anexados.
• v ichama r se junta as linhas de resultado.
• rretorna uma lista de Stringlinhas.
• t é s com o último caractere cortado.
• A recursão r tproduz as linhas, exceto a primeira, menos o espaço inicial em cada linha.

Gelatina , 13 bytes

⁶ṁ;@µḣJUz⁶ŒBY

Experimente online!

Quão?

⁶ṁ;@µḣJUz⁶ŒBY - Main link: string s
⁶             - space character
 ṁ            - mould like s: len(s) spaces
  ;@          - concatenate s with that
    µ         - monadic chain separation (call that t)
      J       - range(length(t))
     ḣ        - head (vectorises): list of prefixes from length to all
       U      - upend: reverse each of them
        z     - transpose with filler:
         ⁶    -     space: now a list of the left parts plus centre
          ŒB  - bounce each: reflect each one with only one copy of the rightmost character
            Y - join with line feeds
              - implicit print

Ruby, 85 83 bytes

editar: espaço em branco removido em excesso

s=ARGV[0];s+=' '*s.length;s.length.times{|i|puts s+s[i..-2].reverse;s=' '+s[0..-2]}

Na verdade, achei bastante difícil jogar este em Ruby. Depois de adicionar espaço em branco, ele se expande para um trecho de código bastante legível:

s = ARGV[0]
s+=' ' * s.length

s.length.times do |i|
  puts s + s[i..-2].reverse
  s = ' ' + s[0..-2]
end

MATLAB (R2016b), 223 183 bytes

r=input('');l=nnz(r)*2;for i=1:l;m=l+1-2*i;c={' '};s=cell(1,i-1);s(:)=c;x=cell(1,m);x(:)=c;e=r;y=flip(r);if(m<1);e=r(1:2*end-i+1);y=r(l/2+end-i:-1:1);end;disp(cell2mat([s e x y]));end

Código pela primeira vez Golf. Dicas são bem vindas!

Saída do Programa:

Editar:

Economizou 40 bytes graças a Luis Mendo.

PHP, 95 92 85 80 78 77 bytes

Nota: usa codificação IBM-850

for($s.=strtr($s^$s=$argn,~ ,~▀);~$s[$i++];)echo$s,strrev($s=" $s"^$s^$s),~§;
          # Note that this ^ char is decimal 255 (negating it yields "\0")

Execute assim:

echo "Hello" | php -nR 'for($s.=strtr($s^$s=$argn,"\0",~▀);~$s[$i++];)echo$s,strrev($s=" $s"^$s^$s),~§;'
> Hello         olleH 
>  Hello       olleH  
>   Hello     olleH   
>    Hello   olleH    
>     Hello olleH     
>      HellolleH      
>       HellleH       
>        HeleH        
>         HeH         
>          H          

Explicação

for(
  $s.=strtr(             # Set string to the input, padded with spaces.
    $s^$s=$argn,         # Input negated with itself, leads to string with
                         # only null bytes with the same length.
    ~ ,                  # Replace null bytes...
    ~▀                   # ... with spaces.
  );
  ~$s[$i++];             # Iterate over the string by chars, works because 
                         # there are just as many lines as the padded
                         # string has chars.
)
  echo                   # Output!
    $s,                  # The string.
    strrev(              # The reverse of the string.
      $s=" $s"^$s^$s     # After each iteration, prefix string with a
    ),                   # space, and trim the last character.
    ~§;                  # Newline.

Tweaks

• Economizou 3 bytes ao se livrar do caractere de bloco (o str_padpadrão é espaço, que é o que precisamos)
• 7 bytes salvos usando operações binárias na cadeia de caracteres para truncá-la em vez de substr
• Economizou 5 bytes girando a string ao imprimir o reverso. Evita a necessidade de imprimir um backspace, mas resulta em um espaço à direita em cada linha.
• Salva 2 bytes preenchendo a string usando um método mais complicado, mas mais curto.
• Salvou um byte devido ao fato de não haver necessidade de contabilizar o ~"0"caso (ASCII 207), pois todas as entradas podem ser consideradas como ascii imprimíveis (Thx @Titus)

JavaScript (ES6), 169 157 bytes

(-10 bytes graças a Conor O'Brien)

V=(j,i=0,p="")=>i<(f=j.length)*2?V(j,-~i,p+" ".repeat(i)+j.slice(0,f-i*(i>f))+" ".repeat(i<f?(f-i)*2-1:0)+[...j.slice(0,f+~i*(i>=f))].reverse().join``+`
`):p

Uma solução recursiva. Eu sou novo no JavaScript, portanto, seja gentil! Todas as dicas de golfe são muito apreciadas. :)

E, claro, um feliz aniversário para você V!

Snippet de teste

V=(j,i=0,p="")=>i<(f=j.length)*2?V(j,-~i,p+" ".repeat(i)+j.slice(0,f-i*(i>f))+" ".repeat(i<f?(f-i)*2-1:0)+[...j.slice(0,f+~i*(i>=f))].reverse().join``+`
`):p

<input oninput=o.textContent=V(this.value)><pre id=o>

CJam , 26 bytes

Feliz aniversário do seu velho amigo CJam!

q_,2*:L,\f{LS*+m>L<_W%(;N}

Experimente online!

Explicação

q                           Push the input
 _,2*:L                     Push 2 times the length of the input, store it in L
       ,                    Take the range from 0 to L-1
        \                   Swap top stack elements
         f{                 Map over the range, using the input as an extra parameter
           LS*+               Append L spaces to the input
               m>             Rotate the resulting string right i positions (where i is the
                               current number being mapped)
                 L<           Take the first L characters of the string
                   _W%        Duplicate it and reverse it
                      (;      Remove the first character from the copy
                        N     Add a newline
                         }  (end of block)
                            (implicit output)

PowerShell, 126 bytes 124 bytes

$l=($s="$args")|% Le*;$r=-join$s[-1..-$l];0..($l*2-1)|%{' '*$_+($s+' '*$l).substring(0,$l*2-$_)+(' '*$l+$r).substring($_+1)}

Chame-o com um único parâmetro, como .\V.ps1 Hello.

Edit: 2 bytes salvos com dica do AdmBorkBork

Pyke , 14 bytes

l}j Fd*R+j^j<s

Experimente online!

JavaScript (ES6), 94 bytes

f=(s,y=0,x=0,l=s.length*2-1)=>(s[(x>l?l*2-x:x)-y]||' ')+(x<l*2?f(s,y,x+1):y<l?`
`+f(s,y+1):'')

Casos de teste

f=(s,y=0,x=0,l=s.length*2-1)=>(s[(x>l?l*2-x:x)-y]||' ')+(x<l*2?f(s,y,x+1):y<l?`
`+f(s,y+1):'')

console.log(f('Happy'))
console.log(f('Birthday'))
console.log(f('V!'))
console.log(f('~'))

J, 44 bytes

(([(,}.@|.)@{."1-@i.@[|."0 1(,#&' ')~)~+:@#)