Entschlüsseln Sie das erweiterte Wechsler-Format

18

Diese Herausforderung basiert auf einem Sandbox-Beitrag von user48538 . Da er auf dieser Seite nicht mehr aktiv ist, habe ich diese Herausforderung angenommen.


apgsearch , das verteilte Suppensuchprogramm für Conways Game of Life und die Suchergebnisdatenbank Catagolue, verwenden apgcodes , um Muster zu klassifizieren und zu kennzeichnen. apgcodes selbst verwenden das erweiterte Wechsler-Format , eine Erweiterung einer von Allan Wechsler 1992 entwickelten Musternotation .

Die folgenden Beispiele und Bilder stammen aus dem LifeWiki .

  1. Eine Folge von n Zeichen in der Menge, die mit dem regulären Ausdruck übereinstimmt, [0-9a-v]bezeichnet einen Streifen von fünf Zeilen mit einer Breite von n Spalten. Jede Figur zeigt die fünf Zellen in einer vertikalen Spalte zu den entsprechenden bitstrings [ 00000, 10000, 01000...00010 , 10010, 01010, 11010... 11111].

    Entspricht zum Beispiel 27deee6einem schweren Raumschiff :

27deee6

[01100001101111011111100111100000000]
  1. Das Zeichen ztrennt zusammenhängende fünfreihige Streifen.

    Entspricht beispielsweise 0ca178b96z69d1d96einem 31-Bit-Stillleben:

Bildbeschreibung hier eingeben

Bildbeschreibung hier eingeben

[000110110001010101010010001011001110000000000011111000100000100101010100011011000000000000]
  1. Die Zeichen wundx werden verwendet , um abzukürzen 00und 000sind.

    So w33z8kqrqk8zzzx33entspricht ein Trans-Bienenkönigin-Shuttle :

Bildbeschreibung hier eingeben

Bildbeschreibung hier eingeben

(10 leere Zeilen weggelassen)

Bildbeschreibung hier eingeben

[0011000001100000000000000000000000000010000011100010001010111010111110000000000000000000000000000000000000000000000000000000000000000000000000011000001100000000000000000000000]
  1. Schließlich entsprechen die Symbole, die dem regulären Ausdruck y[0-9a-z]entsprechen, Läufen von 4 bis 39 aufeinanderfolgenden 0s.

    Ein gutes Beispiel 31a08zy0123ckofür ein Schiff auf Quadpole ist :

Bildbeschreibung hier eingeben

Bildbeschreibung hier eingeben

[1100000000101000000000000000000010100000000000000000001010000000011000000000011000000001010000000011]

The Challenge

Write a program or a function to parse a string of the extended Wechsler format, defined above, and print (or return) the pattern corresponding to this string.

You may assume that the string is nonempty, and does not start or end with z.

You may use any reasonable output format, e.g., a string, a matrix, a 2d array. You may use any two values to represent 0 and 1, given that you declare them in the answer.

You may omit the trailing zeroes lines in the output, or add extra trailing zeroes lines. You may also add/omit trailing zeroes on each line, as long as all lines have the same length in the output.

You may return the transpose of the array, if that is more convenient.

This is , so the shortest code wins.

Test cases

