ความท้าทายนี้จะขึ้นอยู่กับการโพสต์ Sandbox โดยuser48538 เนื่องจากเขาไม่ได้ใช้งานเว็บไซต์นี้อีกต่อไปฉันจึงเข้าร่วมการท้าทายนี้

---

apgsearchโปรแกรมค้นหาซุปแบบกระจายสำหรับ Game of Life ของ Conway และฐานข้อมูลผลการค้นหาCatagolueใช้apgcodesเพื่อจัดหมวดหมู่และแสดงถึงรูปแบบ apgcodes ใช้รูปแบบ Wechsler แบบขยายซึ่งเป็นส่วนขยายของรูปแบบสัญลักษณ์ที่พัฒนาโดย Allan Wechsler ในปี 1992

ตัวอย่างต่อไปนี้และภาพที่นำมาจากLifeWiki

1. สตริงของอักขระnในชุดที่ตรงกับ regex จะ[0-9a-v]แสดงแถบของห้าแถวกว้างคอลัมน์n ตัวละครแต่ละตัวหมายถึงห้าเซลล์ในคอลัมน์แนวตั้งที่สอดคล้องกับ bitstrings [การ00000, 10000, 01000... 00010, 10010, 01010, 11010... 11111]

   ตัวอย่างเช่น27deee6สอดคล้องกับยานอวกาศเฮฟวี่เวท :

$$\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}$$

2. อักขระzคั่นแถบห้าแถวที่ต่อเนื่องกัน

   ตัวอย่างเช่น0ca178b96z69d1d96สอดคล้องกับภาพนิ่ง 31 บิต:

$$\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}$$

3. อักขระwและxถูกใช้เพื่อย่อ00และ000ตามลำดับ

   ดังนั้นw33z8kqrqk8zzzx33สอดคล้องกับกระสวยผึ้งทรานส์ควีน :

(ละเว้น 10 แถวว่าง)

$$\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}$$

4. สุดท้ายสัญลักษณ์การจับคู่ regex y[0-9a-z]ตรงตามลักษณะที่วิ่งระหว่างวันที่ 4 ติดต่อกันและ 39 0s

   ตัวอย่างที่ดีคือ31a08zy0123ckoสอดคล้องกับเรือรบใน quadpole :

$$\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}$$

ความท้าทาย

เขียนโปรแกรมหรือฟังก์ชันเพื่อแยกสตริงของรูปแบบ Wechsler ที่ขยายเพิ่มที่กำหนดไว้ด้านบนและพิมพ์ (หรือส่งคืน) รูปแบบที่สอดคล้องกับสตริงนี้

zคุณอาจจะคิดว่าเป็นสตริงว่างและไม่ได้เริ่มต้นหรือจุดสิ้นสุดด้วย

คุณสามารถใช้รูปแบบผลลัพธ์ที่สมเหตุสมผลเช่นสตริงเมทริกซ์อาร์เรย์ 2 มิติ คุณสามารถใช้สองค่าใด ๆ เพื่อเป็นตัวแทน0และ1โดยที่คุณประกาศไว้ในคำตอบ

คุณอาจละเว้นบรรทัดเลขศูนย์ต่อท้ายในผลลัพธ์หรือเพิ่มบรรทัดเลขศูนย์ต่อท้าย นอกจากนี้คุณยังสามารถเพิ่ม / ละเว้นเลขศูนย์ต่อท้ายในแต่ละบรรทัดได้ตราบใดที่ทุกบรรทัดมีความยาวเท่ากันในเอาต์พุต

คุณอาจส่งคืนการย้ายของอาร์เรย์ถ้าสะดวกกว่า

นี่คือรหัสกอล์ฟดังนั้นรหัสที่สั้นที่สุดชนะ

กรณีทดสอบ

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

ถ่าน 50 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด การใช้ประโยชน์และ1 0คำอธิบาย:

ＵＢ0

ตั้งค่าพื้นหลังเช่นใดเซลล์ unprinted 0ของสี่เหลี่ยมล้อมรอบการส่งออกเพื่อ

≔⁺⭆χιββ

คำนำหน้าตัวเลขไปยังตัวอักษรตัวพิมพ์เล็กที่กำหนดไว้ล่วงหน้า

ＦＳ

วนรอบสตริงอินพุต

¿υ

หากรายการว่างที่กำหนดไว้ล่วงหน้าไม่ว่างเปล่า ...

×0⁺⊟υ⌕βι

