Grazie a @KritixiLithos per avermi aiutato con questa sfida!

V è un linguaggio di programmazione che ho scritto in modo da poter utilizzare ed estendere Vim per le sfide del code-golf. Il primo commit è stato il 3 marzo 2016, il che significa che oggi V compie un anno! Woo-hoo

Durante il primo anno di esistenza di V, ci sono stati 176 commit da quattro diversi contributori, 140 risposte da 12 utenti diversi e troppi operatori duplicati rotti da contare . Ha un interprete online , generosamente ospitato da @Dennis, che è stato gestito quasi 8000 volte da dicembre .

Facciamo una sfida per festeggiare il compleanno di V! Poiché la maggior parte delle funzionalità di V sono progettate pensando alla manipolazione delle stringhe e all'arte ascii , sembra naturale che qualsiasi sfida che celebra V debba riguardare l'arte ascii. Quindi la tua sfida per oggi è prendere una parola come input e rimodellare quella parola a forma di V. Ad esempio, l'input "Hello" dovrebbe dare la seguente V:

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

Ecco alcuni dettagli su come dovrebbe essere la tua V. Se la stringa di input è lunga n caratteri, la V dovrebbe essere n*2alta le righe. La prima riga dovrebbe consistere in:

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

Su ogni nuova riga, viene aggiunto uno spazio all'inizio e i due lati della stringa si spostano l'uno verso l'altro, rimuovendo eventuali caratteri sovrapposti. Fino all'ultima riga, che è solo il primo carattere di input. Lo spazio bianco finale su ogni riga è accettabile e è consentita anche una nuova riga finale.

Si può presumere che l'input sarà sempre ASCII stampabile senza spazi bianchi e si può prendere l'input e l'output in qualsiasi metodo ragionevole. Ecco alcuni altri input di esempio:

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

~:

~ ~
 ~

Naturalmente, poiché si tratta di code-golf , le scappatoie standard sono vietate e il tuo obiettivo è quello di scrivere il programma più breve possibile per completare questa attività. Buon golf!

Per quello che vale, ho un debole per le risposte di vim, quindi punti bonus immaginari per l'uso di vim o V, sebbene qualsiasi lingua sia accettabile. :)

MATL , 21 14 byte

MATL augura a V un felice compleanno!

tnEXyY+c3MZvZ)

Provalo online!

Spiegazione

Considera l'input

'Hello'

di lunghezza n=5. Il codice calcola la convoluzione 2D di questa stringa con la matrice identità di dimensione 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]

Il risultato della convoluzione, convertito in char e con char 0 mostrato come spazio, è

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

Quindi le colonne [1, 2, ..., 2*n-1, 2*n, 2*n-1, ..., 2, 1]vengono selezionate da questa matrice di caratteri, producendo il risultato desiderato:

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

Codice commentato

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 byte

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

Provalo online!

Molto più breve ora che V ha un operatore "inverso" .

Non così impressionante rispetto alle altre lingue del golf che hanno risposto, ma doveva essere fatto. hexdump:

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

Spiegazione:

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

A questo punto, il buffer si presenta così:

Happy         yppaH

No, costruiremo ricorsivamente il triangolo verso il basso.

ò                   " 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

Qui è dove posso mostrare una delle mie funzioni preferite di V. Molti comandi richiedono un argomento. Ad esempio, il >comando indenterà un numero variabile di righe in base all'argomento:

>>    " 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

ma la maggior parte dei comandi verrà forzata a terminare con un argomento predefinito (di solito la riga corrente) se si trova alla fine del programma e non viene specificato. Ad esempio, ciò che V esegue effettivamente per il nostro ciclo ricorsivo è:

òâÙHãêxx>>ò

Il secondo òè implicitamente compilato. La cosa interessante è che i comandi implicitamente finiti applicano diversi livelli in profondità, quindi anche se abbiamo solo scritto >, V darà implicitamente il _suo argomento, e indenterà la riga corrente.

Brainfuck , 152 byte

Questa è un'occasione così importante, ho deciso di estromettere il vecchio interprete BF e dare una svolta.

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

Con commenti

++++++++++
[->+>+++<<] 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
]

Provalo online!

> <> , 221 byte

Ho trascorso modo troppo tempo su questo. Buon compleanno, 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

Puoi provarlo online , ma è molto più divertente ottenere questo interprete ed eseguirlo usando la --playbandiera

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

che risulta nell'animazione in basso.

Esempio

(ci vogliono poco meno di due minuti)

Spiegazione

Poiché la parte interessante di questa risposta la sta avvolgendo nella Vforma, ecco una spiegazione che è conforme ad essa. Usiamo la seguente versione numerata per riferimento.

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

A volte le frecce (→ ↓ ←) vengono utilizzate per indicare la direzione in cui viene raggiunto uno snippet.

