Vielen Dank an @KritixiLithos, der mir bei dieser Herausforderung geholfen hat !

V ist eine Programmiersprache, die ich geschrieben habe, um vim für Code-Golf-Herausforderungen zu verwenden und zu erweitern. Das allererste Commit fand am 3. März 2016 statt, was bedeutet, dass V heute ein Jahr alt wird! Woo-hoo

Im ersten Jahr des Bestehens von V gab es 176 Commits von vier verschiedenen Mitwirkenden, 140 Antworten von 12 verschiedenen Benutzern und zu viele fehlerhafte Duplikatoperatoren, um gezählt zu werden . Es verfügt über einen Online-Dolmetscher , der großzügig von @Dennis gehostet wird und seit Dezember fast 8.000 Mal ausgeführt wurde .

Feiern wir den Geburtstag von V! Da die meisten Features in V auf String-Manipulation und Ascii-Art ausgelegt sind , scheint es nur selbstverständlich, dass sich jede Herausforderung, die V feiert, auf Ascii-Art bezieht. Ihre Herausforderung für heute besteht also darin, ein Wort als Eingabe zu nehmen und dieses Wort in die Form eines V umzuformen. Die Eingabe "Hallo" sollte beispielsweise das folgende V ergeben:

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

Hier sind einige Details darüber, wie Ihr V aussehen sollte. Wenn die Eingabezeichenfolge n Zeichen lang ist, sollte das V n*2Zeilen lang sein. Die allererste Zeile sollte bestehen aus:

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

In jeder neuen Zeile wird am Anfang ein Leerzeichen eingefügt, und die beiden Seiten der Zeichenfolge werden aufeinander zu bewegt, wobei sich überlappende Zeichen entfernt werden. Bis zur allerletzten Zeile, die nur das erste Zeichen der Eingabe ist. Es ist akzeptabel, in jeder Zeile Leerzeichen nachzustellen, und es ist auch zulässig, eine neue Zeile nachzustellen.

Sie können davon ausgehen, dass die Eingabe immer druckbares ASCII ohne Leerzeichen sein wird, und Sie können die Eingabe und Ausgabe in jeder angemessenen Methode vornehmen. Hier sind einige weitere Beispieleingaben:

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

~:

~ ~
 ~

Da es sich um Code-Golf handelt , sind natürlich Standard-Lücken verboten und es ist Ihr Ziel, das kürzestmögliche Programm zu schreiben, um diese Aufgabe zu erfüllen. Viel Spaß beim Golfen!

Was auch immer es wert ist, ich habe ein Faible für VIM-Antworten, also imaginäre Bonuspunkte für die Verwendung von VIM oder V, obwohl jede Sprache akzeptabel ist. :)

MATL , 21 14 Bytes

MATL wünscht V alles Gute zum Geburtstag!

tnEXyY+c3MZvZ)

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe

'Hello'

der Länge n=5. Der Code berechnet die 2D-Faltung dieser Zeichenfolge mit der Identitätsmatrix der Größe 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]

Das Ergebnis der Faltung, konvertiert in char und mit char 0 als Leerzeichen, ist

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

Dann werden die Spalten [1, 2, ..., 2*n-1, 2*n, 2*n-1, ..., 2, 1]aus dieser Zeichenmatrix ausgewählt, um das gewünschte Ergebnis zu erzielen:

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

Kommentierter Code

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>

Probieren Sie es online!

Viel kürzer jetzt, da V einen "Rückwärts" -Operator hat .

Nicht so beeindruckend im Vergleich zu den anderen Golfsprachen, die geantwortet haben, aber es musste getan werden. Hexdump:

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

Erläuterung:

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

Zu diesem Zeitpunkt sieht der Puffer folgendermaßen aus:

Happy         yppaH

Nein, wir bauen das Dreieck rekursiv ab.

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

Hier kann ich eines meiner Lieblingsmerkmale von V demonstrieren. Viele Befehle erfordern ein Argument. Beispielsweise wird der >Befehl abhängig vom Argument eine variable Anzahl von Zeilen einrücken:

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

Die meisten Befehle müssen jedoch mit einem Standardargument (normalerweise der aktuellen Zeile) enden, wenn es sich am Ende des Programms befindet und nicht angegeben ist. Was V beispielsweise für unsere rekursive Schleife tatsächlich ausführt, ist:

òâÙHãêxx>>ò

Das zweite òist implizit ausgefüllt. Das Coole ist, dass implizit beendete Befehle mehrere Ebenen tief anwenden. Obwohl wir nur geschrieben haben >, wird V implizit _für das Argument angeben und die aktuelle Zeile einrücken.

