Descriptografar o formato Wechsler estendido

18

Esse desafio é baseado em uma postagem de sandbox por user48538 . Como ele não está mais ativo neste site, assumi esse desafio.


apgsearch , o programa distribuído de pesquisa de sopas do Game of Life de Conway e o banco de dados de resultados de pesquisa, Catagolue usa apgcodes para classificar e denotar padrões. Os próprios apgcodes usam o formato estendido de Wechsler , uma extensão de uma notação padrão desenvolvida por Allan Wechsler em 1992.

Os exemplos a seguir e as imagens foram tiradas da LifeWiki .

  1. Uma sequência de n caracteres no conjunto correspondente ao regex [0-9a-v]indica uma faixa de cinco linhas, n colunas de largura. Cada carácter indica a cinco células em uma coluna vertical correspondentes às bitstrings [ 00000, 10000, 01000... 00010, 10010, 01010, 11010... 11111].

    Por exemplo, 27deee6corresponde a uma nave espacial pesada :

27deee6

[01100001101111011111100111100000000]
  1. O caractere zsepara tiras contíguas de cinco linhas.

    Por exemplo, 0ca178b96z69d1d96corresponde a uma natureza morta de 31 bits:

insira a descrição da imagem aqui

insira a descrição da imagem aqui

[000110110001010101010010001011001110000000000011111000100000100101010100011011000000000000]
  1. Os caracteres we xsão usados ​​para abreviar 00e 000, respectivamente.

    Portanto, w33z8kqrqk8zzzx33corresponde a um transporte de abelhas trans-rainha :

insira a descrição da imagem aqui

insira a descrição da imagem aqui

(10 linhas em branco omitidas)

insira a descrição da imagem aqui

[0011000001100000000000000000000000000010000011100010001010111010111110000000000000000000000000000000000000000000000000000000000000000000000000011000001100000000000000000000000]
  1. Finalmente, os símbolos correspondentes ao regex y[0-9a-z]correspondem a execuções entre 4 e 39 0s consecutivos .

    Um bom exemplo é que 31a08zy0123ckocorresponde a um navio no quadrilátero :

insira a descrição da imagem aqui

insira a descrição da imagem aqui

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

Respostas:

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⊞υ⁴

Se for um y, empurre 4para a lista vazia predefinida, causando 4+n 0a saída de s na próxima vez.

x×0³

Se for uma xsaída 3 0s. (Isso é feito via repetição para evitar que o literal 0toque no xou no literal a seguir.)

w¦00

Se for uma wsaída 2 0s. ( ¦É necessário separar os dois literais de cadeia de caracteres.)

«P↓⮌⍘⌕βι²→

Caso contrário, indexe o caractere atual nos dígitos e letras, converta em binário e imprima primeiro o resultado para baixo menos significante; depois mova o cursor para a direita na próxima coluna.

Neil
fonte
6

JavaScript (ES8), 197 bytes

Recebe a entrada como uma sequência. Retorna uma matriz de strings com '#' e espaços. A saída pode incluir espaços à direita extras (mas consistentes) em cada linha.

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

Experimente online!(saída pretificada)

Quão?

Variáveis ​​globais

  • O personagem "x"é usado várias vezes, então vale a pena armazená-lo na variável x .
  • A função parseInté usada duas vezes, de modo que vale a pena armazenando-o para a variável P .
  • y é o índice da linha, inicializado em 0 .
  • w controla um limite superior da largura que é usada para preencher a saída final.
  • o [] é a matriz de saída, inicialmente vazia.

Pré-processamento de zeros repetidos

Primeiro, substituir todos os padrões "w", "x"e "yX"na cadeia de entrada com o número apropriado de espaços. Esses espaços serão posteriormente interpretados como "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
  )
)

Decodificação

Dividimos a sequência resultante, acrescentamos uma inicial "x"e iteramos 5 vezes (com i = 0 a 4 ) em cada caractere c :

  • Se c for menor que "x", anexamos o padrão correspondente às próximas 5 linhas.

    o[y + i - 5] += ' #'[P(c, 36) >> i & 1]
  • Se c for maior ou igual a "x", alocamos 5 novas cadeias vazias em o [] e adicionamos 5 a y . Isso é acionado pela inicial "x"que foi adicionada no início da string ou por alguma "z"no conteúdo original.

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

