Descifrar el formato extendido de Wechsler

18

Este desafío se basa en una publicación de sandbox por user48538 . Como ya no está activo en este sitio, asumí este desafío.


apgsearch , el programa distribuido de búsqueda de sopas para Conway's Game of Life y la base de datos de resultados de búsqueda, Catagolue usa apgcodes para clasificar y denotar patrones. Los apgcodes usan el formato Wechsler extendido , una extensión de una notación de patrón desarrollada por Allan Wechsler en 1992.

Los siguientes ejemplos y las imágenes están tomadas de LifeWiki .

  1. Una cadena de n caracteres en el conjunto que coincide con la expresión regular [0-9a-v]denota una tira de cinco filas, n columnas de ancho. Cada personaje denota cinco celdas de una columna vertical que corresponde a las cadenas de bits [ 00000, 10000, 01000... 00010, 10010, 01010, 11010... 11111].

    Por ejemplo, 27deee6corresponde a una nave espacial de peso pesado :

27deee6

[0 0110 00 00 00 0110 011110 01111110 00 011110 00 00 00 00 00 00 00 0]
  1. El carácter zsepara las tiras contiguas de cinco filas.

    Por ejemplo, 0ca178b96z69d1d96corresponde a una naturaleza muerta de 31 bits:

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

[0 00 00 0110 0110 00 00 010 010 010 010 010 00 010 00 00 010 0110 00 01110 00 00 00 00 00 00 00 00 00 00 0111110 00 00 010 00 00 00 00 010 00 010 010 010 010 00 00 0110 0110 00 00 00 00 00 00 00 00 00 00 00 0]
  1. Los caracteres wy xse utilizan para abreviar 00y 000, respectivamente.

    Entonces w33z8kqrqk8zzzx33corresponde a un transbordador trans-queen bee :

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

(10 filas en blanco omitidas)

ingrese la descripción de la imagen aquí

[0 00 0110 00 00 00 00 0110 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 010 00 00 00 00 01110 00 00 010 00 00 010 010 01110 010 0111110 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0110 00 00 00 00 0110 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0]
  1. Finalmente, los símbolos que coinciden con la expresión regular y[0-9a-z]corresponden a carreras de entre 4 y 39 0s consecutivos .

    Un buen ejemplo es 31a08zy0123cko, correspondiente a un barco en quadpole :

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

[110 00 00 00 00 00 00 00 010 010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 010 010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 010 010 00 00 00 00 00 00 00 0110 00 00 00 00 00 00 00 00 00 0110 00 00 00 00 00 00 00 010 010 00 00 00 00 00 00 00 011]

El reto

Escriba un programa o una función para analizar una cadena del formato Wechsler extendido, definido anteriormente, e imprima (o devuelva) el patrón correspondiente a esta cadena.

Puede suponer que la cadena no está vacía y no comienza ni termina con z.

Puede usar cualquier formato de salida razonable, por ejemplo, una cadena, una matriz, una matriz 2d. Puede usar cualquiera de los dos valores para representar 0y 1, dado que los declara en la respuesta.

Puede omitir las líneas de ceros finales en la salida o agregar líneas de ceros finales adicionales. También puede agregar / omitir ceros finales en cada línea, siempre que todas las líneas tengan la misma longitud en la salida.

Puede devolver la transposición de la matriz, si eso es más conveniente.

Este es el , por lo que gana el código más corto.

Casos de prueba

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
fuente
¿ zAlguna vez ocurrirá desde el principio?
Sr. Xcoder
@ Mr.Xcoder La página de LifeWiki no dice nada al respecto. Pero puede suponer aquí que la cadena no comienza o termina con z.
alephalpha
3
No es realmente un patrón de Juego de la Vida, pero solo por diversión:vv99f60vv99f60uv11320uv19rqz33y133y11322310132231
Arnauld
1
"Puede devolver la transposición de la matriz". Si está bien, ¿qué pasa con otras simetrías como al revés, etc.?
Jonathan Allan
1
Dos de las tres primeras respuestas fallan por alguna de estas: 1yx1, 1yy1, 1yw1y 1yz1. Quizás deberían ser pruebas.
Jonathan Allan

Respuestas:

2

Carbón de leña , 50 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Usos 1y 0. Explicación:

UB0

Establezca el fondo, es decir, las celdas sin imprimir del rectángulo que encierra la salida, en 0.

≔⁺⭆χιββ

Prefije los dígitos al alfabeto en minúscula predefinido.

FS

Pase sobre la cadena de entrada.

¿υ

Si la lista vacía predefinida no está vacía ...

×0⁺⊟υ⌕βι

... luego imprima un número de 0s dado por la suma del número extraído de la lista y el índice del carácter actual en los dígitos y letras. Vea a continuación cuál es ese número siempre.

≡ι

