Odszyfruj rozszerzony format Wechslera

18

To wyzwanie jest oparte na poście w piaskownicy przez user48538 . Ponieważ nie jest już aktywny na tej stronie, podjąłem to wyzwanie.


apgsearch , rozproszony program wyszukiwania zup dla Gry Życia Conwaya oraz baza danych wyników wyszukiwania, Catagolue używa apgcodes do klasyfikowania i oznaczania wzorców. same apgcodes używają rozszerzonego formatu Wechsler , rozszerzenia notacji wzorców opracowanej przez Allana Wechslera w 1992 roku.

Poniższe przykłady i zdjęcia pochodzą z LifeWiki .

  1. Ciąg n znaków w zestawie pasujących do wyrażenia regularnego [0-9a-v]oznacza pasek pięciu rzędów o szerokości n kolumn. Każdy znak oznacza pięć komórek w kolumnie pionowej odpowiadających bitstrings [ 00000, 10000, 01000... 00010, 10010, 01010, 11010... 11111].

    Na przykład 27deee6odpowiada ciężkiemu statkowi kosmicznemu :

27deee6

[01100001101111011111100111100000000]
  1. Znak zoddziela ciągłe pięciorzędowe paski.

    Na przykład 0ca178b96z69d1d96odpowiada 31-bitowej martwej natury:

wprowadź opis zdjęcia tutaj

wprowadź opis zdjęcia tutaj

[000110110001010101010010001011001110000000000011111000100000100101010100011011000000000000]
  1. Znaki wi xsą używane odpowiednio do skrótu 00i 000.

    w33z8kqrqk8zzzx33Odpowiada więc transferowi królowej pszczół trans :

wprowadź opis zdjęcia tutaj

wprowadź opis zdjęcia tutaj

(Pominięto 10 pustych wierszy)

wprowadź opis zdjęcia tutaj

[0011000001100000000000000000000000000010000011100010001010111010111110000000000000000000000000000000000000000000000000000000000000000000000000011000001100000000000000000000000]
  1. Finally, the symbols matching the regex y[0-9a-z] correspond to runs of between 4 and 39 consecutive 0s.

    A good example is 31a08zy0123cko, corresponding to a ship on quadpole:

wprowadź opis zdjęcia tutaj

wprowadź opis zdjęcia tutaj

[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
źródło
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

Odpowiedzi:

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
źródło
6

JavaScript (ES8), 197 bytes

Takes input as a string. Returns an array of strings with '#' and spaces. The output may include extra (but consistent) trailing spaces on each line.

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

Try it online! (prettified output)

How?

Global variables

  • The character "x" is used several times, so it's worth storing it into the variable x.
  • The function parseInt is used twice, so it's worth storing it into the variable P.
  • y is the row index, initialized to 0.
  • w keeps track of an upper bound of the width which is used to pad the final output.
  • o[ ] is the output array, initially empty.

Pre-processing of repeated zeros

We first replace all patterns "w", "x" and "yX" in the input string with the appropriate number of spaces. These spaces will later be interpreted as "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
  )
)

Decoding

We split the resulting string, prepend an initial "x" and iterate 5 times (with i = 0 to 4) on each character c:

  • If c is lower than "x", we append the corresponding pattern to the next 5 rows.

    o[y + i - 5] += ' #'[P(c, 36) >> i & 1]
  • If c is greater than or equal to "x", we allocate 5 new empty strings in o[ ] and add 5 to y. This is triggered by the initial "x" that was added at the beginning of the string, or by any "z" in the original content.

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

Padding

Finally, we pad each string in o[ ] with spaces so that they all have w characters.

o.map(r => r.padEnd(w))
Arnauld
źródło
6

05AB1E, 148 132 98 bytes

I'm a highschool student and this was my first time for both golfing and using 05AB1E, so comments are appreciated!

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

Try it online!

Try it online!

Try it online!

Takes input as uppercase and outputs the transposed matrix as multiple output lines of 1s and 0s. May add extra zeros.

If you want to test with lowercase strings, add u in the TIO header.

If you want pretty-printed output, add '1'█:'0'.: in the TIO footer.

Explanation