153 => [[1, 1, 1], [0, 0, 1], [0, 1, 0], [0, 0, 0], [0, 0, 0]]
27deee6 => [[0, 1, 1, 0, 0, 0, 0], [1, 1, 0, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0]]
0ca178b96z69d1d96 => [[0, 0, 0, 1, 1, 0, 1, 1, 0], [0, 0, 1, 0, 1, 0, 1, 0, 1], [0, 1, 0, 0, 1, 0, 0, 0, 1], [0, 1, 1, 0, 0, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0, 1, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0, 0], [0, 1, 1, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]]
w33z8kqrqk8zzzx33 => [[0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 1, 0, 0, 0, 1, 0], [1, 0, 1, 1, 1, 0, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]
31a08zy0123cko => [[1, 1, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1]]
o5995ozes88sezw33 => [[0, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0], [1, 0, 1, 1, 0, 1], [1, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 1], [1, 1, 0, 0, 1, 1], [1, 1, 1, 1, 1, 1], [0, 1, 0, 0, 1, 0], [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
y3343x6bacy6cab6x343zkk8yy8kkzgo8gywg8ogz0123yw321zzgo4syws4ogzgh1yy1hgz221yy122zy3c2cx6d53y635d6xc2c => [[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1], [0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], [1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
alephalpha
quelle
Will z ever occur at the very beginning?
Mr. Xcoder
@Mr.Xcoder The LifeWiki page does not say anything about that. But you can assume here that the string does not start or end with z.
alephalpha
3
Not really a Game of Life pattern, but just for fun: vv99f60vv99f60uv11320uv19rqz33y133y11322310132231
Arnauld
1
"You may return the transpose of the array" - if that's OK, what about other symmetries like upside-down etc...?
Jonathan Allan
1
Two of the first three answers fail for some of these: 1yx1, 1yy1, 1yw1 and 1yz1. Maybe they should be tests.
Jonathan Allan

Antworten:

2

Charcoal, 50 bytes

UB0≔⁺⭆χιββFS¿υ×0⁺⊟υ⌕βι≡ιz×⸿⁵y⊞υ⁴x×0³w¦00«P↓⮌⍘⌕βι²→

Try it online! Link is to verbose version of code. Uses 1 and 0. Explanation:

UB0

Set the background, i.e. any unprinted cells of the rectangle enclosing the output, to 0.

≔⁺⭆χιββ

Prefix the digits to the predefined lower case alphabet.

FS

Loop over the input string.

¿υ

If the predefined empty list is not empty...

×0⁺⊟υ⌕βι

... then print a number of 0s given by the sum of the number popped from the list and the index of the current character in the digits and letters. See below for what that number always is.

≡ι

Switch over the current character.

z×⸿⁵

If it's a z then output 5 carriage returns, taking us to the next output strip.

y⊞υ⁴

If it's a y, then push 4 to the predefined empty list, causing 4+n 0s to be output next time.

x×0³

If it's an x then output 3 0s. (This is done via repetition to avoid the literal 0 touching the x or the following literal.)

w¦00

If it's a w then output 2 0s. (The ¦ is needed to separate the two string literals.)

«P↓⮌⍘⌕βι²→

Otherwise, index the current character in the digits and letters, convert to binary, and print the result downwards least significant bit first; then move the cursor right for the next column.

Neil
quelle
6

JavaScript (ES8), 197 Byte

Übernimmt die Eingabe als Zeichenfolge. Gibt ein Array von Strings mit '#' und Leerzeichen zurück. Die Ausgabe kann zusätzliche (aber konsistente) Leerzeichen in jeder Zeile enthalten.

s=>[x='x',...s.replace(/w|x|y./g,s=>''.padEnd(s<x?2:s>x?P(s[1],36)+4:3),P=parseInt)].map(c=>[!++w,1,2,3,4].map(i=>c<x?o[y+i-5]+=' #'[P(c,36)>>i&1]:o=[...++y&&o,'']),w=y=o=[])&&o.map(r=>r.padEnd(w))

Probieren Sie es online! (schöne Ausgabe)

Wie?

Globale Variablen

  • Das Zeichen "x"wird mehrmals verwendet, daher lohnt es sich, es in der Variablen x zu speichern .
  • Die Funktion parseIntwird zweimal verwendet, es lohnt sich also, sie in der Variablen P zu speichern .
  • y ist der auf 0 initialisierte Zeilenindex .
  • w verfolgt eine Obergrenze der Breite, die zum Auffüllen der endgültigen Ausgabe verwendet wird.
  • o [] ist das Ausgangsarray, anfangs leer.

Vorverarbeitung von wiederholten Nullen

Wir ersetzen zunächst alle Muster "w", "x"und "yX"in der Eingabezeichenfolge mit der entsprechenden Anzahl von Räumen. Diese Leerzeichen werden später als interpretiert "0".

s.replace(
  /w|x|y./g,
  s => ''.padEnd(
    // w --> 2
    s < x ? 2 :
    // yX --> value of X + 4
    s > x ? P(s[1], 36) + 4 :
    // x --> 3
    3
  )
)

Dekodierung

Wir teilen die resultierende Zeichenfolge, stellen eine Initiale "x"voran und iterieren 5 Mal (mit i = 0 bis 4 ) für jedes Zeichen c :

  • Wenn c kleiner als ist "x", hängen wir das entsprechende Muster an die nächsten 5 Zeilen an.

    o[y + i - 5] += ' #'[P(c, 36) >> i & 1]
  • Wenn c größer oder gleich ist "x", ordnen wir 5 neue leere Zeichenfolgen in o [] zu und addieren 5 zu y . Dies wird durch die Initiale ausgelöst, die "x"am Anfang der Zeichenfolge hinzugefügt wurde, oder durch eine beliebige "z"im ursprünglichen Inhalt.

    o = [...++y && o, '']

Polsterung

Schließlich füllen wir jede Zeichenfolge in o [] mit Leerzeichen auf, sodass sie alle w Zeichen enthalten.

o.map(r => r.padEnd(w))
Arnauld
quelle
6

05AB1E , 148 132 98 Bytes

Ich bin Gymnasiast und war das erste Mal, dass ich Golf gespielt und 05AB1E benutzt habe. Kommentare sind also willkommen!

„YY¾38×:'Yð:žLRDUsð«#εNĀiDнXsk4+s¦sú]'W¾2×:'X¾3×:J'Z¶:.Bð¾:vNUyvDykDNX‚Š32VY‹iY+b¦RX_i¶ì}‚ˆ]¯{€¦˜J

Probieren Sie es online!

Probieren Sie es online!

Probieren Sie es online!

Nimmt Eingaben als Großbuchstaben und gibt die transponierte Matrix als mehrere Ausgabezeilen mit 1 und 0 aus. Kann zusätzliche Nullen hinzufügen.

Wenn Sie mit Kleinbuchstaben testen möchten, fügen Sie uden TIO-Header hinzu.

Wenn Sie eine hübsch gedruckte Ausgabe wünschen, fügen Sie diese '1'█:'0'.:in die TIO-Fußzeile ein.

Erläuterung

(Ich rufe "Zeilen" und "Spalten" entgegengesetzt zu dem, was Sie vielleicht erwarten, weil es die transponierte Matrix erzeugt.)

Der grundlegende Algorithmus lautet:

  1. Ersetzen Sie "yy" durch 38 0s
  2. Teilen Sie auf "y" und und erweitern Sie die 0-Runs.
  3. Ersetze "w" und "x"
  4. Ermitteln Sie die längste Spalte (d. H. Die längste Zeichenfolge zwischen z) und füllen Sie alle anderen Spalten so auf, dass sie diese Länge haben. (Dies ist notwendig, da der folgende Algorithmus funktioniert.)
  5. Aufgeteilt auf z
  6. Zu diesem Zeitpunkt ist die Eingabezeichenfolge ein Array von Spalten, wobei jede Spalte eine Zeichenfolge von [0-9A-V] ist, wobei jede Spalte dieselbe Länge hat.
  7. Der Algorithmus, um es in das Ausgabeformat zu bekommen, ist zu
    1. Konvertieren Sie die Zeichen in Zahlen, indem Sie indexOf in einer Suchzeichenfolge verwenden
    2. Wandle die Zeichen in Binär um und fülle sie dann auf Länge 5 auf
    3. Wenn es sich um die erste Spalte handelt, fügen Sie vor der Binärzahl einen Zeilenumbruch ein
    4. Fügen Sie am Anfang der Binärzeichenfolge, in der die Zeile und dann die Spalte des Zeichens gespeichert sind, ein Präfix hinzu.
    5. Schieben Sie die Binärzeichenfolge mit dem Präfix in das Register / die Variable "global array" von 05AB1E
  8. Sortieren Sie das globale Array. Die Präfixzeichenfolge, die die Sortierreihenfolge bestimmt, stellt sicher, dass alles in der richtigen Reihenfolge endet und die Zeilenumbrüche an den richtigen Stellen stehen.
  9. Entfernen Sie die Präfixzeichenfolge aus jedem Element des globalen Arrays
  10. Verbinden Sie das Array mit "" und drucken Sie es aus.

Es gibt noch einige andere kleinere Details, die Sie unten im erweiterten Code sehen können. Alles nach den Tabulatoren am Ende einer Zeile ist ein Kommentar und kann ignoriert werden. (Dieses Kommentar-Schema ist übrigens nicht Teil von 05AB1E. Ich habe es so gemacht, weil es gut aussah.) Zeilen, deren Kommentare mit "@" beginnen, dienen Debugging-Zwecken und können weggelassen werden, ohne die endgültige Ausgabe zu ändern.

„YY¾38×:                                        Replace "YY" with 38 0's. (y is the 34th character in the index, so need to add 34+4 = 38). ¾ is initialized to zero, which saves one byte from typing '038
'Yð:                                            Replace "Y" with " "                                
"Replaced input Stage1 = "?D,                   @DEBUG

žLR                                             Pushes [0-9A-Za-z]
DU                                              Set X to [0-9A-Za-z] and leave [0-9A-Za-z] on the stack.
s                                               Swap top two elements. Now the stack is [0-9A-Za-z],input

ð«                                              Append a space so the below splitter works even if there are no other spaces.
#                                               Split input on " ", which "Y" has been replaced with
ε                                               Map. This map replaces the y runs
    "Element = "?D,                             @DEBUG
    "N = "?N,                                   @DEBUG
    NĀi                                         If N != 0   
        "Replacing!",                           @DEBUG
        Dн                                      Get the first letter
        X                                       Push X
        s                                       Swap
        k                                       X (which is [0-9A-Za-z]) .indexOf(firstLetter)
        "indexOf run token = "?D,               @DEBUG
        4+                                      Add 4 to the index, now becoming the number of zeros to add
        s                                       Swap. Now top is the string between runs
        ¦                                       Remove the first character
        s                                       Swap again. Now the top is the number of zeros to add.
        ú                                       Add that many spaces (will be replaced with zeros later) to the start of the element.
        "Element Replaced = "?D,                @DEBUG
]
'W¾2×:                                          Need to do this replacement after the Y replacement so stuff like YW gets parsed properly. Again, ¾ is zero.
'X¾3×:
J                                               Join with ""
"Replaced input Stage2 = "?D,                   @DEBUG
'Z¶:                                            Replace "Z" with "¶".
.B                                              "Squarify" command. Splits on \n and appends spaces to the end of each element so each is the same length. In this case, that is equivalent to adding zeros to the end of each column, which is what we want.
ð¾:                                             Replace spaces (which we used for padding above) with zeros.
"Replaced input Stage3 = "?D,                   @DEBUG
"0 Stack top = "?D,                             @SDEBUG
"0 Stack top-1 = "?sD,s                         @SDEBUG
v                                               pop and loop over top element, which is array of column code
    NU                                          Store the column number in X
    yv                                          Loop over each character in the column              
        "1 Stack top = "?D,                     @SDEBUG
        "1 Stack top = "?D,                     @SDEBUG
        D                                       Duplicate top element (which is now [0-9A-Za-z])
        y                                       Push y (special loop variable)
        "Character = "?D,                       @DEBUG
        k                                       Push indexOf y in [0-9A-Za-z]
        "Index = "?D,                           @DEBUG
        "2.1 Stack top = "?D,                   @SDEBUG
        "2.1 Stack top-1 = "?sD,s               @SDEBUG
        D                                       Duplicate index.
        NX‚                                     Push [rowNumber,columnNumber]. This result is used for sorting.
        Š                                       Triple swap. The top of the stack is now sortPrefix, index, index
        32V                                     Set Y to 32
        Y‹i                                     index < 32. This uses up one copy of index
            Y+                                  Add 32 to the index
            b                                   Push the index in binary. This uses the second copy of index. 
            ¦                                   Remove the first character, which will be a 1 because we added 32. The result is now a padded binary string of length 5
            "Binary = "?D,                      @SDEBUG
            R                                   Reverse the binary string. This gives the proper transposed output. 
            X_i                                 This will only run if X (which is set to the column number) == 0. (Runs !X)
                ¶ì                              Stick a linebreak at the beginning of the binary string
            }
            "2.5 Stack top = "?D,               @SDEBUG
            "2.5 Stack top-1 = "?sD,s           @SDEBUG         
            ‚                                   At this point the top of the stack is sortPrefix,binaryString. This will combine the two into a list.
            "Pushing '"?D?"'",                  @DEBUG
            ˆ                                   Push [[rowNumber,columnNumber],binaryString] to global array
            "2.6 Stack top = "?D,               @SDEBUG
            "2.6 Stack top-1 = "?sD,s           @SDEBUG
        ]                                       Close all blocks
¯                                               Push global array

{                                               Sort global array. 
"Sorted Data = "?D,                             @DEBUG
€¦                                              Remove the sort prefix              
˜                                               Flatten. Before doing this, the array is in the format [[<binary string>],[<binary string>],[<binary string>],...]
J                                               Join with ""
'1'█:'0'.:                                      @DEBUG pretty print 
kerwizzy
quelle
1
Hallo und willkommen bei PPCG; sehr schöner erster Beitrag! Bezüglich Ihrer Byteanzahl: Sie haben Recht. TIO zeigt mithilfe der 05AB1E-Codepage sogar mühelos an, dass die 148 Zeichen durch 148 Bytes dargestellt werden.
Jonathan Frech
Eine kleine Anmerkung: Die meisten Golfsprachen implementieren implizites Drucken. Ich denke, du kannst deinen letzten weglassen ,.
Jonathan Frech
Ich habe nachgesehen und einige Verbesserungen vorgenommen. Das Verhalten wird sich (theoretisch) nur für Dinge mit mehr als 1000 Zeilen oder Spalten unterscheiden. An diesem Punkt wird das kleinere Programm etwas Unerwartetes tun.
kerwizzy
Nicht die einfachste Herausforderung, um anzufangen! Gute Arbeit, ich kann mir vorstellen, dass einige der tüchtigen 05AB1E-Mitarbeiter nützliche Hinweise geben werden, wenn sie vorbeikommen.
Jonathan Allan
1
Willkommen bei PPCG und der Welt von 05AB1E. Momentan habe ich nicht so viel Zeit und ich habe erst vor ein paar Monaten angefangen, 05AB1E zu verwenden. Daher bin ich auch noch kein so großer Profi, aber hier ein paar kleine Dinge zum Golfen: "yy"Kann sein „yy(05AB1E hat sowohl ein 2-Zeichen- als auch ein 3-Zeichen-String (eingebaut). >≠kann sein Ā(wahrheitsgemäß, 0bleibt im Grunde 0und alles andere wird 1). }}kann sein ](schließen Sie alle Schleifen und wenn-elses). Ich bin sicher, einige der Pro 05AB1E-Golfer sind in der Lage, umfangreichere Dinge als ich zu spielen, möglicherweise sogar die Hälfte der Byteanzahl.
Kevin Cruijssen
4

