Alles Gute zum Geburtstag V!

72

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 , 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 , 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. :)

DJMcMayhem
quelle
Kann ich nach jeder neuen Zeile ein einzelnes Nullzeichen (0x00) ausgeben?
Wheat Wizard
@wheatwizard Hmm. Es ist ein bisschen komisch, aber ich denke, das ist in Ordnung, solange die Ausgabe visuell gleich ist.
DJMcMayhem
21
Der 5. Geburtstag wird etwas anderes sein! (In römischen Ziffern)
Albert Renshaw
5
Viele Grüße an die V-Sprache von der Vee :-)
Die Vee

Antworten:

44

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
Luis Mendo
quelle
Sehr interessanter Ansatz! +1
seshoumara
3
@seshoumara Danke! Wie Flawr sagt, ist Faltung der Schlüssel zum Erfolg :-)
Luis Mendo
38

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.

DJMcMayhem
quelle
Ich habe daran gearbeitet, aber ich denke, es ist passender, dass Sie antworten!
nmjcman101
29

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!

Ein Taco
quelle
23

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

Beispiel Fisch laufen

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

PidgeyUsedGust
quelle
Sie sollten wahrscheinlich die Golf-Version zur Hauptversion machen
Destructible Lemon
1
@DestructibleWatermelon der Beitrag handelt jedoch eher von der V-Version, da es viel schwieriger war, alles in einer bestimmten Form mit nur einer begrenzten Anzahl von verfügbaren Bytes zu formen . Es folgt daher eine Erläuterung für die V-Version und nicht für die einfache. Vielleicht mache ich später ein Golfspiel.
PidgeyUsedGust
Das ist Gold, nur Gold
Christopher
Ich weiß zu schätzen, dass diese Antwort in einer Sprache verfasst ist, deren Name ausschließlich aus gedrehten V besteht.
Sellyme
19

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.

Test 1

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.

Test 2

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.

Test 3

Weizen-Assistent
quelle
Sehr beeindruckend, dass Sie es geschafft haben, es überhaupt zum Laufen zu bringen! Glauben Sie, Sie könnten Bytes sparen, indem Sie es umgekehrt lassen und das -rFlag hinzufügen ?
DJMcMayhem
@ DJMcMayhem Ich glaube nicht. Der Umkehrprozess und das Einfügen von Leerzeichen erfolgen gleichzeitig. Wenn ich also das -rFlag hinzufüge, muss ich es tatsächlich ein weiteres Mal umkehren. Es wird spät, wo ich bin, aber ich denke, ich werde versuchen, dies morgen deutlich zu reduzieren. Wenn ich das Platzproblem beheben kann, werde ich definitiv die -rFlagge verwenden.
Wheat Wizard
16

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.
Dennis
quelle
Es sind 12 Zeichen, aber gibt es eine Codierung, bei der es nur 12 Bytes ergeben würde?
Kasperd
1
Ja, Jelly verwendet eine eigene Codepage .
Dennis
16

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>

Neil
quelle
Könntest du einen Beitrag schreiben, der dies erklärt? Der Ersatz und die regulären Ausdrücke verwirren mich ein wenig.
Jacob Persi
@JacobPersi Sie sind ein roter Hering. Alles, was ich brauche, ist ein Ausgabebereich mit der Größe n*2von n*4(einschließlich der Zeilenumbrüche am Ende jeder Zeile). Ich berechne dann das Zeichen, das in jeder Zelle erscheinen soll.
Neil
Nett! Sie können ein Byte abschneiden, indem Sie den Zeilenumbruch zwischen f=und entfernen s=>.
Yummypasta
@yummypasta Das f=ist nur ein Teil des Snippets, nicht die Antwort. Als solches ist es nicht in der Byteanzahl enthalten.
Neil
11

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.