Brainfuck , 152 Bytes

Dies ist eine so bedeutsame Gelegenheit, dass ich mich entschlossen habe, den alten BF-Interpreter zu knacken und es zu versuchen.

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

Mit Kommentaren

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

Probieren Sie es online!

> <> 221 Bytes

Ich verbrachte Art und Weise zu viel Zeit zu diesem Thema . Alles Gute zum Geburtstag 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

Sie können es online ausprobieren , aber es macht viel mehr Spaß, diesen Interpreter zu bekommen und ihn unter Verwendung der --playFlagge auszuführen

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

Daraus ergibt sich die Animation unten.

Beispiel

(es dauert etwas weniger als zwei Minuten)

Erläuterung

Da der interessante Teil dieser Antwort darin besteht, sie in VForm zu bringen, finden Sie hier eine Erklärung, die dieser entspricht. Wir verwenden die folgende zeilennummerierte Version als Referenz.

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

Manchmal werden Pfeile (→ ↓ ←) verwendet, um die Richtung anzugeben, in der ein Snippet erreicht wird.

1. Initialisierung

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

   In der ersten Zeile wird 2n auf [0,1] verschoben, n auf dem Stapel belassen und ein Leerzeichen angehängt. Als nächstes gehen wir nach oben und biegen in die zweite Zeile rechts ein, wo wir anfangen, nach links zu gehen. Es gibt eine Schleife zum Anhängen von n + 1 Leerzeichen. Das funktioniert wie folgt.

                   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.
   

   Nachdem dies abgeschlossen ist, springt es nach unten zu Zeile 3. Dort werden die beiden obersten Stapelelemente (0 und ein Leerzeichen) entfernt ( ~~) und wir springen zu XPosition [10,1] ( a1.), wobei wir uns nach rechts bewegen. Wir stoßen an der /, biegen in Zeile 7 ab und starten die Hauptprogrammschleife.

2. Hauptschleife ( 2n mal)

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

   Dies ist die Schleifenbedingung. Zunächst wird der Stapel zum Drucken umgekehrt. Dann erhalten wir den Zähler von [1,0] ( 01g) und speichern eine dekrementierte Version ( :1-01p). Indem wir uns abkoppeln und anstoßen, stoßen wir auf die Bedingung zum Beenden des Programms. Wenn wir nicht abbrechen, springen wir in die erste Druckschleife.

   • Erste Druckschleife (linke Hälfte)

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

     Wir beginnen mit der Länge oben auf dem Stapel und führen den folgenden Code aus, solange das oberste Element nicht 0 ist.

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

     Dadurch wird der Stapel gedruckt, ohne ihn zu verwerfen. Wenn die Schleife endet, springen wir in Zeile 5 nach rechts und bereiten uns auf die nächste Druckschleife vor.

   • Vorbereitung der rechten Hälfte

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

     Dies war eines der am schwierigsten zu montierenden Teile. Unten ist eine Version ohne Umbruch, um anzuzeigen, was passiert.

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

     Wir verschieben dann die Länge des zu druckenden Textes und starten die zweite Druckschleife (mit einem anfänglichen Duplikat, das nicht Teil der Schleife ist).

   • Zweite Druckschleife (rechte Hälfte)

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

     Der Code, der ausgeführt wird, ist völlig derselbe wie in der ersten Druckschleife, wobei der Code o}etwas weiter platziert wird, weil es verfügbare Stellen gibt. Am Ende müssen wir noch ein paar Dinge erledigen, bevor wir die Hauptschleifeninvariante erneut überprüfen können. Nachdem die ~Zeile 9 ausgeführt wurde, werden wir vertikal herumlaufen und am folgenden Codeteil enden.

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

     Zuerst aowird eine neue Zeile gedruckt. Dann hüpfen wir auf und kommen nach der Initialisierung genau an der gleichen Stelle an, nämlich beim Springen zum X.

Brain-Flak , 486 + 1 = 489 Bytes

Alles Gute zum Geburtstag V von Brain-Flak!

Auch ein Dankeschön an 0 ', der einen Teil des in dieser Antwort verwendeten Codes zur Verfügung gestellt hat

+1 aufgrund des -cFlags, das für ASCII in und out benötigt wird

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

Probieren Sie es online!

Dies ist ohne Zweifel das Schwierigste, was ich jemals in Brain-Flak gemacht habe.

Brain-Flak ist bekanntermaßen für das Duplizieren und Umkehren von Saiten schrecklich, und diese Herausforderung besteht nur aus dem Duplizieren und Umkehren von Saiten.