... จากนั้นพิมพ์จำนวน0s ที่กำหนดโดยผลรวมของตัวเลขที่ปรากฏจากรายการและดัชนีของอักขระปัจจุบันในตัวเลขและตัวอักษร ดูด้านล่างว่าตัวเลขนั้นคืออะไร

≡ι

สลับไปมาตัวละครปัจจุบัน

z×⸿⁵

ถ้ามันเป็นช่องว่างzขาออก 5 ช่องแล้วให้เรากลับไปที่ช่องสัญญาณออกถัดไป

y⊞υ⁴

ถ้าเป็นy, ให้กด4ไปที่รายการว่างที่กำหนดไว้ล่วงหน้า, ทำให้4+n 0s ส่งออกในครั้งต่อไป

x×0³

ถ้ามันxออกมา 3 0วินาที (สิ่งนี้ทำผ่านการทำซ้ำเพื่อหลีกเลี่ยงการ0สัมผัสตัวอักษรxหรือตามตัวอักษรต่อไปนี้)

w¦00

ถ้ามันเป็นwผลลัพธ์แล้ว 2 0วินาที ( ¦จำเป็นต้องแยกสองตัวอักษรสตริง)

«Ｐ↓⮌⍘⌕βι²→

มิฉะนั้นให้ทำดัชนีอักขระปัจจุบันในตัวเลขและตัวอักษรแปลงเป็นไบนารี่และพิมพ์ผลลัพธ์บิตที่มีนัยสำคัญน้อยลงก่อน จากนั้นเลื่อนเคอร์เซอร์ไปที่คอลัมน์ถัดไป

JavaScript (ES8), 197 ไบต์

รับอินพุตเป็นสตริง ส่งคืนอาร์เรย์ของสตริงด้วย '#' และช่องว่าง ผลลัพธ์อาจรวมถึงช่องว่างต่อท้ายพิเศษ (แต่สอดคล้องกัน) ในแต่ละบรรทัด

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

ลองออนไลน์! (เอาต์พุตที่กำหนดล่วงหน้า)

อย่างไร?

ตัวแปรทั่วโลก

• อักขระที่"x"ถูกนำมาใช้หลายครั้งจึงเป็นมูลค่าการจัดเก็บลงในตัวแปรx
• ฟังก์ชั่นparseIntจะใช้สองครั้งจึงเป็นมูลค่าการจัดเก็บลงในตัวแปรP
• Yคือดัชนีแถวเริ่มต้นได้ที่0
• wติดตามขอบเขตบนของความกว้างซึ่งใช้สำหรับรองเอาท์พุทสุดท้าย
• o []เป็นอาร์เรย์เอาต์พุตในตอนแรกจะว่างเปล่า

การประมวลผลล่วงหน้าของเลขศูนย์ซ้ำ

ก่อนอื่นเรามาแทนที่ทุกรูปแบบ"w", "x"และ"yX"ในสายเข้ากับจำนวนที่เหมาะสมของพื้นที่ "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
  )
)

ถอดรหัส

เราแยกสตริงที่เป็นผลลัพธ์รวมค่าเริ่มต้น"x"และวนซ้ำ 5 ครั้ง (ด้วยi = 0ถึง4 ) ในแต่ละอักขระc :

• หากcต่ำกว่า"x"เราจะเพิ่มรูปแบบที่สอดคล้องกับ 5 แถวถัดไป

  o[y + i - 5] += ' #'[P(c, 36) >> i & 1]

• หากคมากกว่าหรือเท่ากับ"x"เราจัดสรร 5 สายใหม่ที่ว่างเปล่าในo []และเพิ่ม5เพื่อY สิ่งนี้ถูกทริกเกอร์โดยการเริ่มต้น"x"ที่ถูกเพิ่มที่จุดเริ่มต้นของสตริงหรือใด ๆ"z"ในเนื้อหาต้นฉบับ

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

การขยายความ

สุดท้ายเราจะใส่แต่ละสตริงในo []ด้วยช่องว่างเพื่อให้ทุกตัวมีตัวอักษรw

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

05AB1E , 148 132 98 ไบต์

ฉันเป็นนักเรียนมัธยมและนี่เป็นครั้งแรกของฉันสำหรับทั้งการเล่นกอล์ฟและการใช้ 05AB1E ดังนั้นความคิดเห็นจะได้รับการชื่นชม!

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

ลองออนไลน์!

ลองออนไลน์!

ลองออนไลน์!

รับอินพุตเป็นตัวพิมพ์ใหญ่และเอาต์พุตเมทริกซ์ transposed เป็นหลายเอาต์พุตบรรทัด 1s และ 0s อาจเพิ่มศูนย์พิเศษ