APL (Dyalog Unicode) , 87 80 77 67 63 Bytes

danke an H.PWiz für das speichern von 7 bytes und ngn für weitere 13 17.

a←⎕D,⎕A⋄,⍉↓⊖(5/2)⊤↑35(≠⊆⊢)a'Y.|W|X'R{'0'/⍨30 36|a2↑⍵.Match}⍞

Probieren Sie es online!

NB: Nimmt die Eingabe als Großbuchstaben.

Mit hübscher Druckausgabe

Erläuterung

a←⎕D,⎕Aa ist die Zeichenfolge '0123...89ABCD...XYZ'
'Y.|W|X'⎕R{'0'/⍨+/30 36|a⍳2↑⍵.Match}ersetzt XW und Yx mit der entsprechenden Anzahl von '0's (ausführlicher erklärt unten) 35(≠⊆⊢)a⍳wandelt die Zeichenfolge in den Vektor von indecies in aund Spalten auf 35(dh) 'Z'eine verschachtelte Vektor Erstellen
wandelt die verschachtelten Vektors in eine Matrix padding Enden mit 0s
(5/2)⊤jeweils konvertiert Zahl in einen binären Vektor, der zu einer dreidimensionalen Matrix mit binären Vektoren entlang der Primärachse führt
Umkehrungen entlang der Primärachse
verringern den Rang der Matrix, sodass
,⍉das Ergebnis zweidimensional in die entsprechende Ausgabe umgewandelt wird