Preenchimento

Finalmente, colocamos cada string em o [] com espaços para que todos tenham w caracteres.

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

05AB1E , 148 132 98 bytes

Sou estudante do ensino médio e essa foi minha primeira vez no golfe e no 05AB1E; portanto, os comentários são apreciados!

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

Experimente online!

Experimente online!

Experimente online!

Pega a entrada como maiúscula e gera a matriz transposta como várias linhas de saída de 1s e 0s. Pode adicionar zeros extras.

Se você deseja testar com seqüências de caracteres minúsculas, adicione uo cabeçalho TIO.

Se você deseja uma saída bem impressa, adicione '1'█:'0'.:o rodapé do TIO.

Explicação

(Estou chamando "linhas" e "colunas" oposto ao que você pode esperar, porque gera a matriz transposta)

O algoritmo básico é:

  1. Substitua "aa" por 38 0s
  2. Divida em "y" e expanda as execuções 0.
  3. Substitua "w" e "x"
  4. Descobrir a coluna mais longa (ou seja, a sequência mais longa entre z's) e preencher todas as outras colunas para que tenham esse comprimento. (Isso é necessário devido à forma como o algoritmo abaixo funciona)
  5. Dividir em z
  6. Nesse ponto, a sequência de entrada é uma matriz de colunas em que cada coluna é uma sequência de [0-9A-V], em que cada coluna tem o mesmo comprimento.
  7. O algoritmo para colocá-lo no formato de saída é
    1. Converta os caracteres em números usando indexOf em uma sequência de pesquisa
    2. Converta os caracteres em binário e depois coloque no comprimento 5
    3. Se for a primeira coluna, adicione uma quebra de linha antes do número binário
    4. Adicione um prefixo ao início da seqüência de caracteres binária que armazena a linha e a coluna do caractere.
    5. Empurre a sequência binária com prefixo para o registro / variável "matriz global" de 05AB1E
  8. Classifique a matriz global. A sequência de prefixos, que determina a ordem de classificação, garantirá que tudo termine na ordem correta e que as quebras de linha estejam nos lugares certos.
  9. Remova a sequência de prefixos de cada elemento da matriz global
  10. Junte a matriz com "" e imprima-a.

Existem outros detalhes menores que você pode ver abaixo no código expandido. Tudo depois das guias no final de uma linha é um comentário e pode ser ignorado. (A propósito, esse esquema de comentários não faz parte do 05AB1E. Fiz dessa maneira porque ficou bonito.) As linhas que possuem comentários começando com "@" são para fins de depuração e podem ser omitidas sem alterar a saída final.

„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
fonte
1
Olá e bem-vindo ao PPCG; muito bom primeiro post! Em relação à sua contagem de bytes: você está certo. O TIO exibe com facilidade que os 148 caracteres são representados por 148 bytes usando a página de código 05AB1E.
Jonathan Frech
Uma pequena observação: a maioria dos idiomas de golfe implementa impressão implícita; Eu acho que você pode omitir o seu último ,.
Jonathan Frech
Eu olhei e fiz algumas melhorias. O comportamento será diferente (teoricamente) apenas para itens com mais de 1000 linhas ou colunas; nesse momento, o programa menor fará algo inesperado.
precisa saber é o seguinte
Não é o desafio mais fácil de começar! Bom trabalho, imagino que alguns dos fiéis do 05AB1E darão algumas dicas úteis quando aparecerem.
Jonathan Allan
1
Bem-vindo ao PPCG e ao mundo do 05AB1E. Eu não tenho muito tempo agora e só comecei a usar o 05AB1E há alguns meses, então também não sou muito profissional, mas aqui estão algumas pequenas coisas para o golfe: "yy"pode ser „yy(05AB1E tem uma string de 2 e 3 caracteres). >≠pode ser Ā(verdade, basicamente 0permanece 0e tudo o mais se torna 1). }}pode ser ](feche todos os loops e if-elses). Tenho certeza de que alguns jogadores profissionais do 05AB1E são capazes de jogar coisas mais substanciais do que eu, possivelmente até reduzindo pela metade a contagem de bytes.
Kevin Cruijssen
4

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

