Einführung

Alice ist eine 2-D-Sprache von Martin Ender, die zwei verschiedene Ausführungsmodi hat, Kardinal und Ordinal . Wenn der Befehlszeiger übergibt , durch einen Spiegel (entweder /oder \), schaltet er von einem Modus zum anderen.

In dieser Herausforderung konzentrieren wir uns auf den Ordnungsmodus , in dem Befehle auf Zeichenfolgen ausgeführt werden und der Befehlszeiger sich diagonal bewegt und gegen die Kanten des Codes prallt.

Einfache Programme, die nur im Ordnungsmodus arbeiten, können in einem recht kompakten Stil geschrieben werden, wie im folgenden Beispiel:

/fbd/
@aec\

Hier wird die IP beginnt in Kardinal - Modus von der ersten Zelle in Richtung Osten, durch den ersten Spiegel und beginnt sich zu bewegen diagonal und Prellen, Ausführen von Befehlen a, bund c. Es trifft dann den Nordosten Spiegel, der es nach Süden in Richtung der anderen Spiegel gehen lässt und starten Sie dann zurück in Richtung Westen prallt, stoßen Befehle d, e, fund schließlich @, die das Programm beendet.

Diese Art von Struktur ist recht kompakt, aber nicht einfach zu schreiben und zu warten (das Hinzufügen eines einzelnen Befehls kann dazu führen, dass wir den größten Teil des Codes neu anordnen müssen!). Daher möchte ich, dass Sie mir bei der Formatierung helfen.

Die Aufgabe

Ordnen Sie bei einer Befehlsfolge, bei der jeder Befehl ein einzelnes druckbares ASCII-Zeichen ist, diese in zwei Zeilen neu an, sodass die erste Hälfte der Folge beginnend mit dem ersten Zeichen der zweiten Zeile gelesen werden kann und sich dann immer diagonal nach rechts bewegt. während die zweite Hälfte gelesen werden kann, wobei die verbleibenden Zeichen von rechts nach links genommen werden. Mach dir keine Sorgen über Spiegel und das Abschlusssymbol, ich werde sie selbst hinzufügen.

So abcdefsollten Sie beispielsweise bei gegebener Eingabe ausgeben

fbd
aec

Wenn die Eingabe ungerade ist, sollten Sie irgendwo ein einzelnes Leerzeichen hinzufügen (was in Alice ein Noop ist), solange die Reihenfolge der gefundenen Befehle gleich bleibt. Sie können auch zwei Zeilen ausgeben, deren Länge sich um ein Zeichen unterscheidet. In diesem Fall wird davon ausgegangen, dass die kürzere Zeile am Ende ein einzelnes Leerzeichen enthält.

Regeln

Dies ist Code-Golf , die kürzeste Antwort in Bytes gewinnt!

• Sie können über eine der Standardeingabe- / Ausgabemethoden eingeben / ausgeben
• Die Eingabe besteht aus einer einzelnen Zeile druckbarer ASCII-Zeichen
• In der Ausgabe ist eine einzelne nachfolgende Newline zulässig
• Einige Ausgaben Ihres Programms verhalten sich möglicherweise nicht vollständig korrekt, wenn sie als Alice-Programme ausgeführt werden (z. B. wenn der Auffüllbereich in ein Zeichenfolgenliteral eingefügt wird). Sie müssen sich nicht mit diesen Situationen befassen
• Standardlücken sind verboten

Testfälle

--Input
abcdef
--Output
fbd
aec

--Input
123
--Output
 2
13
OR
31
 2
OR
3
12
OR
32
1

--Input
O
--Output
O

OR

O

--Input
"Hello, World!"o
--Output
oH!lloo 
""edlr,W

--Input
i.szR.szno
--Output
o.zz.
inssR