'Y.|W|X'R{'0'/⍨30 36|a2↑⍵.Match}
'Y.|W|X'R                          Regular expression replace. mathing the string.
                        2↑⍵.Match   Takes matching string (either 'X' 'W' or 'Y.') and pads with spaces to length 2
                      a            Returns the indecies of each charactor in a. on the spaces this is 36 (length of a)
                30 36|              Takes the remainders of the indecies when divided by 30 and 36 respectively. Overall 'W' -> 'W ' -> 32 36 -> 2 0, 'Y2' -> 'Y2' -> 34 2 -> 4 2.
           '0'/⍨                    Make vector of repeating '0's with length equal to the sum of the result. '0'/⍨4 2  '000000'
jslip
quelle
Hier ist eine 7 - Byte - Einsparung: a←⎕D,⎕A⋄,↓↑{⊖(5/2)⊤a⍳⍵}¨'Z'(≠⊆⊢)('Y.|W|X'⎕R{'0'/⍨{0::2+'WX'⍳⍵⋄4+a⍳1⊃⍵}⍵.Match})⍞. Der Fehler Fang scheint auch nicht sehr golfen
H.PWiz
Vielen Dank an H.PWiz. Ja, ich mag den Fehlerfang auch nicht, aber ansonsten habe ich zwei Regex-Ersetzungen verwendet.
Jslip
@ Jslip die Klammern herum ⎕Rund seine Operanden sind unnötig
ngn
2+'WX'⍳⍵->2+'X'=⍵
ngn
{0::2+'X'=⍵⋄4+a⍳1⊃⍵}⍵.Match->30 36|a⍳2↑⍵.Match
ngn
3