obrigado a H.PWiz por salvar 7 bytes e ngn por outros 13 17.

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

Experimente online!

NB: Aceita a entrada como uma sequência em maiúsculas.

Com saída bastante impressa

Explicação

a←⎕D,⎕Aa é a string que '0123...89ABCD...XYZ'
'Y.|W|X'⎕R{'0'/⍨+/30 36|a⍳2↑⍵.Match}substitui XW e Yx pelo número correspondente de '0's (explicado mais abaixo) 35(≠⊆⊢)a⍳converte a string em vetor de indecies ae divide-se em 35(ie) 'Z'criar um vetor aninhado
converte o vetor aninhado em um preenchimento de matriz termina com 0s
(5/2)⊤converte cada número em um vetor binário, resultando em uma matriz tridimensional com vetores binários ao longo do eixo primário,
inverte-o ao longo do eixo primário,
reduz a classificação da matriz, de modo que seja bidimensional
,⍉redimensiona o resultado para a saída apropriada

'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
fonte
Aqui está uma poupança de 7 byte: a←⎕D,⎕A⋄,↓↑{⊖(5/2)⊤a⍳⍵}¨'Z'(≠⊆⊢)('Y.|W|X'⎕R{'0'/⍨{0::2+'WX'⍳⍵⋄4+a⍳1⊃⍵}⍵.Match})⍞. A captura de erro também não parece muito golfy
H.PWiz
Obrigado @ H.PWiz. Sim, eu também não gosto da captura de erro, mas, caso contrário, estava usando duas substituições de regex.
Jslip
@jslip os parênteses ao redor ⎕Re seus operandos são desnecessários
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

14 bytes salvos graças a Jo King. (Também corrigimos um pequeno erro ao analisar o ye adicionamos um prettificador.)

Corrigida a análise de buggy de 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}

Experimente online!

A quebra de linha existe apenas para ajustar o texto na tela. Não faz parte do programa.

Como funciona

É uma função anônima que aceita uma sequência mutável. (Isso torna o uso da função um pouco peculiar, porque você pode fornecer apenas variáveis, não literais.) Após algum trabalho, ele retorna uma lista de listas contendo 0 e 1, com o mesmo significado que na postagem original.

A cadeia de entrada vem em na variável $_. Começamos usando uma série de instruções de substituição, a fim de nos livrarmos de todas essas atalhos para vários números de zeros. Primeiro, precisamos resolver o yporque, no caso de yxou yw, o w(ou x) não constitui uma abreviação por si só. Procuramos y(.)( ye um caractere que ele lembra) e o substituímos por 000{"0"x:36(~$0)}: os três zeros são copiados literalmente, depois convertemos o próximo caractere da base 36 para a base 10 ( :36(~$0)) e adicionamos muito mais zeros. Em seguida, substituímos o wuso s:g/w/00/e o xuso s:g/x/000/. Finalmente, coms/$/z/ adicionamos umzno final, adicionando muitas linhas vazias ao fundo. (Veremos o motivo mais tarde.)

O resto é apenas uma grande declaração do mapa. Estamos mapeando sobre .split("z").map: (*~0 x.chars).comb}), que é a string de entrada (sem zero atalhos), dividida em linhas em z, com cada linha sendo preenchida primeiro com 0 x.chars(toneladas de zeros, ou seja, o comprimento total da string de entrada) à direita e depois dividido em uma lista de caracteres individuais ( .comb). Finalmente, nós a transpomos com [Z](reduza com zip). O zíper termina assim que a lista mais curta é esgotada, o que resulta em todas as linhas com o mesmo comprimento. (O número de zeros à direita inúteis à direita é igual ao comprimento da linha mais curta. Além disso, esse truque de transposição falha em uma "matriz" com apenas uma linha. É por isso que adicionamos à força outra linha no final antes.)

