18

Bu zorluk, user48538 tarafından sağlanan bir korumalı alana dayalıdır . Artık bu sitede aktif olmadığı için bu zorluğu aştım.

apgsearch , Conway'in Hayat Oyunu için dağıtılan çorba arama programı ve arama sonuçları veritabanı, Catagolue kullanım apgcodes sınıflandırmak ve göstermektedirler desenleri için. apgcodes , 1992'de Allan Wechsler tarafından geliştirilen bir desen gösteriminin uzantısı olan genişletilmiş Wechsler formatını kullanıyor .

Aşağıdaki örnekler ve görüntüler LifeWiki'den alınmıştır .

Bir dize n regex eşleşen sette karakterlerin [0-9a-v]beş satır, bir şeridi anlamına gelmektedir n geniş sütunlar. Her karakter bit katarı tekabül eden dikey bir kolon içinde beş hücreleri belirtmektedir [ 00000, 10000, 01000... 00010, 10010, 01010, 11010... 11111].

Örneğin, ağır bir uzay gemisine27deee6 karşılık gelir :

[\begin{matrix} 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 \end{matrix}]

$\begin{bmatrix} {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ 1 & 1 & {\color{Gray}0} & 1 & 1 & 1 & 1 \\ {\color{Gray}0} & 1 & 1 & 1 & 1 & 1 & 1 \\ {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & 1 & 1 & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \end{bmatrix}$

Karakter zbitişik beş sıralı şeritleri ayırır.

Örneğin, 0ca178b96z69d1d9631 bitlik bir natürmort'a karşılık gelir:

[\begin{matrix} 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 \end{matrix}]

$\begin{bmatrix} {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 \\ {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 \\ {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & 1 & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & 1 & 1 & 1 & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} \\ 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \end{bmatrix}$

Karakterleri wve xkısaltmak için kullanılır 00ve 000sırasıyla.

Yani w33z8kqrqk8zzzx33bir trans-kraliçe arı mekiğine karşılık gelir :

(10 boş satır atlanmıştır)

[\begin{matrix} 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 \end{matrix}]

$\begin{bmatrix} {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} \\ 1 & {\color{Gray}0} & 1 & 1 & 1 & {\color{Gray}0} & 1 \\ {\color{Gray}0} & 1 & 1 & 1 & 1 & 1 & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \end{bmatrix}$

Son olarak, normal ifadeyle eşleşen semboller y[0-9a-z]4 ila 39 ardışık 0s arasındaki işlemlere karşılık gelir .

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

[\begin{matrix} 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 \end{matrix}]

$\begin{bmatrix} 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 & {\color{Gray}0} \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & {\color{Gray}0} & 1 \\ {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & {\color{Gray}0} & 1 & 1 \end{bmatrix}$

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 code-golf, 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]]

code-golf parsing game-of-life

— alephalpha
kaynak

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

Gerçekten bir Hayat Oyunu deseni değil, sadece eğlence için:vv99f60vv99f60uv11320uv19rqz33y133y11322310132231

— Arnauld

1

"Dizinin devrikliğini geri döndürebilirsiniz" - eğer sorun değilse, baş aşağı vb. Gibi diğer simetrilere ne dersiniz?

— Jonathan Allan

1

: İlk üç cevapları ikisi bunlardan bazıları için başarısız 1yx1, 1yy1, 1yw1ve 1yz1. Belki de test olmalılar.

— Jonathan Allan

2

Kömür , 50 bayt

ＵＢ0≔⁺⭆χιββＦＳ¿υ×0⁺⊟υ⌕βι≡ιz×⸿⁵y⊞υ⁴x×0³w¦00«Ｐ↓⮌⍘⌕βι²→

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Kullanır 1ve 0. Açıklama:

ＵＢ0

Arka planı, yani çıktıyı çevreleyen dikdörtgenin yazdırılmamış hücrelerini olarak ayarlayın 0.

≔⁺⭆χιββ

Basamakları önceden tanımlanmış küçük harf alfabesine önek.

ＦＳ

Giriş dizesinin üzerinden döngü yapın.

¿υ

Önceden tanımlanmış boş liste boş değilse ...

×0⁺⊟υ⌕βι

... daha sonra 0, listeden açılan sayının toplamı ile rakam ve harflerde geçerli karakterin indeksi ile verilen bir takım sayıları yazdırın . Bu sayının her zaman ne olduğu için aşağıya bakın.

≡ι

Geçerli karakteri değiştirin.

z×⸿⁵

Eğer o zzaman çıkış 5 taşıyıcı geri döner ve bizi bir sonraki çıkış şeridine götürür.

y⊞υ⁴

Bir buysa y, o zaman itmek 4neden önceden tanımlanmış boş listeye 4+n 0ın çıkış dahaki sefere olmak.

x×0³

Bu bir xçıkış ise 3 0s. (Bu, değişmez 0değerin xveya aşağıdaki değişmez değere dokunmasını önlemek için tekrarlama yoluyla yapılır .)

w¦00

Bu bir wçıkış ise 2 0s. ( ¦İki dize değişmezini ayırmak için gerekir.)

«Ｐ↓⮌⍘⌕βι²→

Aksi takdirde, rakam ve harflerde geçerli karakteri dizine ekler, ikiliye dönüştürür ve sonucu önce en az anlamlı bit aşağıya doğru yazdırır; ardından imleci sonraki sütun için sağa hareket ettirin.

— Neil
kaynak

6

JavaScript (ES8), 197 bayt

Girişi dize olarak alır. '#' Ve boşluklu dizeler dizisi döndürür. Çıktı, her satırda fazladan (ancak tutarlı) takip eden boşluklar içerebilir.

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

Çevrimiçi deneyin! (önceden hazırlanmış çıktı)

Nasıl?

Global değişkenler

Karakter "x"birkaç kez kullanılır, bu yüzden onu x değişkenine depolamaya değer .
İşlev parseIntiki kez kullanılır, bu nedenle P değişkenine depolamaya değer .
y , 0 olarak başlatılan satır dizinidir .
w , son çıktıyı doldurmak için kullanılan genişliğin bir üst sınırının kaydını tutar.
o [] başlangıçta boş olan çıktı dizisidir.

Tekrarlanan sıfırların ön işlemleri

Biz her şeyden önce desenleri değiştirmek "w", "x"ve "yX"gereken sayıda boşluk ile giriş dizesi. Bu alanlar daha sonra olarak yorumlanacaktır "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

Ortaya çıkan dizeyi böleriz, bir baş harfinin başına ekleriz "x"ve her c karakterinde 5 kez ( i = 0 - 4 ile ) yineleriz :

Eğer C daha düşük olduğu "x", bir sonraki 5 satırlara karşılık gelen model ekleyin.
```
o[y + i - 5] += ' #'[P(c, 36) >> i & 1]
```
Eğer C daha büyük olan ya da eşit "x", içinde 5 yeni boş dizeleri tahsis o [] ekleyin 5 için y . Bu, "x"dizenin başına eklenen baş harfiyle veya "z"orijinal içerikteki herhangi biri tarafından tetiklenir .
```
o = [...++y && o, '']
```

Dolgu malzemesi

Son olarak, her bir dizeyi o [] içine boşluklarla doldururuz, böylece hepsinin w karakteri olur.

o.map(r => r.padEnd(w))

— Arnauld
kaynak

6

05AB1E , 148 132 98 bayt

Ben bir lise öğrencisiyim ve bu hem golf yapmak hem de 05AB1E kullanmak için ilk kez oldu, bu yüzden yorumlar takdir edildi!

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

~~Çevrimiçi deneyin!~~

Çevrimiçi deneyin!

Girişi büyük harf olarak alır ve aktarılan matrisi 1s ve 0s çoklu çıkış çizgileri olarak çıkarır. Ekstra sıfır ekleyebilir.

Küçük harfli dizelerle test etmek istiyorsanız u, TIO başlığına ekleyin .

Güzel yazdırılmış çıktılar istiyorsanız '1'█:'0'.:, TIO altbilgisine ekleyin .

açıklama

(Ben transpoze matris oluşturur çünkü beklediğiniz ne zıt "satır" ve "sütun" çağırıyorum)

Temel algoritma:

"Yy" yerine 38 0s girin
"Y" üzerine bölün ve 0-run'ları genişletin.
"W" ve "x" ifadelerini değiştirin
En uzun sütunu (yani, z'ler arasındaki en uzun dizeyi) bulun ve diğer tüm sütunları bu uzunlukta olacak şekilde doldurun. (Bu, aşağıdaki algoritmanın çalışma şekli nedeniyle gereklidir)
Split on z
Bu noktada, giriş dizesi, her sütunun [0-9A-V] dizesi olduğu ve her sütunun aynı uzunlukta olduğu bir sütun dizisidir.
Çıktı formatına almak için algoritma
1. Arama dizesindeki indexOf komutunu kullanarak karakterleri sayılara dönüştürme
2. Karakterleri ikiliye dönüştürün ve sonra uzunluğunu 5'e çevirin
3. İlk sütunsa, ikili sayıdan önce bir satır sonu ekleyin
4. Satırı ve ardından karakterin sütununu depolayan ikili dizenin başına bir önek ekleyin.
5. İkili dizeyi önekle 05AB1E'nin "global dizi" kaydına / değişkenine it
Genel diziyi sıralayın. Sıralama düzenini belirleyen önek dizesi, her şeyin doğru sırada bitmesini ve satır aralıklarının doğru yerlerde olmasını sağlar.
Global dizinin her öğesinden önek dizesini kaldırın
Diziye "" ile katılın ve yazdırın.

Genişletilmiş kodda aşağıda görebileceğiniz bazı küçük ayrıntılar var. Satırın sonundaki sekmelerden sonraki her şey bir yorumdur ve yok sayılabilir. (Bu yorum şeması 05AB1E'nin bir parçası değildir. Bu şekilde yaptım çünkü güzel görünüyordu.) "@" İle başlayan yorumları olan satırlar hata ayıklama amaçlıdır ve son çıktıyı değiştirmeden atlanabilir.

„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
kaynak

1

Merhaba ve PPCG'ye hoş geldiniz; çok güzel ilk yazı! Bayt sayınıza gelince: haklısınız. TIO, 148 karakterin 05AB1E kod sayfası kullanılarak 148 bayt ile temsil edildiğini bile kolayca gösterir.

— Jonathan Frech

Küçük bir not: Çoğu golf dili örtük baskı uygular; Sanırım sonuncusunu yapabilirsin ,.

— Jonathan Frech

Baktım ve bazı iyileştirmeler yaptım. Davranış sadece (teorik olarak) 1000'den fazla satır veya sütuna sahip şeyler için farklı olacaktır, bu noktada daha küçük program beklenmedik bir şey yapacaktır.

— kerwizzy

Başlamak için en kolay zorluk değil! İyi iş, bazı 05AB1E çarpıklarının geldiklerinde bazı kullanışlı işaretçiler vereceğini hayal ediyorum.

— Jonathan Allan

1

PPCG'ye ve 05AB1E dünyasına hoş geldiniz. Şu anda çok fazla zamanım yok ve sadece birkaç ay önce 05AB1E kullanmaya başladım, bu yüzden henüz bir profesyonel değilim, ama burada golf yapmak için bazı küçük şeyler: "yy"olabilir „yy(05AB1E var hem 2 karakterli hem de 3 karakterli dize yerleşik). >≠edilebilir Ā(truthified, temelde 0kalır 0ve her şey olur 1). }}olabilir ](tüm döngüleri ve ifisleri kapatır). Profesyonel 05AB1E golfçülerin bazılarının benden daha önemli şeyler golf edebildiğinden eminim, muhtemelen bayt sayısını yarıya indirebilir.

— Kevin Cruijssen

4

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

H.PWiz'e 7 bayt ve ngn tasarrufu için teşekkürler 13 17.

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

Çevrimiçi deneyin!

Not: Girişi büyük harfli bir dize olarak alır.

Oldukça basılı çıktı ile

açıklama

a←⎕D,⎕Aa, dize '0123...89ABCD...XYZ'
'Y.|W|X'⎕R{'0'/⍨+/30 36|a⍳2↑⍵.Match}XW ve Yx'in yerine karşılık gelen sayıda '0's (aşağıda açıklanmıştır) ile yer 35(≠⊆⊢)a⍳değiştirir, dizeyi içindeki indekslerin vektörüne dönüştürür ve aüzerine bölünür 35(yani) 'Z'bir iç içe vektör oluşturma iç
↑içe vektörünü her bir 0s
(5/2)⊤dönüştürmesiyle bir matris dolgu uçlarına dönüştürür birincil eksen
⊖boyunca ters vektörler ile ikili vektörler ile 3 boyutlu bir matris sonuçlanan bir ikili vektöre sayı
↓, matrisin sırasını azaltır, böylece
,⍉sonucu 2 boyutlu uygun çıktıya yeniden şekillendirir

'Y.|W|X'⎕R{'0'/⍨30 36|a⍳2↑⍵.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
kaynak

İşte 7 bayt tasarrufu:

a←⎕D,⎕A⋄,↓↑{⊖(5/2)⊤a⍳⍵}¨'Z'(≠⊆⊢)('Y.|W|X'⎕R{'0'/⍨{0::2+'WX'⍳⍵⋄4+a⍳1⊃⍵}⍵.Match})⍞

. Hata yakalama da çok golf gibi görünmüyor

— H.PWiz

Teşekkürler H.PWiz. Evet ben de hata yakalama sevmiyorum ama aksi takdirde iki regex yerine kullanıyordum.

— jslip

@js parantez etrafında ⎕Rve onun işlenen gereksiz

— ngn

2+'WX'⍳⍵->2+'X'=⍵

— ngn

{0::2+'X'=⍵⋄4+a⍳1⊃⍵}⍵.Match->30 36|a⍳2↑⍵.Match

— ngn

3

Perl 6 ,156 142 bayt

Jo King sayesinde 14 bayt tasarruf etti. (Ayrıştırma ile küçük bir hata düzeltildi yve bir ön ekledi.)

Arabasının ayrıştırılması düzeltildi 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}

Çevrimiçi deneyin!

Satır sonu metni ekrana sığdırmak için orada. Programın bir parçası değildir.

O nasıl çalışır

Değişken bir dize alan anonim bir işlevdir. (Bu, işlevi kullanmayı biraz tuhaf hale getirir, çünkü ona değişmez değerler değil, yalnızca değişkenler verebilirsiniz.) Bazı çalışmalardan sonra, orijinal yazıdakiyle aynı anlama gelen 0 ve 1 içeren listelerin bir listesini döndürür.

Giriş dizesi değişkende gelir $_. Çeşitli sıfır sayıları için bu kısayollardan kurtulmak için üzerinde bir dizi ikame ifadesi kullanarak başlıyoruz. İlk olarak, çözmek gerekir yçünkü söz konusu olduğunda, yxya da yw, w(ya da x) kendi başına bir steno teşkil etmez. Biz y(.)( yve hatırladığı bir karakter) 000{"0"x:36(~$0)}ararız ve onunla değiştiririz : üç sıfır kelimesi kelimesi kelimesine kopyalanır, daha sonra bir sonraki karakteri taban 36'dan taban 10'a dönüştürür ( :36(~$0)) ve daha birçok sıfır ekleriz. Sonra, w's s:g/w/00/ve x' s kullanarak değiştirin s:g/x/000/. Son olarak, birlikte s/$/z/, bir eklemezsonuna kadar bir sürü boş satır ekleyerek. (Nedeni daha sonra göreceğiz.)

Gerisi sadece büyük bir harita ifadesidir. Her bir satır ilk önce (tonlarca sıfır, yani giriş dizesinin toplam uzunluğu kadar) dolgulu .split("z").map: (*~0 x.chars).comb})olarak, giriş dizesi (sıfır steno olmadan), satırlara bölünmüş olarak eşleştiriyoruz ve sonra tek tek karakterler ( ) olarak ayrılır . Son olarak, (zip ile azaltın) ile aktarıyoruz. Sıkıştırma, en kısa liste biter bitmez sona erer, bu da tüm satırların aynı uzunlukta olmasına neden olur. (Sağdaki işe yaramaz sıfırın sayısı en kısa çizginin uzunluğuna eşittir. Ayrıca, bu transpozisyon hilesi sadece bir sıralı bir "matris" için başarısız olur. Bu yüzden daha önce sonuna başka bir satır daha ekledik.)z0 x.chars.comb[Z]

Şimdi, sadece satırları (orijinal matrisin sütunları) eşleştiriyoruz ve karşılaşılan her karakteri karşılık gelen 5 bitle değiştiriyoruz. :32($_)(Taban 32 ila taban 10) .fmt("%05b")(sıfırlarla doldurulmuş 5 genişlik bit .flipdizisi olarak biçimlendir ) kullanılarak yapılır ( dizeyi tersine çevirin, çünkü LSB en alt satırda değil, en üst satırdadır) .comb(dizeyi karakter). .flatmapSonuç listesini düzleştiren kullandık (aksi takdirde her sütunda listelerin bir listesini alırız). Sonucun devri daha sonra örtük olarak döndürülür.

(Sıfırları çok zor takip etme olasılığını kötüye kullandığım için biraz kötü hissediyorum. Ancak bayt sayısını oldukça önemli ölçüde azalttı:

— Ramillies
kaynak

142 bayt

— Jo King

@JoKing - Ah evet, çok teşekkür ederim!

— Ramillies

Başarısız 1yx1ve1yw1

— Jonathan Allan

@JonathanAllan, haklısın, teşekkürler. Birazdan tamir edeceğim. (İlk önce sadece bir sebep olabileceğini düşündüm y[0-9a-v]ve durum böyle olmadığında, hızlı (ve yanlış) bir düzeltme ekledim.)

— Ramillies

Sen yerini alabilir 000ile y yerinex

— Jo Kral

2

Jöle , 66 bayt

^{Vay canına!}

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

Liste listesi olarak aktarılmış bir sürüm veren monadik bir bağlantı ( Zgeri dönüştürmek için sonuna ekleyin ).

Çevrimiçi deneyin! Ya da test takımına bakın (güzel çıktı ile).

— Jonathan Allan
kaynak

2

Retina , 203 bayt

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

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. Alternatif çözüm, ayrıca 203 bayt:

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

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. Açıklama:

y(.)
#$1

Önce ykomutun garip durumunu ele alın . Ne yazık ki bundan sonraki mektubun ybir z, hatta bir olmasına izin verilir , bu yüzden burada dikkatli olmalıyız. Bütün büyüler yilk önce #s'ye dönüşür .

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

Daha sonra bir döngü #s'yi işler . İlk olarak, a 0eklenir #. Bu işlemin tamamlandığı bir #0değiştirilmişse 000, aksi takdirde the karakterinden sonraki karakter #azaltılır ve döngü tüm #s işlenene kadar tekrarlanır .

wS ve xs'yi düzeltin .

z
¶

Yeni satırlara bölün. ( S`zaynı bayt sayısı için de çalışır.)

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

Her satırın 5 kopyasını oluşturun, ardından #diğer bitler boşluk haline gelirken harfleri uygun bitle eşleştirerek ve bu biti temizleyerek ikili dönüşüm gerçekleştirin . Bitler 16, 8, 4, 2 sırasıyla işlenir ve daha sonra son çeviri, 2bitin temizlenmesini ve bitin 1aynı anda dönüştürülmesini sağlar . (Alternatif sürüm, her bir kopyayı ayrı ayrı yapar ve bu da daha fazla bayttır, ancak bit işleme basitleştirildiğinden bunlar kaydedilir.)

P`.+

Tüm çizgileri aynı uzunlukta doldurun.

— Neil
kaynak

1

Python 2 , 249 244 bayt

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

Çevrimiçi deneyin!

Jonathan Frech tarafından kaydedilen 5 bayt .

— Chas Kahve
kaynak

İçinde gereksiz bir alan var while 'y'in. Sanırım alt simge [-5:][::-1]golf edilebilir [:-6:-1]. Dönüş ifadesi bir önceki satıra konabilir.

— Jonathan Frech

1

JavaScript (ES8), 192 bayt

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

Daha sonra dikey eksene yansıtılan devrik dönüşü döndürür; bunun bu girişi geçersiz hale getirip getirmediğini bana bildirin. Çıktı, 0s ve 1s içeren dizelerden oluşan bir dizidir .

Çevrimiçi deneyin!

açıklama

Her karakter için c, k+1değiştirilecek satır sayısını değerlendirir. k = "wxy".search(c) + 1;, burada searchyöntem dizini veya döndürür -1. kdaha sonra doğruluk değeri -1kontrol edilerek ulaşılana kadar azaltılır ~k--.

Geçerli karakter "y" ise, bir sonraki karakterin base-36 değeri - 1'in değeri olması için bir bayrak ayarlayın k.

Bir "z" ile karşılaştığınızda, ped dizeleri sola doğru, ped miktarını 5arttırır ve dizi indeksini sıfırlar 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

— fazlalık
kaynak

Bence girdinin dönüşümünü geri döndürmemenin daha mantıklı olacağını düşünüyorum.

— mbomb007

1

Haskell, 399 bayt

Yükleme splitpaketi: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

— Евгений Новиков
kaynak

Genişletilmiş Wechsler formatının şifresini çözme

The Challenge

Test cases

Kömür , 50 bayt

JavaScript (ES8), 197 bayt

Nasıl?

Global değişkenler

Tekrarlanan sıfırların ön işlemleri

Decoding

Dolgu malzemesi

05AB1E , 148 132 98 bayt

açıklama

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

açıklama

Perl 6 ,156 142 bayt

O nasıl çalışır

Jöle , 66 bayt

Retina , 203 bayt

Python 2 , 249 244 bayt

JavaScript (ES8), 192 bayt

açıklama

Haskell, 399 bayt