Martin Ender
quelle
Würde mich über eine Erklärung freuen, wie das funktioniert. Ich weiß, dass die Syntax von sed weniger kompakt ist, aber mein Entwurf ist zweimal länger. Das Umkehren des Strings und das Zusammenfügen der ersten Ausgabezeile ist der größte Teil davon.
Seshoumara
@seshoumara Sicher, los geht's.
Martin Ender
Vielen Dank. Jetzt weiß ich, dass ein Sed-Skript mit doppelter Länge nicht schlecht ist :)) aufgrund zusätzlicher s///Zeichen, die sich summieren, längerer Zeichenfolgenumkehr und anderer Operationen, denen die Feinheiten von Retina fehlen. Gut zu lesen. +1
seshoumara
9

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
Emigna
quelle
2
Wenn Sie die Kommentare inkrementell
einrücken,
9

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ê
ETHproductions
quelle
5

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)
Seshoumara
quelle
@ Riley Antwort aktualisiert, danke!
Seshoumara
4

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]
Hactar
quelle
4

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
Conor O'Brien
quelle
4

Kohle , 29 Bytes

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

SσF…·¹Lσ«Fι§σκMι←↖»Fσ«Pσ↖»‖O→

Probieren Sie es online!

Erläuterung

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

Sσ                                    Input σ as string
                                       The bottom len(σ) half-rows:
   F…·¹Lσ«           »               For ι in inclusive range from 1 to length(σ):
            Fι                          For κ in range(ι):
               §σκ                         Print character of σ at index κ
                  Mι←                   Move cursor ι spaces leftward
                      ↖                  Move cursor one space up and left
                                       The top len(σ) half-rows:
                        Fσ«    »      For each character ι in σ:
                            Pσ          Print σ without moving the cursor
                               ↖         Move cursor one space up and left
                                 ‖O→  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.)

DLosc
quelle
Obwohl Charcoal kein String-Slicing hatte, war dies CycleChopder Fall, mit dem der Kopf des Strings extrahiert werden kann, wodurch 4 Bytes gespart werden. Es gibt jedoch einen besseren Ansatz, der 9 Bytes einspart. Weitere Einsparungen, von denen ich denke, dass sie zu der Zeit auch funktionierten: ReflectStandardmäßig spiegeln sie ein weiteres Byte wider, und eine der Variablen ist für die erste Eingabe vordefiniert, wodurch zwei Bytes gespart werden.
Neil,
4

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
DLosc
quelle
4

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()
atajti
quelle
Willkommen auf der Seite! :)
DJMcMayhem
4

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.

user3334690
quelle
Willkommen auf der Seite, das ist eine schöne Antwort! Leider weiß ich wirklich nicht viel über Rubin, daher kann ich keine Tipps geben. Möglicherweise finden Sie auf dieser Seite jedoch etwas.
DJMcMayhem
Vielen Dank! Es gibt viele interessante Dinge auf dieser Seite, aber ich scheine bereits viele davon zu tun. Mir war klar, dass ich durch Nebeneffekte und die Reihenfolge der Operationen einige Bytes einsparen konnte.
user3334690
1
Ich nehme an, dass [Ruby] nur Ruby ist, die mehr oder weniger bekannte Programmiersprache?
8.
Sie können 8 Bytes einsparen, indem Sie dies zu einem Lambda machen .
Jordanien
4

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.