Agora, apenas mapeamos as linhas (colunas da matriz original) e substituímos cada caractere encontrado pelos 5 bits correspondentes. Isso é feito usando :32($_)(base 32 a base 10) .fmt("%05b")(formato como uma cadeia de bits da largura 5, preenchida com zeros) .flip(inverta a cadeia, porque o LSB está na linha superior, não na parte inferior) .comb(divida a cadeia em uma lista de personagens). Nós usamos .flatmap, que nivela a lista resultante (caso contrário, obteríamos uma lista de listas em cada coluna). A transposição do resultado é retornada implicitamente.

(Sinto-me um pouco mal por abusar da possibilidade de rastrear zeros com tanto esforço. Mas reduziu consideravelmente o número de bytes: --).)

Ramillies
fonte
142 bytes
Jo King
@JoKing - Oh sim, muito obrigado!
Ramillies
Falha para 1yx1e1yw1
Jonathan Allan
@ JonathanAllan, você está certo, obrigado. Vou consertar isso em um momento. (Primeiro pensei por algum motivo que só poderia haver y[0-9a-v]e quando eu descobri que não é o caso, eu apenas acrescentou uma (e errado) solução rápida.)
Ramillies
Você pode substituir 000na substituição y porx
Jo King
2

Geléia , 66 bytes

Yowza!

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

Um link monádico que produz uma versão transposta como uma lista de listas (adicione Zao final para transpor de volta).

Experimente online! Ou veja a suíte de testes (com saída bastante impressa).

Jonathan Allan
fonte
2

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

Experimente online! O link inclui casos de teste. Solução alternativa, também 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`.+

Experimente online! O link inclui casos de teste. Explicação:

y(.)
#$1

Primeiro, lide com o caso estranho do ycomando. Infelizmente, a carta depois disso pode ser uma you até uma z, por isso temos que ter cuidado aqui. Todas as mágicas ysão primeiro transformadas em #s.

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

Um loop processa os #s. Primeiro, a 0é anexado ao #. Se este for um, #0então é alterado para o 000qual conclui a operação, caso contrário, o caractere após o #é decrementado e o loop se repete até que todos os #s tenham sido processados.

w
000
x
00

Corrija os wes e xs.

z
¶

Dividir em novas linhas. ( S`ztambém funciona para a mesma contagem de bytes.)

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

Faça 5 cópias de cada linha e execute a conversão binária mapeando as letras com o bit apropriado #e limpando esse bit, enquanto outras letras se tornam espaços. Os bits são processados ​​na ordem 16, 8, 4, 2 e, em seguida, a última tradução trata de limpar o 2bit e convertê 1-lo ao mesmo tempo. (A versão alternativa faz cada cópia individualmente, o que custa mais bytes, mas estes são salvos porque o tratamento de bits é simplificado.)

P`.+

Coloque todas as linhas no mesmo comprimento.

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

Experimente online!

5 bytes salvos por Jonathan Frech .

Chas Brown
fonte
Existe um espaço supérfluo em while 'y'in. Eu acho que o subscrito [-5:][::-1]pode ser jogado [:-6:-1]. A declaração de retorno pode ser colocada na linha anterior.
Jonathan Frech
1

JavaScript (ES8), 192 bytes

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

Retorna a transposição ... que é refletida no eixo vertical; deixe-me saber se isso invalida esta entrada. Saída é uma matriz de cadeias contendo 0s e 1s.

Experimente online!

Explicação

Para cada caractere c, k+1avalia o número de linhas a serem modificadas. k = "wxy".search(c) + 1;, onde o searchmétodo retorna o índice ou -1. ké então decrementado até atingir -1, verificando ~k--um valor verdadeiro.

Se o caractere atual for "y", defina um sinalizador para que o valor base-36 do próximo caractere - 1 se torne o valor para k.

Ao encontrar um "z", as seqüências de caracteres do teclado à esquerda, aumentam a quantidade do teclado 5e redefina o índice da matriz para 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
redundância
fonte
Eu acho que faria mais sentido não retornar a transposição da entrada.
Mbomb007
1

Haskell, 399 bytes

Instale o splitpacote: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
Евгений Новиков
fonte