Perl 6 ,156 142 Bytes

Dank Jo King wurden 14 Bytes eingespart. ( yBehebung eines kleinen Fehlers beim Parsen des und Hinzufügen eines Prettifiers.)

Das fehlerhafte Parsen von wurde behoben y[wxy].

{s:g/y(.)/000{0 x:36(~$0)}/;s:g/x/w0/;s:g/w/00/;s/$/z/;map {
.flatmap:{:32($_).fmt("%05b").flip.comb}},[Z] .split("z").map: (*~0 x.chars).comb}

Probieren Sie es online!

Der Zeilenumbruch dient nur dazu, dass der Text auf den Bildschirm passt. Es ist nicht Teil des Programms.

Wie funktioniert es

Es ist eine anonyme Funktion, die eine veränderbare Zeichenfolge akzeptiert. (Dies macht die Verwendung der Funktion etwas eigenartig, da Sie nur Variablen und keine Literale angeben können.) Nach einiger Arbeit wird eine Liste von Listen mit 0en und 1en mit der gleichen Bedeutung wie im ursprünglichen Beitrag zurückgegeben.

Die Eingabezeichenfolge wird in die Variable eingegeben $_. Wir beginnen mit einer Reihe von Substitutionsanweisungen, um all diese Abkürzungen für verschiedene Anzahlen von Nullen zu beseitigen. Erstens müssen wir das aussortieren y, denn im Fall von yxoder ywstellt das w(oder x) keine Abkürzung für sich dar. Wir suchen nach y(.)( yund einem Zeichen, an das es sich erinnert) und ersetzen es durch 000{"0"x:36(~$0)}: Die drei Nullen werden wörtlich kopiert, dann konvertieren wir das nächste Zeichen von der Basis 36 zur Basis 10 ( :36(~$0)) und fügen die vielen weiteren Nullen hinzu. Dann ersetzen wir die w"s using" s:g/w/00/und die x"s using" s:g/x/000/. Schließlich s/$/z/fügen wir mit azam ende eine menge leerer zeilen nach unten setzen. (Wir werden den Grund später sehen.)