Ich habe es geschafft, dieses fast funktionierende Snippet in weniger als einer Stunde harter Arbeit zu bekommen, aber das Hinzufügen in den letzten paar Stellen hat sich als eine der schwierigsten Dinge herausgestellt, die ich jemals in Brain-Flak getan habe.

Erläuterung

Die Grundidee ist, dass wir zuerst die Spitze des V erstellen und bei jeder Iteration zwei Zeichen aus der Mitte entfernen und dem Anfang ein Leerzeichen hinzufügen.

In der Praxis wird dies ziemlich schwierig.

Es gibt vorhandene Algorithmen zum Kopieren und Umkehren, daher habe ich einen davon verwendet, um eine umgekehrte Kopie des Codes im Offstack zu erstellen. Sobald ich das getan habe, setze ich 2n-1Leerzeichen auf den ursprünglichen Stapel und lege den Stapel wieder auf den Stapel, um ein Sandwich zu erstellen.

Jetzt haben wir unsere oberste Reihe. Jetzt wollen wir zwei Zeichen vom Anfang entfernen und ein Leerzeichen nach vorne einfügen. Dies ist der schwierigste Teil. Der Grund dafür ist, dass wir im Wesentlichen zwei Werte speichern müssen, einen für die Tiefe des aktuellen Snippets und einen für die Tiefe in der Mitte des V, in der die Löschung erfolgen muss.

Das ist schwer.

Aufgrund all der Duplizierungen und Umkehrungen, die auf beiden Stapeln stattfinden, sind sie die ganze Zeit in vollem Einsatz. Es gibt wirklich keinen Ort auf diesen Stapeln, an dem man etwas unterbringen könnte. Selbst mit der gesamten dritten Stapel-Magie der Welt können Sie nicht die Art von Zugriff erhalten, die Sie zur Lösung dieses Problems benötigen.

Wie beheben wir das? Kurz gesagt, wir tun es nicht wirklich. Wir ignorieren die Leerzeichen fürs Erste und korrigieren sie später. Wir werden dem Code Nullen hinzufügen, um zu markieren, wohin die Leerzeichen gehen sollen, aber ansonsten werden wir eigentlich nichts tun.

Also machen wir bei jeder Iteration eine Kopie der letzten Iteration und legen sie in den Offstack. Wir verwenden die Tiefe, die wir gespeichert haben, um diese in zwei Hälften zu teilen, sodass wir die linke Hälfte des V auf dem rechten Stapel und die rechte Hälfte des V auf dem linken Stapel haben. Wir entfernen zwei Elemente und fügen sie wieder zusammen. Wir fügen eine neue Zeile für eine gute Messung hinzu und starten die nächste Iteration. Jedes Mal, wenn die Tiefe zur Mitte des V um eins abnimmt und es auf Null trifft, stoppen wir die Schleife.

Jetzt haben wir den Großteil des V aufgebaut. Es fehlen uns jedoch die richtigen Räume und unser V ist derzeit ein bisschen (gelesen: vollständig) auf dem Kopf.

Also drehen wir es um. Um es auf den anderen Stapel zu drehen, müssen wir jedes Element einzeln verschieben. Während wir Elemente bewegen, prüfen wir, ob Nullen vorhanden sind. Wenn wir einem begegnen, müssen wir die Räume dorthin zurückversetzen, wo sie hingehören. Wir setzen die Null und fügen eine Menge Leerzeichen hinzu. Woher wissen wir, wie viele? Wir behalten den Überblick; Das Umdrehen eines Stapels im Gegensatz zum Duplizieren oder Umkehren eines Stapels ist eine sehr unintensive Aufgabe, sodass wir tatsächlich über den Speicher verfügen, um einen zusätzlichen Zähler zu speichern und darauf zuzugreifen, um zu verfolgen, wie viele Speicherplätze hinzugefügt werden müssen. Jedes Mal, wenn wir Leerzeichen hinzufügen, verringern wir den Zähler um eins. Der Zähler sollte in der letzten Zeile (am oberen Rand des V) auf Null stehen und somit können wir drucken.

Zuletzt bereinigen wir ein paar Dinge und beenden das Programm für die implizite Ausgabe.

Jelly , 15 12 Bytes

⁶ṁ⁸;;\Uz⁶ŒBY

Probieren Sie es online!

Wie es funktioniert

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

Probieren Sie es online!

Python 2 , 65 Bytes

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

Probieren Sie es 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>

Netzhaut , 51 47 Bytes