(I'm calling "rows" and "columns" opposite of what you might expect because it generates the transposed matrix)

The basic algorithm is:

  1. Replace "yy" with 38 0s
  2. Split on "y" and and expand the 0-runs.
  3. Replace "w" and "x"
  4. Figure out the longest column (that is, the longest string between z's) and pad all the other columns so they are that length. (This is necessary because of how the algorithm below works)
  5. Split on z
  6. At this point, the input string is an array of columns where each column is a string of [0-9A-V], where each column is the same length.
  7. The algorithm to get it into the output format is to
    1. Convert the characters to numbers by using indexOf in a lookup string
    2. Convert the characters to binary and then pad to length 5
    3. If it is the first column, add a linebreak before the binary number
    4. Add a prefix to the beginning of the binary string that stores the row and then the column of the character.
    5. Push the binary string with prefix to 05AB1E's "global array" register/variable
  8. Posortuj tablicę globalną. Ciąg prefiksu, który określa kolejność sortowania, upewni się, że wszystko skończy się we właściwej kolejności, a podziały wierszy będą we właściwych miejscach.
  9. Usuń ciąg prefiksu z każdego elementu globalnej tablicy
  10. Połącz tablicę za pomocą „” i wydrukuj ją.

Istnieje kilka innych drobnych szczegółów, które można zobaczyć poniżej w rozszerzonym kodzie. Wszystko po kartach na końcu wiersza jest komentarzem i można je zignorować. (Nawiasem mówiąc, ten schemat komentarzy nie jest częścią 05AB1E. Zrobiłem to w ten sposób, ponieważ wyglądał ładnie.) Linie zawierające komentarze zaczynające się od „@” służą do debugowania i można je pominąć bez zmiany ostatecznego wyniku.

„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
źródło
1
Witam i witam w PPCG; bardzo fajny pierwszy post! Jeśli chodzi o liczbę bajtów: masz rację. TIO nawet wyświetla, że ​​148 znaków jest reprezentowanych przez 148 bajtów przy użyciu strony kodowej 05AB1E.
Jonathan Frech,
Jedna mała uwaga: większość języków golfowych implementuje druk niejawny; Myślę, że możesz odłożyć swój ostatni ,.
Jonathan Frech,
Obejrzałem go i wprowadziłem kilka ulepszeń. Zachowanie będzie inne (teoretycznie) tylko dla rzeczy z więcej niż 1000 wierszy lub kolumn, w którym to momencie mniejszy program zrobi coś nieoczekiwanego.
kerwizzy
Nie jest to najłatwiejsze wyzwanie na początek! Dobra robota, wyobrażam sobie, że niektórzy niezłomni 05AB1E dadzą przydatne wskazówki, kiedy się pojawią.
Jonathan Allan,
1
Witamy w PPCG i świecie 05AB1E. Nie mam teraz zbyt wiele czasu i zacząłem używać 05AB1E dopiero kilka miesięcy temu, więc nie jestem jeszcze zbyt profesjonalistą, ale tutaj kilka drobnych rzeczy do golfa: "yy"może być „yy(05AB1E ma wbudowany ciąg znaków 2-znakowy i 3-znakowy). >≠może być Ā(prawdomówny, zasadniczo 0pozostaje 0i wszystko inne staje się 1). }}może być ](zamknij wszystkie pętle i if-elsy). Jestem pewien, że niektórzy z profesjonalnych golfistów 05AB1E są w stanie grać w golfa bardziej ode mnie, prawdopodobnie nawet o połowę.
Kevin Cruijssen
4

APL (Dyalog Unicode) , 87 80 77 67 63 bajtów

dzięki H.PWiz za zapisanie 7 bajtów i ngn na kolejne 13 17.

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

Wypróbuj online!

NB: Pobiera dane wejściowe jako ciąg wielkich liter.

Z ładnym wydrukiem

Wyjaśnienie

a←⎕D,⎕Aoznacza łańcuch '0123...89ABCD...XYZ'
'Y.|W|X'⎕R{'0'/⍨+/30 36|a⍳2↑⍵.Match}zastępuje XW i yx odpowiednią liczbę '0's (wyjaśnione poniżej) 35(≠⊆⊢)a⍳przekształca ciąg do wektora indecies w ai rozdziela się na 35(IE) 'Z'tworząc zagnieżdżonej VECTOR
konwertuje zagnieżdżonej wektora do celów wypełniających macierz 0s
(5/2)⊤przekształca każdą liczba w wektor binarny, co daje trójwymiarową macierz z wektorami binarnymi wzdłuż osi pierwotnej,
odwraca się wzdłuż osi pierwotnej,
zmniejsza rangę macierzy, więc jest dwuwymiarowa
,⍉przekształca wynik na odpowiedni wynik