Neil
quelle
1
Hier ist eine verschlungene Methode zum Speichern eines Bytes . (Erstellen Sie einen Alias ​​für @set und entfernen Sie ihn @echo off, und fügen Sie ihn @nach Bedarf ein.
Conor O'Brien
@ ConorO'Brien Danke, ich hätte nie gedacht, dass setmir 8 s genug Bytes erspart hätten, damit es sich lohnt.
Neil
3

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.
Ørjan Johansen
quelle
2
+1 für die Benennung der Hauptfunktion v. : D
DJMcMayhem
1
@DJMcMayhem: nicht die Hauptfunktion Namensgebung ist ein Byte länger: unlines.r.((++)<*>(' '<$)).
Nimi
1
@nimi Ich nehme an, er mochte den Namen, den ich gewählt habe. Technisch gesehen eine Lambda-Beziehung ... Als ich die Antwort schrieb, wusste ich nicht, dass Sie für einige Funktionen Deklarationen der obersten Ebene verwenden können, ohne die Hauptfunktion zu benennen. Obwohl ich jemand anderes gesehen habe, finde ich es etwas störend. Heutzutage funktioniert es zumindest in GHCi.
Ørjan Johansen
3

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
Jonathan Allan
quelle
Gleichgesinnte denken großartig. : P
Dennis
Oh mein ich habe nicht über eine kumulative Verkettung nachgedacht! Holzkohle hat eine V-Richtung, vielleicht einige Untersuchungen darüber ...
Jonathan Allan
3

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
Sculper
quelle
1
Sie könnten wahrscheinlich ein bisschen sparen, indem Sie an Länge eine Variable setzen, wie ich es getan habe? Ich denke, Sie sollten auch überlegen, Größe statt Länge zu verwenden.
user3334690
Tun, was @ user3334690 vorschlug und Verschieben der .times-Anweisung, 79 Bytes:s=ARGV[0];(s+=' '*s.size).size.times{|i|puts s+s[i..-2].reverse;s=' '+s[0..-2]}
Conor O'Brien
Sie können fünf Bytes sparen, indem Sie dies zu einem Lambda machen .
Jordanien
3

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:

MATLAB Code Golf

Bearbeiten:

40 Bytes gespart dank Luis Mendo.

Grant Miller
quelle
2
Willkommen bei PPCG und schöne erste Antwort! Leider weiß ich nichts über MATLAB, deshalb kann ich Ihnen beim Golfen nicht weiterhelfen, aber vielleicht finden Sie einige hilfreiche Tipps :-)
ETHproductions
1
Die Eingabe einer Zeichenfolge einschließlich der Anführungszeichen ist standardmäßig zulässig. So können Sie entfernen 's'aus input. Ich verstehe auch nicht, warum Sie verwenden evalc(disp(...)), aber ich denke, Sie können nur auf cell2mat diese Weise verwenden
Luis Mendo
1
Auch flipist kürzer als end:-1:1, siehe hier
Luis Mendo
3

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).
aross
quelle
echo$s,strrev($s=" $s"^$s^$s),~§;spart 5 Bytes.
Titus
@ Titus, thx. Normalerweise vermeide ich es, Leerzeichen
nachzustellen
~$s[$i++]ist ausreichend (Eingabe ist druckbar ASCII, und so ist $s)
Titus
@ Titus, thx, guten Fang. Ich neige dazu, auf der sicheren Seite zu
codieren
2

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

R. Kap
quelle
1
Das ist ziemlich gut! Normalerweise s.split("")kann geändert werden , um [...s], und a.join("")kann worden a.joindurch ein Paar von Backticks gefolgt. Sie können weitere 3 Bytes speichern, indem Sie [r='repeat']und [r]durch einfaches 'Wiederholen' ersetzen , dasselbe mit slice.
Conor O'Brien
@ ConorO'Brien Danke für die Tipps! Sie werden sehr geschätzt. :)
R. Kap
2

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)
Geschäfts-Katze
quelle
2

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

Tor
quelle
1
A Probieren Sie es online aus! Link, falls Sie interessiert sind.
Dennis
Oh, ich wusste nichts über dieses kleine Werkzeug, danke!
Tor
Hallo! Ein paar kleine Golfplätze vorne. Nehmen Sie die Eingabe als Zeichenfolge und übergeben Sie die Variable mithilfe der Kapselung. Spart zwei Bytes. $l=($s="$args")|% Le*;
AdmBorkBork
Wow, wusste nicht über diese 2 Golfplätze Bescheid, danke!
Tor
2

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

Arnauld
quelle
2

J, 44 Bytes

(([(,}.@|.)@{."1-@i.@[|."0 1(,#&' ')~)~+:@#)
Mark Allen
quelle
1
Hmm, ich kann nicht herausfinden, wie ich das online machen soll. Probieren Sie es online! Nenne ich es nur falsch? (Ich bin ein J-Neuling)
DJMcMayhem
@DJMcMayhem Das ist eine Funktion, kein Programm. tio.run/nexus/…
Dennis
Golf: |."0 1bis |."{(2 Bytes gespeichert)
Conor O'Brien
Außerdem müssen die äußeren Klammern nicht angegeben werden.
Conor O'Brien