1. Inizializzazione

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

   La prima riga spingerà 2n su [0,1], lascerà n in pila e aggiungerà uno spazio. Successivamente, andiamo su e ci spostiamo sulla seconda riga a destra, dove inizieremo andando a sinistra. Esiste un ciclo per aggiungere n + 1 spazi. Funziona come segue.

                   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.
   

   Al termine, rimbalza fino alla linea 3. Lì vengono rimossi i due primi elementi dello stack (0 e uno spazio) ( ~~) e passiamo Xalla posizione at [10,1] ( a1.), proseguendo verso destra. Ci imbattiamo in /, passiamo alla riga 7 e iniziamo il ciclo principale del programma.

2. Ciclo principale ( 2n volte fare)

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

   Questa è la condizione del loop. Inizialmente, la pila viene invertita per la stampa. Quindi otteniamo il contatore da [1,0] ( 01g) e memorizziamo una versione decrementata ( :1-01p). Avvolgendoci e scontrandoci a destra, incontriamo il condizionale per terminare il programma. Se non terminiamo, passiamo al primo ciclo di stampa.

   • Primo ciclo di stampa (metà sinistra)

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

     Iniziamo con la lunghezza in cima allo stack ed eseguiamo il codice seguente purché l'elemento superiore non sia 0.

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

     Questo stamperà la pila senza scartarla. Se il ciclo termina, saltiamo a destra sulla riga 5, preparandoci per il ciclo di stampa successivo.

   • Preparazione della metà destra

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

     Questa è stata una delle parti più difficili da adattare. Di seguito è una versione spogliata di tutte le direzioni per indicare cosa succede.

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

     Quindi spingiamo la lunghezza di ciò che deve essere stampato e iniziamo il secondo ciclo di stampa (con un duplicato iniziale che non fa parte del ciclo).

   • Secondo ciclo di stampa (metà destra)

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

     Il codice in esecuzione è completamente lo stesso del primo ciclo di stampa, con il o}posizionamento un po 'più lontano perché c'erano posizioni disponibili. Al termine, ci restano alcune cose da fare prima di poter verificare nuovamente l'invariante del ciclo principale. Dopo l' ~esecuzione della riga 9, ci spostiamo verticalmente, finendo con il seguente pezzo di codice.

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

     In primo luogo aostamperà una nuova riga. Quindi riprendiamo e arriviamo esattamente nello stesso punto dopo l'inizializzazione, ovvero saltando al X.

Brain-Flak , 486 + 1 = 489 byte

Buon compleanno V da Brain-Flak!

Anche un grazie a 0 ' che ha fornito parte del codice utilizzato in questa risposta

+1 a causa della -cbandiera richiesta per l'entrata e l'uscita ASCII

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

Provalo online!

Questa è senza dubbio la cosa più difficile che abbia mai fatto in Brain-Flak.

Brain-Flak è notoriamente terribile nel duplicare e invertire le stringhe e questa sfida consiste solo nel duplicare e invertire le stringhe.

Sono riuscito a ottenere questo frammento quasi funzionante in poco meno di un'ora di duro lavoro, ma l'aggiunta negli ultimi spazi si è rivelata una delle cose più difficili che abbia mai fatto in Brain-Flak.

Spiegazione

L'idea di base è che creeremo prima la parte superiore della V e ogni iterazione rimuoverà due caratteri dal centro e aggiungerà uno spazio all'inizio.

In pratica questo diventa abbastanza difficile.

Gli algoritmi esistenti esistono per copia e reverse, quindi ho usato uno di quelli per creare una copia invertita del codice sullo offstack. Una volta che ho fatto questo, ho messo degli 2n-1spazi in cima alla pila originale e ho spostato lo stack fuori dallo stack per creare un sandwich.

Ora abbiamo la nostra prima fila. Ora vogliamo rimuovere due caratteri dall'inizio e aggiungere uno spazio in primo piano. Questa risulta essere la parte più difficile. La ragione di ciò è che dobbiamo essenzialmente memorizzare due valori, uno per la profondità dello snippet corrente e uno per la profondità al centro della V dove deve avvenire la cancellazione.

Questo è difficile.

A causa di tutta la duplicazione e l'inversione che sta avvenendo su entrambe le pile sono in pieno uso tutto il tempo. Non c'è davvero nulla su queste pile per mettere qualcosa. Anche con tutta la Terza pila di magia al mondo non è possibile ottenere il tipo di accesso necessario per risolvere questo problema.

Quindi, come lo ripariamo? In breve non lo facciamo davvero; ignoriamo gli spazi per ora e li patch in seguito aggiungeremo zeri al codice per contrassegnare dove sono destinati gli spazi ma a parte questo non faremo davvero nulla.