Cambia el personaje actual.

z×⸿⁵

Si se trata de una zsalida de 5 retornos de carro, nos lleva a la siguiente tira de salida.

y⊞υ⁴

Si es a y, entonces empuje 4a la lista vacía predefinida, haciendo 4+n 0que se muestre s la próxima vez.

x×0³

Si es una xsalida de 3 0s. (Esto se hace por repetición para evitar que el literal 0toque el xo el siguiente literal).

w¦00

Si se trata de una wsalida de 2 0s. (Se ¦necesita para separar los dos literales de cadena).

«P↓⮌⍘⌕βι²→

De lo contrario, indexe el carácter actual en los dígitos y letras, conviértalo a binario e imprima el resultado hacia abajo con el bit menos significativo primero; luego mueva el cursor hacia la derecha para la siguiente columna.

Neil
fuente
6

JavaScript (ES8), 197 bytes

Toma la entrada como una cadena. Devuelve una matriz de cadenas con '#' y espacios. La salida puede incluir espacios finales adicionales (pero consistentes) en cada línea.

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

Pruébalo en línea! (salida prettified)

¿Cómo?

Variables globales

  • El personaje "x"se usa varias veces, por lo que vale la pena almacenarlo en la variable x .
  • La función parseIntse utiliza dos veces, por lo que vale la pena almacenarlo en la variable P .
  • y es el índice de fila, inicializado a 0 .
  • w realiza un seguimiento de un límite superior del ancho que se utiliza para rellenar la salida final.
  • o [] es la matriz de salida, inicialmente vacía.

Preprocesamiento de ceros repetidos

Primero reemplazamos todos los patrones "w", "x"y "yX"en la cadena de entrada con el número apropiado de espacios. Estos espacios serán luego 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
  )
)

Descodificación

Dividimos la cadena resultante, anteponemos una inicial "x"e iteramos 5 veces (con i = 0 a 4 ) en cada carácter c :

  • Si c es menor que "x", agregamos el patrón correspondiente a las siguientes 5 filas.

    o[y + i - 5] += ' #'[P(c, 36) >> i & 1]
  • Si c es mayor o igual que "x", asignamos 5 nuevas cadenas vacías en o [] y sumamos 5 a y . Esto se desencadena por la inicial "x"que se agregó al comienzo de la cadena, o por cualquiera "z"en el contenido original.

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

Relleno

Finalmente, rellenamos cada cadena en o [] con espacios para que todos tengan w caracteres.

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

05AB1E , 148 132 98 bytes

Soy un estudiante de secundaria y esta fue mi primera vez para jugar al golf y usar 05AB1E, por lo que agradecemos los comentarios.

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

Pruébalo en línea!

Pruébalo en línea!

Pruébalo en línea!

Toma la entrada en mayúscula y saca la matriz transpuesta como múltiples líneas de salida de 1s y 0s. Puede agregar ceros adicionales.

Si desea probar con cadenas en minúsculas, agregue uel encabezado TIO.

Si desea una salida impresa bonita, agregue '1'█:'0'.:el pie de página TIO.

Explicación

(Estoy llamando "filas" y "columnas" opuestas a lo que podría esperar porque genera la matriz transpuesta)

El algoritmo básico es:

  1. Reemplace "yy" con 38 0s
  2. Dividir en "y" y expandir las 0 ejecuciones.
  3. Reemplace "w" y "x"
  4. Calcule la columna más larga (es decir, la cadena más larga entre las z) y rellene todas las otras columnas para que tengan esa longitud. (Esto es necesario debido a cómo funciona el siguiente algoritmo)
  5. Split on z
  6. En este punto, la cadena de entrada es una matriz de columnas donde cada columna es una cadena de [0-9A-V], donde cada columna tiene la misma longitud.
  7. El algoritmo para llevarlo al formato de salida es
    1. Convierta los caracteres en números utilizando indexOf en una cadena de búsqueda
    2. Convierta los caracteres a binario y luego el pad a la longitud 5
    3. Si es la primera columna, agregue un salto de línea antes del número binario
    4. Agregue un prefijo al comienzo de la cadena binaria que almacena la fila y luego la columna del carácter.
    5. Empuje la cadena binaria con prefijo al registro / variable "matriz global" de 05AB1E
  8. Ordenar la matriz global. La cadena de prefijo, que determina el orden de clasificación, se asegurará de que todo termine en el orden correcto y los saltos de línea estén en los lugares correctos.
  9. Elimine la cadena de prefijo de cada elemento de la matriz global
  10. Unir la matriz con "" e imprimirlo.