Der Rest ist nur eine große Kartenaussage. Wir mappen über .split("z").map: (*~0 x.chars).comb}), das ist die Eingabezeichenfolge (ohne Nullkurzzeichen), die in Zeilen bei aufgeteilt ist z, wobei jede Zeile zuerst mit 0 x.chars(Tonnen von Nullen, dh so viel wie die Gesamtlänge der Eingabezeichenfolge ist) auf der rechten Seite aufgefüllt wird und dann in eine Liste einzelner Zeichen ( .comb) zerlegt . Zum Schluss transponieren wir es mit [Z](verkleinern mit zip). Das Zippen endet, sobald die kürzeste Liste erschöpft ist, was zur Folge hat, dass alle Zeilen die gleiche Länge haben. (Die Anzahl der nutzlosen nachgestellten Nullen auf der rechten Seite entspricht der Länge der kürzesten Zeile. Außerdem schlägt dieser Transpositionstrick für eine "Matrix" mit nur einer Zeile fehl. Deshalb haben wir am Ende zuvor eine weitere Zeile hinzugefügt.)

Nun ordnen wir einfach die Zeilen (Spalten der ursprünglichen Matrix) zu und ersetzen jedes gefundene Zeichen durch die entsprechenden 5 Bits. Dies geschieht mit :32($_)(Basis 32 bis Basis 10) .fmt("%05b")(Format als Bitstring mit der Breite 5, aufgefüllt mit Nullen) .flip(Umkehren der Zeichenfolge, da sich das LSB in der oberen Zeile und nicht in der unteren Zeile befindet) .comb(Aufteilen der Zeichenfolge in eine Liste von Zeichen). Wir haben verwendet .flatmap, um die resultierende Liste zu verflachen (andernfalls würden wir eine Liste von Listen in jeder Spalte erhalten). Die Transponierung des Ergebnisses wird dann implizit zurückgegeben.