Alles Gute zum Geburtstag von einer anderen Sprache, die Saiten verarbeitet!

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

;{*`.¶

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

Probieren Sie es online!

Erläuterung

$
$.`$* 

Hiermit werden nLeerzeichen (wobei ndie Zeichenfolgenlänge ist) angehängt , indem das Ende der Zeichenfolge abgeglichen, die Länge der Zeichenfolge mit abgerufen $.`und ein Leerzeichen so oft mit wiederholt wird $*.

$
¶$`

Wir duplizieren die gesamte Zeichenkette (durch einen Zeilenumbruch getrennt), indem wir das Ende der Zeichenkette erneut abgleichen und die Zeichenkette selbst mit einfügen $`.

O$^r`.\G

Dies kehrt die zweite Zeile um, indem von rechts nach links ( r) abgeglichen wird und dann jeweils ein Zeichen abgeglichen wird ( .), wobei jedoch sichergestellt wird, dass alle Zeichen benachbart sind ( \G). Auf diese Weise kommen die Streichhölzer nicht über den Zeilenvorschub hinaus. Dies wird dann in einer Sortierstufe verwendet. Wenn Sie den $Sortiermodus ( ) verwenden, aber jede Übereinstimmung durch eine leere Zeichenfolge ersetzen, erfolgt keine eigentliche Sortierung. Aufgrund der ^Option werden die Übereinstimmungen am Ende umgekehrt, wodurch die gesamte zweite Zeile umgekehrt wird.

;{*`.¶

Diese Stufe ist für die Ausgabe vorgesehen und wirkt sich auch auf den Rest des Programms aus. {Wickelt die verbleibenden Stufen in eine Schleife, die wiederholt wird, bis diese Stufen die Zeichenfolge nicht mehr ändern (was passiert, weil die letzte Stufe nicht mehr übereinstimmt). Die ;Ausgabe wird am Ende des Programms deaktiviert. Das *verwandelt diese Stufe in einen Probelauf, was bedeutet, dass die Stufe verarbeitet und das Ergebnis gedruckt wird, aber danach wird die vorherige Zeichenfolge wiederhergestellt.

Die Bühne selbst entfernt einfach einen Zeilenumbruch und das vorhergehende Zeichen. Das gibt uns eine Zeile der gewünschten Ausgabe (beginnend mit der ersten Zeile).

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

Schließlich verwandelt diese Stufe jede Zeile in die nächste. Hierzu wird ein Leerzeichen vor dem ersten Nicht-Leerzeichen eingefügt, wobei das letzte Zeichen in der ersten Zeile sowie das erste Zeichen in der zweiten Zeile entfernt werden. Dieser Vorgang wird beendet, sobald in der ersten Zeile nur noch ein Leerzeichen vorhanden ist, das der letzten Zeile der Ausgabe entspricht.

05AB1E , 12 Bytes

Dgð×J.p€ûR.c

Probieren Sie es online!

Erläuterung

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

Oder für die gleiche Anzahl von Bytes aus der anderen Richtung.

Âsgú.sí€ûR.c

Erläuterung

             # 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 wünscht noch viele erfolgreiche Golfjahre!

²¬£²îU²ç iYU)ê

Benötigt die -RFlagge. Online testen!

Erläuterung

Dies nutzt die çund îFunktionen, die ich vor ein paar Tagen hinzugefügt habe:

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

Dennis 'Technik ist ein Byte länger:

U+Uç)å+ mw y mê

GNU sed , 110 100 + 1 (r Flag) = 101 Bytes

Edit: 9 Bytes kürzer dank Riley

Sed wünscht V als weitere Saitenmanipulationssprache alles Gute!

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

Probieren Sie es online!

Erläuterung: Angenommen, die Eingabe ist der letzte Testfall ('V!'). Der Klarheit halber werde ich den Musterraum bei jedem Schritt anzeigen und Leerzeichen durch 'S' ersetzen.

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

Probieren Sie es online!

Ich bin mir sicher, dass dies nicht optimal ist, aber es ist zumindest ziemlich pythonisch:

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 wünscht V alles Gute zum Geburtstag!

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

Probieren Sie es hier aus! ␅sollte 0x05 sein.

Erläuterung

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

Kohle , 29 Bytes

Alles Gute zum Geburtstag V, von Ihrem Kollegen, der sich enttäuschend lange nach dieser herausfordernden ASCII-Kunstsprache sehnt!

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

Probieren Sie es online!

Erläuterung

Unsere Strategie: Drucken Sie die linke Hälfte des V von unten nach links oben; dann reflektiere es.

Ｓσ                                    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

(Wenn nur Charcoal das Aufschneiden von Strings gehabt hätte ... leider scheint das noch nicht implementiert worden zu sein.)

Pip , 32-25 Bytes

a.:sX#aL#a{OaDQaPRVaaPUs}

Nimmt die Eingabezeichenfolge als Befehlszeilenargument. Probieren Sie es online!

Erläuterung

                           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 mit Stringipaket, 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()

Wenn Sie R im interaktiven Code ausführen, geben Sie nach dem Einfügen meiner Antwort einfach etwas ein. Sie müssen das stringi R-Paket installieren (ich hoffe, es verstößt nicht gegen die Regeln).

Erläuterung:

Die Grundidee besteht darin, Leerzeichen an der linken Seite einzufügen und diese dann auf die richtige Länge zu schneiden. Fügen Sie es anschließend mit der umgekehrten Version als rechte Seite ein. Hier ist eine längere, für Menschen lesbare Version der Funktion:

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}

Mein Verfahren bestand darin, das erste Zeichen aus der rechten Hälfte jeder Zeile zu entfernen, nachdem die erste Hälfte umgekehrt wurde. So was:

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

Ich bin es nicht gewohnt, Golf zu spielen, also lass es mich wissen, wenn ich etwas tun kann, um es kürzer zu machen.

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

Die Zeilen 1 und 6 haben ein Leerzeichen am Ende. Bearbeiten: 1 Byte dank @ ConorO'Brien gespeichert.

Haskell , 76 Bytes

vist die Hauptfunktion, ein StringArgument zu nehmen und ein StringErgebnis zu geben.

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

Probieren Sie es online!

Anmerkungen:

• i ist das ursprüngliche Argument / die ursprüngliche Eingabe.
• swird anfangs imit length iLeerzeichen angehängt.
• v iruft auf r sund verbindet dann die Ergebniszeilen.
• rgibt eine Liste von StringZeilen zurück.
• tist smit dem letzten Zeichen abgehackt.
• Die Rekursion r terzeugt die Zeilen mit Ausnahme der ersten, abzüglich des Anfangsabstands in jeder Zeile.

Gelee , 13 Bytes

⁶ṁ;@µḣJUz⁶ŒBY

Probieren Sie es online!

Wie?

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

bearbeiten: überschüssiges Leerzeichen entfernt

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

Ich fand es tatsächlich ziemlich schwierig, dieses Spiel in Ruby zu spielen. Nach dem Hinzufügen von Whitespace wird es zu einem ziemlich lesbaren Codeausschnitt erweitert:

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

Zum ersten Mal Code Golf. Trinkgelder sind willkommen!

Programmausgabe:

Bearbeiten:

40 Bytes gespart dank Luis Mendo.

PHP, 95 92 85 80 78 77 Bytes

Anmerkung: Verwendet die IBM-850-Codierung

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

Laufen Sie wie folgt:

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          

Erläuterung

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.

Optimierungen

• 3 Bytes gespart, indem das Pad-Zeichen entfernt wurde ( str_padstandardmäßig Leerzeichen, was wir brauchen)
• Es wurden 7 Bytes gespart, indem Binäroperationen für die Zeichenfolge verwendet wurden, um sie zu kürzen substr
• Spart 5 Bytes durch Drehen der Zeichenkette beim Drucken der Rückseite. Verhindert, dass ein Backspace gedruckt werden muss, führt jedoch zu einem Leerzeichen in jeder Zeile.
• 2 Byte durch Auffüllen der Zeichenfolge mit einer komplexeren, aber kürzeren Methode gespeichert.
• Ein Byte wurde gespeichert, da der ~"0"Fall nicht berücksichtigt werden muss (ASCII 207), da angenommen werden kann, dass alle Eingaben druckbar sind (Thx @Titus).

JavaScript (ES6), 169 157 Bytes

(-10 Bytes dank 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

Eine rekursive Lösung. Ich bin neu in JavaScript, also sei bitte vorsichtig! Alle Golftipps werden sehr geschätzt. :)

Und natürlich alles Gute zum Geburtstag V!

Testschnipsel

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

Alles Gute zum Geburtstag von deinem alten Kumpel CJam!

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

Probieren Sie es online!

Erläuterung

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

Rufen Sie es mit einem einzelnen Parameter auf, z .\V.ps1 Hello.

Bearbeiten: 2 Bytes mit Tipp von AdmBorkBork gespeichert

Pyke , 14 Bytes

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

Probieren Sie es 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):'')

Testfälle

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(,#&' ')~)~+:@#)