Hay algunos otros detalles menores que puede ver a continuación en el código expandido. Todo después de las pestañas al final de una línea es un comentario y puede ignorarse. (Este esquema de comentarios no es parte de 05AB1E, por cierto. Lo hice de esta manera porque se veía bien). Las líneas que tienen comentarios que comienzan con "@" son para propósitos de depuración y pueden omitirse sin cambiar el resultado 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
fuente
1
Hola y bienvenidos a PPCG; muy bonito primer post! Con respecto a su recuento de bytes: tiene razón. TIO incluso muestra cómodamente los 148 caracteres están representados por 148 bytes usando la página de códigos 05AB1E.
Jonathan Frech
Una pequeña nota: la mayoría de los lenguajes de golf implementan la impresión implícita; Creo que puedes omitir tu último ,.
Jonathan Frech
Lo miré e hice algunas mejoras. El comportamiento solo será diferente (teóricamente) para cosas con más de 1000 filas o columnas, en cuyo punto el programa más pequeño hará algo inesperado.
kerwizzy
¡No es el desafío más fácil para comenzar! Buen trabajo, me imagino que algunos de los incondicionales 05AB1E darán algunos consejos útiles cuando lleguen.
Jonathan Allan
1
Bienvenido a PPCG y al mundo de 05AB1E. No tengo tanto tiempo en este momento, y solo comencé a usar 05AB1E hace unos meses, así que tampoco soy tan profesional, pero aquí hay algunas cosas pequeñas para el golf: "yy"puede ser „yy(05AB1E tiene una cadena incorporada de 2 y 3 caracteres). >≠puede ser Ā(verdad, básicamente 0permanece 0y todo lo demás se convierte 1). }}puede ser ](cerrar todos los bucles y if-elses). Estoy seguro de que algunos de los golfistas profesionales 05AB1E pueden jugar al golf cosas más importantes que yo, posiblemente incluso reduciendo a la mitad el número de bytes.
Kevin Cruijssen
4

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

gracias a H.PWiz por guardar 7 bytes y ngn por otros 13 17.

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

Pruébalo en línea!

NB: toma la entrada como una cadena en mayúscula.

Con una bonita salida impresa

Explicación

a←⎕D,⎕Aa es la cadena '0123...89ABCD...XYZ'
'Y.|W|X'⎕R{'0'/⍨+/30 36|a⍳2↑⍵.Match}reemplaza XW e Yx con el número correspondiente de '0's (se explica más adelante) 35(≠⊆⊢)a⍳convierte la cadena en un vector de indencias ay se divide en 35(es decir) al 'Z'crear un vector anidado
convierte el vector anidado en un relleno de matriz termina con 0s
(5/2)⊤convierte cada uno número en un vector binario que da como resultado una matriz tridimensional con vectores binarios a lo largo del eje primario que se
invierte a lo largo del eje primario
reduce el rango de la matriz, por lo que es bidimensional
,⍉reestructura el resultado a la salida adecuada

'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
fuente
Aquí es un ahorro de 7 bytes: a←⎕D,⎕A⋄,↓↑{⊖(5/2)⊤a⍳⍵}¨'Z'(≠⊆⊢)('Y.|W|X'⎕R{'0'/⍨{0::2+'WX'⍳⍵⋄4+a⍳1⊃⍵}⍵.Match})⍞. El error de captura tampoco parece muy complejo
H.PWiz
Gracias @ H.PWiz. Sí, tampoco me gusta la captura de error, pero de lo contrario estaba usando dos reemplazos de expresiones regulares.
jslip
@jslip los paréntesis ⎕Ry sus operandos son innecesarios
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 guardados gracias a Jo King. (También se corrigió un pequeño error al analizar yy agregó un prettifier).

Se corrigió el análisis de errores 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}

Pruébalo en línea!

El salto de línea está ahí solo para que el texto quepa en la pantalla. No es parte del programa.

Como funciona

Es una función anónima que toma una cadena mutable. (Esto hace que el uso de la función sea un poco peculiar, porque solo puede darle variables, no literales). Después de un poco de trabajo, devuelve una lista de listas que contienen 0 y 1, con el mismo significado que en la publicación original.

La cadena de entrada viene en la variable $_. Comenzamos usando una serie de declaraciones de sustitución para deshacernos de todos esos shorthands para varios números de ceros. Primero, necesitamos resolver el y, porque en el caso de yxo yw, el w(o x) no constituye una abreviatura en sí mismo. Buscamos y(.)( yy un carácter, que recuerda) y lo reemplazamos por 000{"0"x:36(~$0)}: los tres ceros se copian textualmente, luego convertimos el siguiente carácter de la base 36 a la base 10 ( :36(~$0)) y agregamos muchos ceros más. Luego, reemplazamos los que wusan s:g/w/00/y los que xusan s:g/x/000/. Finalmente, con s/$/z/, agregamos unzhacia el final, agregando muchas líneas vacías al fondo. (Veremos la razón más tarde).