(Ich fühle mich ein bisschen schlecht, weil ich die Möglichkeit missbraucht habe, Nullen so stark nachzufolgen. Aber das hat die Anzahl der Bytes erheblich reduziert :-).)

Ramillies
quelle
142 Bytes
Jo King
@JoKing - Oh ja, vielen Dank!
Ramillies
Scheitert für 1yx1und1yw1
Jonathan Allan
@ JonathanAllan, du hast recht, danke. Ich werde es gleich beheben. (Ich dachte zuerst aus irgendeinem Grund, dass es nur solche geben könnte, y[0-9a-v]und als ich feststellte, dass dies nicht der Fall ist, fügte ich einfach eine schnelle (und falsche) Lösung hinzu.)
Ramillies
Sie können die 000in der y-Substitution durchx
Jo King
2

Jelly , 66 Bytes

Yowza!

ØBiⱮ+
Œuœṣ⁾YYj38Żṣ”YµḢç3;)Fṣ”Wj2ṣ”Xj3”0ẋ$¹OƑ?€Fṣ”Zµȯ”0ç31BḊ€UZ)Ẏz0

Eine monadische Verknüpfung, die eine transponierte Version als Liste von Listen ergibt (zum Zurücktransponieren Zam Ende hinzufügen ).

Probieren Sie es online! Oder sehen Sie sich die Testsuite an (mit hübscher gedruckter Ausgabe).

Jonathan Allan
quelle
2

Netzhaut , 203 Bytes

y(.)
#$1
{`#
0#
#0
000
)T`dl`_dl`#.
w
000
x
00
z
¶
%(`.+
$&¶$&¶$&¶$&¶$&
T`g-v`#`.+$
T`dl` `.+$
T`g-v`dl
T`89l`#`.+¶.+$
T`d` `.+¶.+$
T`89l`d
T`d`    #`.+¶.+¶.+$
T`4-7`d
T`d`  #`.+¶.+¶.+¶.+$
)T`d` # #
P`.+

Probieren Sie es online! Link enthält Testfälle. Alternative Lösung, auch 203 Bytes:

y(.)
#$1
{`#
0#
#0
000
)T`dl`_dl`#.
w
000
x
00
z
¶
%(`.+
$&¶$&
T`g-v`#`¶.+
T`dl` `¶.+
T`g-v`dl
^.+
$&¶$&
T`89l`#`¶.+
T`d` `¶.+
T`89l`d
^.+
$&¶$&
T`d`    #`¶.+
T`4-7`d
^.+
$&¶$&
T`d`  #`¶.+
)T`d` # #
P`.+

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

y(.)
#$1

Behandeln Sie zuerst den ungeschickten Fall des yBefehls. Leider darf der Brief danach ein yoder sogar ein sein z, deshalb müssen wir hier vorsichtig sein. Alle magischen ys werden zuerst in #s verwandelt .

{`#
0#
#0
000
)T`dl`_dl`#.

Eine Schleife verarbeitet dann das #s. Zunächst wird a dem 0vorangestellt #. Wenn dies ein #0ist, wird das geändert, 000wodurch die Operation abgeschlossen wird, andernfalls wird das Zeichen nach dem #dekrementiert und die Schleife wiederholt, bis alle #s verarbeitet wurden.

w
000
x
00

Repariere das ws und xs.

z
¶

In neuen Zeilen teilen. (Funktioniert S`zauch für die gleiche Byteanzahl.)

%(`.+
$&¶$&¶$&¶$&¶$&
T`g-v`#`.+$
T`dl` `.+$
T`g-v`dl
T`89l`#`.+¶.+$
T`d` `.+¶.+$
T`89l`d
T`d`    #`.+¶.+¶.+$
T`4-7`d
T`d`  #`.+¶.+¶.+¶.+$
)T`d` # #

Erstellen Sie 5 Kopien jeder Zeile, und führen Sie dann eine Binärkonvertierung durch, indem Sie Buchstaben mit dem entsprechenden Bit zuordnen #und dieses Bit löschen, während andere Buchstaben zu Leerzeichen werden. Die Bits werden in der Reihenfolge 16, 8, 4, 2 verarbeitet, und dann löscht die letzte Übersetzung das 2Bit und konvertiert das 1Bit gleichzeitig. (In der alternativen Version wird jede Kopie einzeln erstellt, was mehr Bytes kostet. Diese werden jedoch gespeichert, da die Bitverarbeitung vereinfacht wird.)