หากคุณต้องการทดสอบด้วยสตริงตัวพิมพ์เล็กให้เพิ่มuในส่วนหัวของ TIO

หากคุณต้องการงานพิมพ์สวย ๆ เพิ่ม'1'█:'0'.:ในส่วนท้ายของ TIO

คำอธิบาย

(ฉันกำลังเรียก "แถว" และ "คอลัมน์" ตรงข้ามกับสิ่งที่คุณอาจคาดหวังเพราะมันสร้างเมทริกซ์ที่ถูกสลับเปลี่ยน)

อัลกอริทึมพื้นฐานคือ:

1. แทนที่ "yy" ด้วย 38 0s
2. แบ่งเป็น "y" และขยาย 0-run
3. แทนที่ "w" และ "x"
4. คิดออกคอลัมน์ที่ยาวที่สุด (นั่นคือสตริงที่ยาวที่สุดระหว่าง z) และรองคอลัมน์อื่น ๆ ทั้งหมดเพื่อให้พวกเขามีความยาวที่ (สิ่งนี้จำเป็นเนื่องจากวิธีการทำงานของอัลกอริทึมด้านล่าง)
5. แยกบน z
6. ณ จุดนี้สตริงอินพุตเป็นอาร์เรย์ของคอลัมน์ที่แต่ละคอลัมน์เป็นสตริงของ [0-9A-V] โดยที่แต่ละคอลัมน์มีความยาวเท่ากัน
7. อัลกอริธึมที่จะทำให้มันเป็นรูปแบบผลลัพธ์คือ
   1. แปลงอักขระเป็นตัวเลขโดยใช้ indexOf ในสตริงการค้นหา
   2. แปลงอักขระเป็นไบนารี่และจากนั้นให้แพดยาว 5
   3. หากเป็นคอลัมน์แรกให้เพิ่ม linebreak ก่อนเลขฐานสอง
   4. เพิ่มคำนำหน้าเพื่อเริ่มต้นของสตริงไบนารีที่เก็บแถวและคอลัมน์ของตัวละคร
   5. กดสตริงไบนารีพร้อมคำนำหน้าเพื่อลงทะเบียน / ตัวแปร "global array" ของ 05AB1E
8. เรียงลำดับอาร์เรย์ส่วนกลาง สตริงคำนำหน้าซึ่งกำหนดลำดับการจัดเรียงจะทำให้แน่ใจว่าทุกอย่างจบลงในลำดับที่ถูกต้องและการกระจายบรรทัดอยู่ในตำแหน่งที่ถูกต้อง
9. ลบสตริงคำนำหน้าจากแต่ละองค์ประกอบของอาร์เรย์ทั่วโลก
10. เข้าร่วมอาร์เรย์ด้วย "" และพิมพ์

มีรายละเอียดเล็กน้อยอื่น ๆ ที่คุณสามารถดูด้านล่างในรหัสที่ขยาย ทุกอย่างหลังจากแท็บที่ท้ายบรรทัดมีความคิดเห็นและสามารถละเว้นได้ (รูปแบบความคิดเห็นนี้ไม่ได้เป็นส่วนหนึ่งของ 05AB1E แต่อย่างใดฉันทำแบบนี้เพราะมันดูดี) บรรทัดที่มีความคิดเห็นที่ขึ้นต้นด้วย "@" นั้นมีจุดประสงค์เพื่อการดีบั๊กและสามารถละเว้นได้โดยไม่ต้องเปลี่ยนผลลัพธ์สุดท้าย

„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 

APL (Dyalog Unicode) , 87 80 77 67 63 ไบต์

ขอบคุณ H.PWiz สำหรับการบันทึก 7 ไบต์และ ngn สำหรับอีก13 17

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

ลองออนไลน์!

NB: ใช้อินพุตเป็นสตริงตัวพิมพ์ใหญ่

พร้อมงานพิมพ์สวย ๆ

คำอธิบาย

a←⎕D,⎕Aเป็นสตริง'0123...89ABCD...XYZ'
'Y.|W|X'⎕R{'0'/⍨+/30 36|a⍳2↑⍵.Match}แทนที่ XW และ Yx มีจำนวนที่สอดคล้องกันของ'0's (อธิบายเพิ่มเติมด้านล่าง) 35(≠⊆⊢)a⍳แปลงสตริงเป็นเวกเตอร์ของ indecies ในaและแยกบน35(IE) 'Z'การสร้างซ้อนกันเวกเตอร์
↑แปลงเวกเตอร์ที่ซ้อนกันเป็นเมทริกซ์ padding ปลายกับ0s
(5/2)⊤แปลงแต่ละ ตัวเลขเข้าสู่เวกเตอร์ไบนารีทำให้เกิดเมทริกซ์ 3 มิติพร้อมเวกเตอร์ไบนารีตามแกนหลัก
⊖กลับด้านตามแกนปฐมภูมิ
↓ลดอันดับของเมทริกซ์ดังนั้นจึงเป็น 2 มิติ
,⍉ปรับเปลี่ยนผลลัพธ์เป็นเอาต์พุตที่เหมาะสม

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