El resto es solo una gran declaración de mapa. Estamos mapeando .split("z").map: (*~0 x.chars).comb}), que es la cadena de entrada (sin cero shorthands), dividida en líneas en z, con cada línea primero rellenada con 0 x.chars(toneladas de ceros, es decir, tantos como la longitud total de la cadena de entrada) a la derecha y luego desglosado en una lista de caracteres individuales ( .comb). Finalmente, lo transponemos con [Z](reducir con zip). La compresión finaliza en cuanto se agota la lista más corta, lo que da como resultado que todas las líneas tengan la misma longitud. (El número de ceros finales inútiles a la derecha es igual a la longitud de la línea más corta. Además, este truco de transposición falla para una "matriz" con solo una fila. Es por eso que agregamos a la fuerza otra fila al final antes).

Ahora, solo mapeamos las filas (columnas de la matriz original) y reemplazamos cada carácter encontrado con los 5 bits correspondientes. Eso se hace usando :32($_)(base 32 a base 10) .fmt("%05b")(formato como una cadena de bits de ancho 5, rellenada con ceros) .flip(invierta la cadena, porque el LSB está en la fila superior, no en la inferior) .comb(divida la cadena en una lista de caracteres). Hemos utilizado .flatmap, lo que aplana la lista resultante (de lo contrario, obtendríamos una lista de listas en cada columna). La transposición del resultado se devuelve implícitamente.

(Me siento un poco mal por abusar de la posibilidad de seguir ceros con tanta fuerza. Pero redujo el bytecount considerablemente :—).)

Ramillies
fuente
142 bytes
Jo King
@JoKing - ¡Oh, sí, muchas gracias!
Ramillies
Falla para 1yx1y1yw1
Jonathan Allan
@ JonathanAllan, tienes razón, gracias. Lo arreglaré en un momento. (Primero pensé por alguna razón que podría haber solo y[0-9a-v]y cuando descubrí que no era el caso, simplemente agregué una solución rápida (e incorrecta).)
Ramillies
Puede reemplazar el 000en la sustitución y conx
Jo King
2

Gelatina , 66 bytes

Yowza!

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

Un enlace monádico que produce una versión transpuesta como una lista de listas (agregue Zal final para volver a transponer).

Pruébalo en línea! O vea el conjunto de pruebas (con una salida impresa bonita).

Jonathan Allan
fuente
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`.+

Pruébalo en línea! El enlace incluye casos de prueba. Solución alternativa, también 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`.+

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

y(.)
#$1

Primero maneje el caso incómodo del ycomando. Lamentablemente, la carta después de esto puede ser una yo incluso una z, por lo que debemos tener cuidado aquí. Todas las magia ys se convierten primero en #s.

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

Un ciclo luego procesa el #s. Primero, 0se antepone a #. Si se trata de un #0cambio 000que completa la operación, de lo contrario, el carácter después del #decremento y el bucle se repite hasta que #se hayan procesado todos los correos electrónicos.

w
000
x
00

Arregla los ws y xs.

z
¶

Dividir en nuevas líneas. ( S`ztambién funciona para el mismo recuento 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` # #

Haga 5 copias de cada línea, luego realice la conversión binaria asignando letras con el bit apropiado #y borrando ese bit, mientras que otras letras se convierten en espacios. Los bits se procesan en el orden 16, 8, 4, 2, y luego la última traducción maneja borrar el 2bit y convertir el 1bit al mismo tiempo. (La versión alternativa hace cada copia individualmente, lo que cuesta más bytes, pero se guardan porque el manejo de bits se simplifica).

P`.+

Rellene todas las líneas a la misma longitud.

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

Pruébalo en línea!

5 bytes guardados por Jonathan Frech .

Chas Brown
fuente
Hay un espacio superfluo en while 'y'in. Creo que [-5:][::-1]se puede jugar al subíndice [:-6:-1]. La declaración de devolución se puede poner en la línea 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

Devuelve la transposición ... que luego se refleja a través del eje vertical; avíseme si eso invalida esta entrada. La salida es una matriz de cadenas que contienen 0sy 1s.

Pruébalo en línea!

Explicación

Para cada carácter c, se k+1evalúa el número de filas a modificar. k = "wxy".search(c) + 1;, donde el searchmétodo devuelve el índice o -1. kluego se disminuye hasta que llega -1al verificar ~k--un valor verdadero.

Si el carácter actual es "y", establezca una bandera para que el valor base 36 del siguiente carácter - 1 se convierta en el valor para k.

Al encontrar una "z", las cadenas de almohadilla a la izquierda, incrementan la cantidad de almohadilla 5y restablecen el índice de matriz a 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
redundancia
fuente
Creo que tendría más sentido no devolver la transposición de la entrada.
mbomb007
1

Haskell, 399 bytes

Instalar splitpaquete: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
Евгений Новиков
fuente