--Input
"  ^^} .~[}.~~[}{~~{}[^^^^.""!}"r.h~;a*y'~i.*So
--Output
o *^i}'.*[;.h~r}}~"{.[^
"S .^~ y~a}~~.["{!~"}^^^
(Odd length, your solution may be different)

Gelee , 15 Bytes

œs2U2¦ṚZUJḤ$¦ZY

Probieren Sie es online aus!

Nimmt zitierte Eingaben entgegen.

Erläuterung:

œs2U2¦ṚZUJḤ$¦ZY Main link, monadic
œs2             Split into 2 chunks of similar lengths, last might be shorter
   U2¦          Reverse the 2nd chunk
      Ṛ         Swap the chunks
       Z        Transpose into chunks of length 2
        UJḤ$¦   Reverse the chunks at even indices (1-indexed)
             Z  Transpose into 2 chunks again
              Y Join by a newline

Alice , 28 Bytes

/mY. zm~wZ.k;
\I;'!*?RR.OY@/

Probieren Sie es online aus!

Wenn die Eingabelänge ungerade ist, wird der Füllraum am Ende des linearisierten Programms platziert, das am Ende das erste Zeichen der Ausgabe ist.

Leo hat vor ein paar Tagen in Alice einen Ordinalformatierer geschrieben. Nachdem wir die Unterstützung für Eingaben mit ungerader Länge hinzugefügt und einige Dinge entfernt hatten, die für diese Herausforderung nicht erforderlich waren, wurden 28 Bytes erstellt . Ich wollte einen etwas anderen Ansatz ausprobieren, das ist diese Antwort. Leider hat es gerade 28 Bytes gebunden, aber zumindest auf diese Weise kann ich meine eigene Lösung veröffentlichen und Leo seinen ursprünglichen Algorithmus veröffentlichen lassen.

Dies nutzt Leos wirklich clevere Idee, um eine Saite mit in zwei Hälften zu teilen ..Y;m;.!z?~.

Erläuterung

Nehmen wir an, dass die Eingabe eine gerade Länge hat (weil wir sie nur mit einem Leerzeichen auffüllen, wenn dies nicht der Fall ist). Das Muster ist etwas einfacher zu erkennen, wenn wir es 0123456789als Code verwenden. Die erforderliche Ausgabe wäre:

91735
08264

Die erste Zeile enthält also alle ungeraden Positionen des Eingangs und die zweite Zeile alle geraden Eingänge. Wenn wir die ungeraden Positionen umkehren, sind die Linien selbst beide die erste Hälfte (möglicherweise länger), die mit der Umkehrung der zweiten Hälfte verschachtelt ist.

Die Grundidee lautet also:

• Trennen Sie die Eingabe in ungerade und gerade Positionen.
• Füllen Sie die ungeraden Positionen bei Bedarf mit einem Leerzeichen auf.
• Kehren Sie die ungeraden Positionen um.
• Dann zweimal: Die aktuelle Zeichenfolge halbieren, die zweite Hälfte umkehren, beide Hälften verschachteln, mit nachlaufendem Zeilenvorschub drucken.

Der Code ähnelt stark dem Layout, das wir in dieser Herausforderung erstellen, ist jedoch etwas anders: Wenn die IP /am Ende des Codes die IP-Adresse erreicht, wird sie nach Osten und nicht nach Süden reflektiert . Im Kardinalmodus wird die IP-Adresse dann in die erste Spalte umgebrochen. Der \dortige Modus wechselt wieder in den Ordnungsmodus, sodass die zweite Hälfte des Codes hier nicht von rechts nach links, sondern auch von links nach rechts verläuft. Dies ist bei der Arbeit mit dem Rücksprungadressenstapel von Vorteil, da dort keine Informationen über die IP-Richtung gespeichert werden. Auf diese Weise können wir einige Bytes sparen, da sich die IP auf beiden wund in die gleiche (horizontale) Richtung bewegt k.

Der linearisierte Code lautet wie folgt:

IY' *mRw..Y;m;.!z?~RZOk@

Lassen Sie uns das durchgehen:

I       Read one line of input.
Y       Unzip. Separates the string into even and odd positions.
' *     Append a space to the odd half.
m       Truncate: discards characters from the longer of the two
        strings until they're the same length. So if the input
        length was even, appending a space will make the odd half
        longer and this discards the space again. Otherwise, the
        space just padded the odd half to the same length as the
        even half and this does nothing.
R       Reverse the odd half.
w       Push the current IP address to the return address stack.
        The purpose of this is to run the following section
        exactly twice.

          This first part splits the current line in half, based
          on an idea of Leo's:
  ..        Make two copies of the current half.
  Y         Unzip one of the copies. The actual strings are irrelevant
            but the important part is that the first string's length
            will be exactly half the original string's length (rounded up).
  ;         Discard the potentially shorter half.
  m         Truncate on the original string and its even half. This shortens
            the original string to the first half of its characters.
  ;         Discard the even half, because we only needed its length.
  .!        Store a copy of the first half on the tape.
  z         Drop. Use the first half to discard it from the original string.
            This gives us the the second (potentially shorter half).
  ?         Retrieve the first half from the tape.
  ~         Swap it so that the second half is on top.
          The string has now been split in half.
  R       Reverse the second half.
  Z       Zip. Interleave the two halves.
  O       Print the result with a trailing linefeed.

k       Pop an address from the return address stack and jump back there.
        The second time we reach this, the return address stack is empty,
        and this does nothing.
@       Terminate the program.

Gelee , 23 22 Bytes

-1 Byte dank Leo (unten links kann die Auffüllung sein)

LḂ⁶ẋ;µṚ,µm2œs2U0¦ż/µ€Y

Ein vollständiges Programm, das das Ergebnis druckt (der monadische Link gibt eine Liste mit Listen mit Zeichenlisten zurück).

Probieren Sie es online aus! oder sehen Sie sich eine Testsuite an .

Wie?

LḂ⁶ẋ;µṚ,µm2œs2U0¦ż/µ€Y - Main link: list of characters
L                      - length
 Ḃ                     - modulo 2
  ⁶                    - literal space character
   ẋ                   - repeat
    ;@                 - concatenate (swap @rguments) (appends a space if the input's length is odd)
      µ                - monadic chain separation, call that s
       Ṛ               - reverse s
        ,              - pair with s
         µ         µ€  - for €ach:
          m2           -   modulo 2 slice (take every other character)
            œs2        -   split into two "equal" chunks (first half longer if odd)
               U0¦     -   upend index 0 (reverse the second chunk)
                   /   -   reduce by:
                  ż    -     zip
                     Y - join with newlines (well just the one in this case)
                       - implicit print (mushes the sublists together)

JavaScript (ES6), 104 Byte

f=
s=>s.replace(/./g,(c,i)=>a[1&~i][i+i>l?l-i:i]=c,a=[[` `],[]],l=s.length-1|1)&&a.map(a=>a.join``).join`
`

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

Funktioniert durch Emulieren des Ausführungspfads und Ausfüllen der Befehle.