Quindi ad ogni iterazione facciamo una copia dell'ultima iterazione e la mettiamo nello stack. Usiamo la profondità che abbiamo memorizzato per dividerlo a metà in modo da avere la metà sinistra della V sulla pila destra e la metà destra della V sulla pila sinistra. Rimuoviamo due elementi e raccoppiamo i due insieme. Aggiungiamo una nuova riga per una buona misura e iniziamo la prossima iterazione. Ogni volta che la profondità al centro della V diminuisce di uno e quando raggiunge lo zero fermiamo il loop.

Ora abbiamo costruito la maggior parte della V. Ci mancano tuttavia spazi adeguati e la nostra V è attualmente un po '(leggi: completamente) capovolta.

Quindi lo capovolgiamo. Per capovolgerlo sull'altro stack, dobbiamo spostare ciascun elemento uno alla volta. Mentre spostiamo gli elementi controlliamo la presenza di zeri. Se ne incontriamo uno, dobbiamo rimettere gli spazi dove appartengono. Riduciamo lo zero e aggiungiamo un mucchio di spazi. Come facciamo a sapere quanti? Teniamo traccia; capovolgere uno stack a differenza di duplicare o invertire uno è un'attività molto intensiva, quindi abbiamo effettivamente la memoria per archiviare e accedere a un contatore aggiuntivo per tenere traccia di quanti spazi aggiungere. Ogni volta che aggiungiamo degli spazi, diminuiamo il contatore di uno. Il contatore dovrebbe colpire zero nell'ultima riga (la parte superiore della V) e quindi siamo pronti per la stampa.

Infine, ripuliamo alcune cose e terminiamo il programma per un output implicito.

Gelatina , 15 12 byte

⁶ṁ⁸;;\Uz⁶ŒBY

Provalo online!

Come funziona

⁶ṁ⁸;;\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 byte

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

Provalo online!

Python 2 , 65 byte

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

Provalo online!

JavaScript (ES6), 108 106 98 94 byte

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 byte

Buon compleanno da un altro linguaggio di elaborazione delle stringhe!

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

;{*`.¶

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

Provalo online!

Spiegazione

$
$.`$* 

Questo aggiunge nspazi (dove si ntrova la lunghezza della stringa), abbinando la fine della stringa, recuperando la lunghezza della stringa $.`e ripetendo uno spazio con molte volte $*.

$
¶$`

Dupliciamo l'intera stringa (separata da un avanzamento riga), abbinando nuovamente la fine della stringa e inserendo la stringa stessa $`.

O$^r`.\G

Questo inverte la seconda riga abbinando da destra a sinistra ( r), quindi abbinando un carattere alla volta ( .) ma assicurandosi che siano tutti adiacenti ( \G). In questo modo, le partite non possono superare l'alimentazione di linea. Questo viene quindi utilizzato in una fase di ordinamento. Usando la modalità di ordinamento ( $) ma sostituendo ogni corrispondenza con una stringa vuota, non viene eseguito alcun ordinamento effettivo. Ma grazie ^all'opzione, le partite sono invertite alla fine, invertendo l'intera seconda riga.

;{*`.¶

Questa fase è per l'output e influisce anche sul resto del programma. {avvolge le fasi rimanenti in un ciclo che viene ripetuto fino a quando quelle fasi non riescono a cambiare la stringa (cosa che succederà perché l'ultima fase non corrisponderà più). L' ;uscita disabilita al termine del programma. Questo *trasforma questa fase in una fase a secco, il che significa che la fase viene elaborata e il risultato viene stampato, ma successivamente viene ripristinata la stringa precedente.

Lo stage stesso rimuove semplicemente un avanzamento di riga e il personaggio precedente. Il che ci dà una riga dell'output desiderato (a partire dalla prima riga).

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

Infine, questa fase trasforma ogni riga nella successiva. Questo viene fatto inserendo uno spazio davanti al primo carattere non spaziale, rimuovendo l'ultimo carattere sulla prima riga, nonché il primo carattere sulla seconda riga. Questo processo si interrompe quando sulla prima riga è rimasto solo un carattere non spaziale, che corrisponde all'ultima riga dell'output.

05AB1E , 12 byte

Dgð×J.p€ûR.c

Provalo online!

Spiegazione

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

O per lo stesso numero di byte dall'altra direzione.

Âsgú.sí€ûR.c

Spiegazione

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

Japt augura a V molti altri anni di successo nel golf!

²¬£²îU²ç iYU)ê

Richiede la -Rbandiera. Provalo online!

Spiegazione

Questo utilizza le funzioni çe che îho aggiunto qualche giorno fa:

²¬£²î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)

La tecnica di Dennis è un byte più lunga:

U+Uç)å+ mw y mê

GNU sed , 110 100 + 1 (flag r) = 101 byte

Modifica: 9 byte in meno grazie a Riley

Come altro linguaggio di manipolazione delle stringhe, sed desidera V il meglio!

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

Provalo online!