'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
źródło
Oto oszczędność 7 bajt: a←⎕D,⎕A⋄,↓↑{⊖(5/2)⊤a⍳⍵}¨'Z'(≠⊆⊢)('Y.|W|X'⎕R{'0'/⍨{0::2+'WX'⍳⍵⋄4+a⍳1⊃⍵}⍵.Match})⍞. Błąd łapania również nie wydaje się bardzo golfowy
H.PWiz
Dzięki @ H.PWiz. Tak, nie lubię też łapania błędów, ale w przeciwnym razie użyłem dwóch zamienników wyrażeń regularnych.
jslip,
@jslip nawiasy wokół ⎕Ri operandy są niepotrzebne
ngn
2+'WX'⍳⍵->2+'X'=⍵
ngn
{0::2+'X'=⍵⋄4+a⍳1⊃⍵}⍵.Match->30 36|a⍳2↑⍵.Match
ngn
3

Perl 6 ,156 142 bajty

14 bajtów zaoszczędzonych dzięki Jo Kingowi. (Naprawiono także mały błąd podczas analizowania yi dodano prettifier).

Naprawiono błędne parsowanie 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}

Wypróbuj online!

Podział linii służy tylko dopasowaniu tekstu do ekranu. To nie jest część programu.

Jak to działa

Jest to anonimowa funkcja, która pobiera zmienny ciąg. (To sprawia, że ​​korzystanie z funkcji jest nieco dziwne, ponieważ możesz nadać jej tylko zmienne, a nie literały.) Po pewnym czasie zwraca listę list zawierającą 0 i 1, o takim samym znaczeniu jak w oryginalnym poście.

Łańcuch wejściowy wchodzi do zmiennej $_. Zaczynamy od użycia szeregu instrukcji podstawienia, aby pozbyć się wszystkich tych skrótów dla różnych liczb zer. Po pierwsze, musimy uporządkować y, ponieważ w wypadku yxlub ywThe w(lub x) nie stanowi skrót od siebie. Szukamy y(.)( yi jednego znaku, który pamięta) i zastępujemy go 000{"0"x:36(~$0)}: trzy zera są kopiowane dosłownie, a następnie przekształcamy następny znak z podstawy 36 na podstawę 10 ( :36(~$0)) i dodajemy tyle innych zer. Następnie możemy wymienić w„s użyciu s:g/w/00/, a x” s użyciu s:g/x/000/. Na koniec s/$/z/dodajemyzna końcu, dodając mnóstwo pustych linii na dole. (Zobaczymy przyczynę później.)

Reszta to tylko duża mapa. Odwzorowujemy .split("z").map: (*~0 x.chars).comb}), który jest łańcuchem wejściowym (bez zerowych skrótów), podzielony na linie w z, przy czym każda linia jest najpierw uzupełniana 0 x.chars(tonami zer, czyli tyle, ile całkowita długość łańcucha wejściowego) po prawej stronie a następnie w podziale na listę pojedynczych znaków ( .comb). Na koniec transponujemy go za pomocą [Z](zmniejsz za pomocą zip). Zipowanie kończy się, gdy tylko najkrótsza lista zostanie wyczerpana, co powoduje, że wszystkie linie mają tę samą długość. (Liczba bezużytecznych zer po prawej stronie jest równa długości najkrótszej linii. Ta sztuczka transpozycji kończy się niepowodzeniem dla „macierzy” z tylko jednym wierszem. Dlatego wcześniej na końcu dodaliśmy siłą inny wiersz).

Teraz po prostu odwzorowujemy wiersze (kolumny oryginalnej macierzy) i zastępujemy każdy napotkany znak odpowiednimi 5 bitami. Odbywa się to za pomocą :32($_)(baza 32 do bazy 10) .fmt("%05b")(format jako ciąg bitów o szerokości 5, wypełniony zerami) .flip(odwróć ciąg, ponieważ LSB znajduje się w górnym wierszu, a nie w dole) .comb(podziel ciąg na listę postacie). Użyliśmy .flatmap, który spłaszcza wynikową listę (w przeciwnym razie otrzymalibyśmy listę list w każdej kolumnie). Transpozycja wyniku jest następnie domyślnie zwracana.