เพิร์ล 6 ,156 142 ไบต์

บันทึกไปแล้ว 14 ไบต์ขอบคุณ Jo King (แก้ไขข้อผิดพลาดเล็กน้อยด้วยการแยกวิเคราะห์yและเพิ่ม prettifier)

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}

ลองออนไลน์!

ตัวแบ่งบรรทัดอยู่ที่นั่นเพื่อทำให้ข้อความพอดีกับหน้าจอ มันไม่ได้เป็นส่วนหนึ่งของโปรแกรม

มันทำงานยังไง

มันเป็นฟังก์ชั่นที่ไม่ระบุชื่อที่ใช้สตริงที่ไม่แน่นอน (สิ่งนี้ทำให้การใช้งานฟังก์ชั่นแปลก ๆ เพราะคุณสามารถให้ตัวแปรเท่านั้นไม่ใช่ตัวอักษร) หลังจากทำงานบางอย่างมันจะส่งกลับรายการของรายการที่มี 0 และ 1 โดยมีความหมายเช่นเดียวกับในโพสต์ต้นฉบับ

$_สายเข้ามาในในตัวแปร เราเริ่มต้นด้วยการใช้ชุดคำสั่งการแทนที่ในนั้นเพื่อกำจัดชวเลขทั้งหมดสำหรับเลขศูนย์จำนวนมาก อันดับแรกเราจำเป็นต้องเรียงลำดับออกyเพราะในกรณีของyxหรือywที่w(หรือx) ไม่ได้เป็นการจดชวเลขด้วยตัวเอง เราค้นหาy(.)( yและอักขระหนึ่งตัวที่จำได้) และแทนที่โดย000{"0"x:36(~$0)}: เลขศูนย์สามตัวจะถูกคัดลอกคำต่อคำจากนั้นเราแปลงอักขระถัดไปจากฐาน 36 เป็นฐาน 10 ( :36(~$0)) และเพิ่มศูนย์อีกจำนวนมาก จากนั้นเราจะมาแทนที่wของใช้s:g/w/00/และของใช้x s:g/x/000/ในที่สุดด้วยs/$/z/เราเพิ่มzไปยังจุดสิ้นสุดโดยเพิ่มบรรทัดว่างจำนวนมากลงที่ด้านล่าง (เราจะเห็นสาเหตุในภายหลัง)

ที่เหลือก็เป็นเพียงแผนที่ขนาดใหญ่ เราทำการแมป.split("z").map: (*~0 x.chars).comb})ซึ่งเป็นสตริงอินพุต (โดยไม่มีศูนย์ย่อ) แยกออกเป็นบรรทัดที่zโดยแต่ละบรรทัดจะถูกเติมด้วย0 x.chars(ศูนย์เป็นตันซึ่งเท่ากับความยาวทั้งหมดของสตริงอินพุต) ที่ด้านขวา จากนั้นแยกย่อยเป็นรายการของอักขระแต่ละตัว ( .comb) ในที่สุดเราก็เปลี่ยนมันด้วย[Z](ลดด้วย zip) การซิปจะสิ้นสุดลงทันทีที่รายการที่สั้นที่สุดหมดลงซึ่งส่งผลให้ทุกบรรทัดมีความยาวเท่ากัน (จำนวนศูนย์ต่อท้ายที่ไม่มีประโยชน์ทางด้านขวาเท่ากับความยาวของบรรทัดที่สั้นที่สุดนอกจากนี้เคล็ดลับการขนย้ายนี้ล้มเหลวสำหรับ "เมทริกซ์" ที่มีเพียงหนึ่งแถวนั่นคือเหตุผลที่เราบังคับให้เพิ่มแถวอื่นในตอนท้ายก่อน)