P`.+

Füllen Sie alle Zeilen auf die gleiche Länge auf.

Neil
quelle
1

Python 2 , 249 244 Bytes

def f(s,Z='0'):
 while'y'in s:i=s.find('y');s=s[:i]+4*Z+Z*int(s[i+1],36)+s[i+2:]
 t=s.replace('w',2*Z).replace('x',3*Z).split('z');return map(''.join,zip(*[[(Z*5+bin(int(c,32))[2:])[:-6:-1]for c in r]+[Z*5]*(max(map(len,t))-len(r))for r in t]))

Probieren Sie es online!

5 Bytes von Jonathan Frech gespeichert .

Chas Brown
quelle
Es gibt einen überflüssigen Raum in while 'y'in. Ich denke, der Index [-5:][::-1]kann zu Golf gespielt werden [:-6:-1]. Die return-Anweisung kann in die vorherige Zeile gestellt werden.
Jonathan Frech
1

JavaScript (ES8), 192 Byte

s=>[...s,"z"].map(c=>{h=parseInt(c,36);k="wxy".search(c)+1;y?k=h-y--:h-35?y=h>33:m=m.map(P,z+=5,i=k--);for(h=k?0:h;~k--;m[i]=h.toString(2)+P(m[i++]||""));},P=d=>d.padStart(z,0),m=[i=z=y=0])&&m

Gibt die Transponierte zurück, die dann über die vertikale Achse gespiegelt wird. Lassen Sie mich wissen, wenn dieser Eintrag ungültig ist. Die Ausgabe ist ein Array von Zeichenfolgen, die 0s und 1s enthalten.

Probieren Sie es online!

Erläuterung

Für jedes Zeichen c, k+1auswertet , um die Anzahl der Zeilen zu ändern. k = "wxy".search(c) + 1;, wobei die searchMethode den Index zurückgibt oder -1. kwird dann dekrementiert, bis es erreicht ist, -1indem ~k--nach einem wahrheitsgemäßen Wert gesucht wird.

Wenn das aktuelle Zeichen "y" ist, setzen Sie ein Flag, sodass der Basis-36-Wert des nächsten Zeichens - 1 zum Wert für wird k.

Wenn Sie auf ein "z" stoßen, drücken Sie die Pad-Zeichenfolge nach links, erhöhen Sie den Pad-Wert um 5und setzen Sie den Array-Index auf zurück 0.

s =>
    [...s, "z"].map(c => {                  // append a "z" to ensure final output is properly padded
        h = parseInt(c, 36);
        k = "wxy".search(c) + 1;            // note that "y" -> 4 zeroes
        y                                   // if previous char is "y"...
            ? k = h - y--                   //      decrement y after subtracting y=1 since k is decremented to -1 and the previous y already pushed 4 zeroes
        : h - 35                            // else if current char is not "z"...
            ? y = h > 33                    //      set y if current char = "y"
        : m = m.map(P, z += 5, i = k--);    // else if current char is "z", pad
        for (
            h = k ? 0 : h;                  // if k is truthy, push zeroes
            ~k--;
            m[i] = h.toString(2)            // convert to boolean representation
                + P(m[i++] || "")           // prepend to row or to a newly padded row
        );
    },
        P = d => d.padStart(z, 0),
        m = [i = z = y = 0]                 // the logical OR 4 lines above replaces this value with ""
    ) &&
    m
Redundanz
quelle
Ich denke, es wäre sinnvoller, die Transponierung der Eingabe nicht zurückzugeben.
mbomb007
1

Haskell, 399 Bytes

splitPaket installieren :cabal install split

import Data.Char
import Data.List.Split
import Data.List
p=map
r=replicate
a c|47<c&&c<58=c-48|96<c&&c<123=c-87
o=a.ord
m l n|l==0=[]|True=(mod n 2):m(l-1)(div n 2)
t a=p(\l->l++r((maximum$p length a)-length l)'0')a
y s|length s==0=""|h=='y'=(r(4+(o$s!!1))'0')++y(drop 2 s)|h=='w'="00"++y t|h=='x'="000"++y t|True=h:y t where h=head s;t=tail s
w=(p concat).transpose.(p$p$(m 5).o).t.(splitOn "z").y
Евгений Новиков
quelle