(Czuję się trochę źle z powodu nadużywania możliwości tak ciągłego zerowania. Ale to znacznie zmniejszyło liczbę bajtów :—).)

Ramillies
źródło
142 bajty
Jo King
@JoKing - O tak, bardzo dziękuję!
Ramillies,
Nie działa za 1yx1i1yw1
Jonathan Allan,
@JonathanAllan, masz rację, dziękuję. Zaraz to naprawię. (Najpierw pomyślałem z jakiegoś powodu, że może istnieć tylko y[0-9a-v]i kiedy stwierdziłem, że tak nie jest, po prostu dodałem szybką (i niewłaściwą) poprawkę.)
Ramillies
Możesz zamienić podstawienie 000w y nax
Jo King
2

Galaretka , 66 bajtów

Yowza!

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

Link monadyczny, który daje transponowaną wersję jako listę list (dodaj Zna końcu, aby transponować z powrotem).

Wypróbuj online! Lub zobacz pakiet testowy (z ładnymi wydrukami).

Jonathan Allan
źródło
2

Siatkówka , 203 bajty

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`.+

Wypróbuj online! Link zawiera przypadki testowe. Alternatywne rozwiązanie, również 203 bajty:

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`.+

Wypróbuj online! Link zawiera przypadki testowe. Wyjaśnienie:

y(.)
#$1

Najpierw zajmij się niewygodnym przypadkiem ypolecenia. Niestety, list po tym może być a, ya nawet z, więc musimy tu być ostrożni. Wszystkie magie ysą najpierw zamieniane w #s.

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

Pętla przetwarza następnie #s. Po pierwsze, a 0jest dodawane do #. Jeśli jest to #0wtedy, to jest zmieniane na, 000które kończy operację, w przeciwnym razie znak po #jest zmniejszany, a pętla powtarza się, aż wszystkie #s zostaną przetworzone.

w
000
x
00

Napraw ws i xs.

z
¶

Podziel na nowe linie. ( S`zdziała również dla tej samej liczby bajtów).

%(`.+
$&¶$&¶$&¶$&¶$&
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` # #

Wykonaj 5 kopii każdego wiersza, a następnie wykonaj konwersję binarną, mapując litery odpowiednim bitem #i usuwając ten bit, podczas gdy inne litery stają się spacjami. Bity są przetwarzane w kolejności 16, 8, 4, 2, a następnie ostatnie tłumaczenie obsługuje czyszczenie 2bitu i konwersję 1bitu w tym samym czasie. (Alternatywna wersja sprawia, że ​​każda kopia jest osobno, co kosztuje więcej bajtów, ale są one zapisywane, ponieważ obsługa bitów jest uproszczona).

P`.+

Wypełnij wszystkie linie na tej samej długości.

Neil
źródło
1

Python 2 , 249 244 bajtów

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

Wypróbuj online!

5 bajtów zapisanych przez Jonathana Frecha .

Chas Brown
źródło
Jest w tym zbyteczna przestrzeń while 'y'in. Myślę, że do indeksu dolnego [-5:][::-1]można grać w golfa [:-6:-1]. Instrukcja return może być umieszczona w poprzednim wierszu.
Jonathan Frech,
1

JavaScript (ES8), 192 bajty

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

Zwraca transpozycję ..., która jest następnie odbijana w poprzek osi pionowej; daj mi znać, jeśli to unieważnia ten wpis. Dane wyjściowe to tablica ciągów zawierających 0s i 1s.

Wypróbuj online!

Wyjaśnienie

Dla każdego znaku c, k+1Zwraca liczbę wierszy zmodyfikować. k = "wxy".search(c) + 1;, gdzie searchmetoda zwraca indeks lub -1. kjest następnie zmniejszana, dopóki nie osiągnie -1, sprawdzając ~k--prawdziwą wartość.

Jeśli bieżącym znakiem jest „y”, ustaw flagę tak, aby podstawowa wartość 36 następnego znaku - 1 stała się wartością k.

Po napotkaniu „z”, ciągów padów po lewej stronie, zwiększaj wielkość padów o 5i resetuj indeks tablicy do 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
nadmiar
źródło
Myślę, że sensowniej byłoby nie zwracać transpozycji danych wejściowych.
mbomb007,
1

Haskell, 399 bajtów

Zainstaluj splitpakiet: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
Евгений Новиков
źródło