ตอนนี้เราเพิ่งแมปแถว (คอลัมน์ของเมทริกซ์ดั้งเดิม) และแทนที่อักขระแต่ละตัวที่พบด้วย 5 บิตที่สอดคล้องกัน ที่ทำโดยใช้:32($_)(ฐาน 32 ถึงฐาน 10) .fmt("%05b")(จัดรูปแบบเป็น bitstring ของความกว้าง 5, เบาะด้วยศูนย์) .flip(ย้อนกลับสตริงเพราะ LSB อยู่ในแถวด้านบนไม่ใช่ด้านล่าง) .comb(แบ่งสตริงลงในรายการของ ตัวอักษร) เราได้ใช้.flatmapซึ่งทำให้รายการผลลัพธ์แบน (มิฉะนั้นเราจะได้รับรายชื่อของรายการในแต่ละคอลัมน์) การแปลงผลลัพธ์จะถูกส่งกลับโดยปริยาย

(ฉันรู้สึกแย่เล็กน้อยเพราะการใช้ความเป็นไปได้ที่จะลากเลขศูนย์อย่างหนัก แต่มันลดจำนวน bytecount ลงค่อนข้างมาก: ---))

เยลลี่ 66 ไบต์

^Yowza!

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

ลิงก์ monadic ซึ่งให้ผลลัพธ์เวอร์ชัน transposed เป็นรายการของรายการ (เพิ่มZที่ส่วนท้ายเพื่อย้ายกลับ)

ลองออนไลน์! หรือดูชุดทดสอบ (พร้อมเอาต์พุตที่พิมพ์ออกมาสวย)

เรติน่า , 203 ไบต์

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ โซลูชันทางเลือก 203 ไบต์เช่นกัน:

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ คำอธิบาย:

y(.)
#$1

จัดการกับตัวพิมพ์เล็กของyคำสั่ง น่าเศร้าที่จดหมายฉบับนี้ได้รับอนุญาตให้เป็นyหรือแม้กระทั่งzเราจึงต้องระวังที่นี่ เวทมนตร์ทั้งหมดyจะถูกเปลี่ยนเป็น#s ก่อน

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

จากนั้นวนรอบจะประมวลผล#s แรกจะใช้ได้กับ0 #หากนี่คือค่า#0ที่เปลี่ยนไป000ซึ่งการดำเนินการเสร็จสมบูรณ์มิฉะนั้นอักขระหลังจากที่#ลดค่าลงและลูปจะทำซ้ำจนกว่าจะ#มีการประมวลผลทั้งหมด

w
000
x
00

แก้ไขws และxs

z
¶

แยกบนบรรทัดใหม่ ( S`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` # #

ทำสำเนา 5 ชุดของแต่ละบรรทัดจากนั้นทำการแปลงแบบไบนารีโดยการทำแผนที่ตัวอักษรด้วยบิตที่เหมาะสม#และหักล้างบิตนั้นในขณะที่ตัวอักษรอื่น ๆ กลายเป็นช่องว่าง บิตจะถูกประมวลผลตามลำดับ 16, 8, 4, 2 แล้วการแปลครั้งล่าสุดจะจัดการกับการล้าง2บิตและแปลง1บิตในเวลาเดียวกัน (รุ่นทางเลือกทำสำเนาแต่ละชุดซึ่งมีค่าใช้จ่ายมากกว่าไบต์ แต่จะถูกบันทึกไว้เนื่องจากการจัดการบิตนั้นง่ายขึ้น)

P`.+

วางทุกบรรทัดให้ยาวเท่ากัน

Python 2 , 249 244 ไบต์

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

ลองออนไลน์!

5 ไบต์บันทึกไว้โดยโจนาธาน Frech

JavaScript (ES8), 192 ไบต์

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

ส่งคืนการไขว้ ... ซึ่งจะสะท้อนไปทั่วแกนตั้ง แจ้งให้เราทราบหากสิ่งนั้นทำให้รายการนี้ไม่ถูกต้อง เอาต์พุตเป็นอาร์เรย์ของสตริงที่มี 0s และ1s

ลองออนไลน์!

คำอธิบาย

สำหรับแต่ละอักขระcให้k+1ประเมินจำนวนแถวที่จะแก้ไข k = "wxy".search(c) + 1;ซึ่งวิธีการส่งกลับดัชนีหรือ search จะลดลงจนกว่าจะถึงโดยการตรวจสอบค่าความจริง-1k-1~k--

ถ้าตัวละครในปัจจุบันคือ "Y" ตั้งธงเพื่อให้ค่าฐาน-36 ของตัวอักษรถัดไป - 1 kกลายเป็นค่าสำหรับ

เมื่อพบกับ "z" ให้ดึงสตริงของแผ่นทางด้านซ้ายเพิ่มจำนวนของแผ่นอิเล็กโทรด5แล้วตั้งค่าดัชนีอาเรย์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

Haskell, 399 ไบต์

ติดตั้งsplitแพคเกจ: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