Spiegazione: supponendo che l'ingresso sia l'ultimo caso di test ('V!'). Mostrerò lo spazio del modello ad ogni passo per chiarezza, sostituendo gli spazi con '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 byte

Provalo online!

Sono sicuro che questo non è ottimale, ma almeno è piuttosto Pythonic:

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 byte

Jolf augura a malincuore V un felice compleanno!

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

Provalo qui! ␅dovrebbe essere 0x05.

Spiegazione

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

Carbone , 29 byte

Buon compleanno V, dal tuo collega linguaggio ASCII deludentemente-lungo-per-questa-sfida!

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

Provalo online!

Spiegazione

La nostra strategia: stampare la metà sinistra della V, partendo dal basso e spostandosi in alto a sinistra; quindi riflettilo.

Ｓσ                                    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 solo Charcoal avesse il taglio delle stringhe ... ahimè, sembra che non sia ancora stato implementato.)

Pip , 32 25 byte

a.:sX#aL#a{OaDQaPRVaaPUs}

Accetta la stringa di input come argomento della riga di comando. Provalo online!

Spiegazione

                           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 con pacchetto stringi, 225 byte

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 esegui R nel codice interattivo, dopo aver incollato la mia risposta inserisci semplicemente qualsiasi cosa. Sarà necessario installare il pacchetto stringi R (spero che non sia contrario alle regole).

Spiegazione:

L'idea di base è quella di aggiungere spazi sul lato sinistro, quindi tagliarli alla lunghezza giusta. Successivamente, incollalo con la sua versione rovesciata come il lato destro. Ecco una versione più lunga e leggibile dall'uomo della funzione:

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

Rubino, 92 89 85 byte

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

Il mio processo consisteva nel rimuovere il primo carattere dalla metà destra di ogni riga dopo aver invertito la prima metà. Come questo:

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

Non sono abituato a provare a giocare a golf, quindi fammi sapere se c'è qualcosa che posso fare per accorciarlo.

Lotto, 186 185 byte

@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

Le righe 1 e 6 hanno uno spazio finale. Modifica: salvato 1 byte grazie a @ ConorO'Brien.

Haskell , 76 byte

vè la funzione principale, prendere un Stringargomento e dare un Stringrisultato.

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

Provalo online!

Appunti:

• i è l'argomento / input iniziale.
• sè inizialmente icon length ispazi aggiunti.
• v ichiama r s, quindi unisce le linee dei risultati.
• rrestituisce un elenco di Stringrighe.
• tè scon l'ultimo personaggio tagliato.
• La ricorsione r tproduce le linee tranne la prima, meno lo spazio iniziale su ciascuna linea.

Gelatina , 13 byte

⁶ṁ;@µḣJUz⁶ŒBY

Provalo online!

Come?

⁶ṁ;@µḣ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

Rubino, 85 83 byte

modifica: rimosso lo spazio bianco in eccesso

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

In realtà ho trovato abbastanza difficile giocare a golf a Ruby. Dopo aver aggiunto spazi bianchi, si espande in un frammento di codice abbastanza leggibile:

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 byte

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

Prima volta golf a codice. I suggerimenti sono benvenuti!

Uscita del programma:

Modificare:

Risparmiato 40 byte grazie a Luis Mendo.

PHP, 95 92 85 80 78 77 byte

Nota: utilizza la codifica 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")

Esegui in questo modo:

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          

Spiegazione

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.

Ritocchi

• Salvato 3 byte eliminando il carattere del pad (il str_padvalore predefinito è lo spazio, che è ciò di cui abbiamo bisogno)
• Salvato 7 byte utilizzando operazioni binarie sulla stringa per troncarla invece di substr
• Salvato 5 byte ruotando la stringa quando si stampa il contrario. Previene la necessità di stampare un backspace, ma si traduce in uno spazio finale su ogni riga.
• Salvato 2 byte riempiendo la stringa usando un metodo più contorto, ma più breve.
• Salvataggio di un byte a causa del fatto che non è necessario tenere conto del ~"0"caso (ASCII 207), poiché si può presumere che tutti gli input siano ascii stampabili (Thx @Titus)

JavaScript (ES6), 169 157 byte

(-10 byte grazie 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

Una soluzione ricorsiva. Sono nuovo di JavaScript, quindi per favore sii gentile! Tutti i consigli sul golf sono molto apprezzati. :)

E, naturalmente, un felice compleanno a te V!

Test dello snippet

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 byte

Buon compleanno dal tuo vecchio amico CJam!

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

Provalo online!

Spiegazione

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

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

Chiamalo con un singolo parametro, ad esempio .\V.ps1 Hello .

Modifica: 2 byte salvati con punta da AdmBorkBork

Pyke , 14 byte

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

Provalo online!

JavaScript (ES6), 94 byte

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):'')

Casi test

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 byte

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