Thử thách này dựa trên bài đăng hộp cát của người dùng48538 . Vì anh ấy không còn hoạt động trên trang này, tôi đã tiếp nhận thử thách này.

---

apssearch , chương trình tìm kiếm súp phân tán cho Trò chơi cuộc sống của Conway và cơ sở dữ liệu kết quả tìm kiếm, Catagolue sử dụng các mã dữ liệu để phân loại và biểu thị các mẫu. Bản thân các apgcodes sử dụng định dạng Wechsler mở rộng , một phần mở rộng của ký hiệu mẫu được phát triển bởi Allan Wechsler vào năm 1992.

Các ví dụ và hình ảnh sau đây được lấy từ LifeWiki .

1. Một chuỗi gồm n ký tự trong tập hợp khớp với [0-9a-v]biểu thức chính quy biểu thị một dải gồm năm hàng, n cột rộng. Mỗi nhân vật biểu thị lăm tế bào trong một cột thẳng đứng tương ứng với bitstrings [ 00000, 10000, 01000... 00010, 10010, 01010, 11010... 11111].

   Chẳng hạn, 27deee6tương ứng với một tàu vũ trụ hạng nặng :

$$\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. Các nhân vật ztách dải năm hàng liền kề.

   Ví dụ, 0ca178b96z69d1d96tương ứng với thời gian tĩnh 31 bit:

$$\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. Các ký tự wvà xđược sử dụng để viết tắt 00và 000, tương ứng.

   Vì vậy, w33z8kqrqk8zzzx33tương ứng với một tàu con ong xuyên nữ hoàng :

(Bỏ 10 hàng trống)

$$\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. Cuối cùng, các ký hiệu khớp với biểu thức chính quy y[0-9a-z]tương ứng với các lần chạy trong khoảng từ 4 đến 39 0giây liên tiếp .

   Một ví dụ điển hình là 31a08zy0123cko, tương ứng với một con tàu trên 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}$$

Các thách thức

Viết chương trình hoặc hàm để phân tích một chuỗi định dạng Wechsler mở rộng, được xác định ở trên và in (hoặc trả về) mẫu tương ứng với chuỗi này.

Bạn có thể cho rằng chuỗi không trống và không bắt đầu hoặc kết thúc bằng z.

Bạn có thể sử dụng bất kỳ định dạng đầu ra hợp lý nào, ví dụ: chuỗi, ma trận, mảng 2d. Bạn có thể sử dụng bất kỳ hai giá trị nào để biểu diễn 0và 1, cho rằng bạn khai báo chúng trong câu trả lời.

Bạn có thể bỏ qua các dòng số 0 ở cuối trong đầu ra hoặc thêm các dòng số 0 ở cuối. Bạn cũng có thể thêm / bỏ qua các số 0 ở cuối mỗi dòng, miễn là tất cả các dòng có cùng độ dài trong đầu ra.

Bạn có thể trả về chuyển vị của mảng, nếu điều đó thuận tiện hơn.

Đây là mã golf , vì vậy mã ngắn nhất sẽ thắng.

Các trường hợp thử nghiệm

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

Than , 50 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sử dụng 1và 0. Giải trình:

ＵＢ0

Đặt nền, tức là bất kỳ ô chưa in nào của hình chữ nhật kèm theo đầu ra, thành 0.

≔⁺⭆χιββ

Tiền tố các chữ số cho bảng chữ cái chữ thường được xác định trước.

ＦＳ

Vòng qua chuỗi đầu vào.

¿υ

Nếu danh sách trống được xác định trước không trống ...

×0⁺⊟υ⌕βι

... Sau đó in một số 0s được cho bởi tổng số được bật ra từ danh sách và chỉ mục của ký tự hiện tại trong các chữ số và chữ cái. Xem bên dưới để biết con số đó luôn là gì.

≡ι

Chuyển qua nhân vật hiện tại.

z×⸿⁵

Nếu đó là zđầu ra 5 cỗ xe trở về, đưa chúng ta đến dải đầu ra tiếp theo.

y⊞υ⁴

Nếu đó là một y, sau đó đẩy 4đến danh sách trống được xác định trước, khiến 4+n 0s được xuất ra lần sau.

x×0³

Nếu đó là xđầu ra thì 3 0giây. (Điều này được thực hiện thông qua sự lặp lại để tránh nghĩa đen 0chạm vào xhoặc theo nghĩa đen sau đây.)

w¦00

Nếu đó là wđầu ra 2 0s. ( ¦Cần thiết để tách hai chuỗi ký tự.)

«Ｐ↓⮌⍘⌕βι²→

Mặt khác, lập chỉ mục ký tự hiện tại trong các chữ số và chữ cái, chuyển đổi thành nhị phân và in kết quả xuống ít nhất có ý nghĩa trước; sau đó di chuyển con trỏ sang phải cho cột tiếp theo.

JavaScript (ES8), 197 byte

Đưa đầu vào dưới dạng một chuỗi. Trả về một chuỗi các chuỗi có '#' và dấu cách. Đầu ra có thể bao gồm các khoảng trắng phụ (nhưng nhất quán) trên mỗi dòng.

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

Hãy thử trực tuyến! (đầu ra được chỉnh sửa)

Làm sao?

Biến toàn cầu

• Ký tự "x"được sử dụng nhiều lần, do đó, đáng lưu trữ nó vào biến x .
• Các chức năng parseIntđược sử dụng hai lần, vì vậy nó có giá trị lưu trữ nó vào biến P .
• y là chỉ số hàng, được khởi tạo thành 0 .
• w theo dõi giới hạn trên của chiều rộng được sử dụng để đệm đầu ra cuối cùng.
• o [] là mảng đầu ra, ban đầu trống.

Tiền xử lý các số không lặp lại

Đầu tiên chúng ta thay thế tất cả các mô hình "w", "x"và "yX"trong chuỗi đầu vào với số lượng thích hợp của không gian. Những không gian này sau đó sẽ được hiểu là "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
  )
)

Giải mã

Chúng tôi chia chuỗi kết quả, thêm một ký tự ban đầu "x"và lặp lại 5 lần (với i = 0 đến 4 ) trên mỗi ký tự c :

• Nếu c thấp hơn "x", chúng ta sẽ thêm mẫu tương ứng vào 5 hàng tiếp theo.

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

• Nếu c lớn hơn hoặc bằng "x", chúng ta phân bổ 5 chuỗi trống mới trong o [] và thêm 5 vào y . Điều này được kích hoạt bởi chữ cái đầu tiên "x"được thêm vào đầu chuỗi hoặc bởi bất kỳ "z"nội dung gốc nào.

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

Đệm

Cuối cùng, chúng tôi đệm từng chuỗi trong o [] với khoảng trắng để tất cả chúng có ký tự w .

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

05AB1E , 148 132 98 byte

Tôi là học sinh trung học và đây là lần đầu tiên tôi chơi golf và sử dụng 05AB1E, vì vậy các ý kiến ​​được đánh giá cao!

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

Hãy thử trực tuyến!

Hãy thử trực tuyến!

Hãy thử trực tuyến!

Lấy đầu vào là chữ hoa và xuất ra ma trận chuyển tiếp dưới dạng nhiều dòng đầu ra 1s và 0. Có thể thêm số không.

Nếu bạn muốn kiểm tra với các chuỗi chữ thường, hãy thêm uvào tiêu đề TIO.

Nếu bạn muốn đầu ra được in đẹp, hãy thêm '1'█:'0'.:vào chân trang TIO.

Giải trình

(Tôi đang gọi "hàng" và "cột" ngược lại với những gì bạn có thể mong đợi vì nó tạo ra ma trận chuyển vị)

Thuật toán cơ bản là:

1. Thay thế "yy" bằng 38 0 giây
2. Tách "y" và mở rộng 0 lần chạy.
3. Thay thế "w" và "x"
4. Chỉ ra cột dài nhất (nghĩa là chuỗi dài nhất giữa z) và đệm tất cả các cột khác sao cho chúng có độ dài đó. (Điều này là cần thiết vì cách thức hoạt động của thuật toán bên dưới)
5. Tách trên z
6. Tại thời điểm này, chuỗi đầu vào là một mảng các cột trong đó mỗi cột là một chuỗi [0-9A-V], trong đó mỗi cột có cùng độ dài.
7. Thuật toán để đưa nó vào định dạng đầu ra là
   1. Chuyển đổi các ký tự thành số bằng cách sử dụng indexOf trong chuỗi tra cứu
   2. Chuyển đổi các ký tự thành nhị phân và sau đó pad đến chiều dài 5
   3. Nếu đó là cột đầu tiên, hãy thêm dấu ngắt dòng trước số nhị phân
   4. Thêm một tiền tố vào đầu chuỗi nhị phân lưu trữ hàng và sau đó là cột của ký tự.
   5. Đẩy chuỗi nhị phân có tiền tố đến thanh ghi / biến "mảng toàn cầu" của 05AB1E
8. Sắp xếp mảng toàn cầu. Chuỗi tiền tố, xác định thứ tự sắp xếp, sẽ đảm bảo mọi thứ kết thúc theo đúng thứ tự và các ngắt dòng nằm ở đúng nơi.
9. Xóa chuỗi tiền tố khỏi mỗi phần tử của mảng toàn cục
10. Tham gia mảng với "" và in nó.

Có một số chi tiết nhỏ khác mà bạn có thể thấy dưới đây trong mã mở rộng. Tất cả mọi thứ sau các tab ở cuối dòng là một nhận xét và có thể bỏ qua. (Nhân tiện, lược đồ nhận xét này không phải là một phần của 05AB1E. Tôi đã làm theo cách này vì nó trông đẹp.) Các dòng có nhận xét bắt đầu bằng "@" là dành cho mục đích gỡ lỗi và có thể được bỏ qua mà không thay đổi đầu ra cuối cùng.

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

cảm ơn H.PWiz vì đã lưu 7 byte và ngn cho 13 17 khác.

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

Hãy thử trực tuyến!

NB: Lấy đầu vào là một chuỗi chữ hoa.

Với đầu ra được in đẹp

Giải trình

a←⎕D,⎕Aa là chuỗi '0123...89ABCD...XYZ'
'Y.|W|X'⎕R{'0'/⍨+/30 36|a⍳2↑⍵.Match}thay thế XW và Yx với số lượng tương ứng của '0's (giải thích dưới đây hơn) 35(≠⊆⊢)a⍳chuyển đổi chuỗi thành vector của indecies trong avà chia rẽ trên 35(ví dụ) 'Z'tạo ra một vector lồng nhau
↑cải vector lồng nhau thành một ma trận đệm đầu với 0s
(5/2)⊤chuyển đổi mỗi số vào một vectơ nhị phân dẫn đến ma trận 3 chiều với các vectơ nhị phân dọc theo trục chính
⊖đảo dọc theo trục chính
↓làm giảm thứ hạng của ma trận, do đó, nó sẽ
,⍉định hình lại kết quả 2 chiều cho đầu ra thích hợp

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

Perl 6 ,156 142 byte

14 byte được lưu nhờ Jo King. (Cũng đã sửa một lỗi nhỏ với phân tích cú pháp yvà thêm trình chỉnh sửa.)

Đã sửa lỗi phân tích lỗi của 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}

Hãy thử trực tuyến!

Ngắt dòng là có để làm cho văn bản phù hợp trên màn hình. Nó không phải là một phần của chương trình.

Làm thế nào nó hoạt động

Đây là một hàm ẩn danh có một chuỗi có thể thay đổi. (Điều này làm cho việc sử dụng hàm hơi kỳ dị một chút, bởi vì bạn chỉ có thể cung cấp cho nó các biến chứ không phải bằng chữ.)

Chuỗi đầu vào có trong biến $_. Chúng tôi bắt đầu bằng cách sử dụng một loạt các tuyên bố thay thế trên đó để loại bỏ tất cả các tốc ký đó cho các số 0 khác nhau. Đầu tiên, chúng ta cần sắp xếp y, bởi vì trong trường hợp yxhoặc yw, w(hoặc x) không tự nó tạo thành một tốc ký. Chúng tôi tìm kiếm y(.)( yvà một ký tự mà nó nhớ) và thay thế nó bằng 000{"0"x:36(~$0)}: ba số không được sao chép nguyên văn, sau đó chúng tôi chuyển đổi ký tự tiếp theo từ cơ sở 36 sang cơ sở 10 ( :36(~$0)) và thêm nhiều số không nữa. Sau đó, chúng tôi thay thế việc wsử dụng s:g/w/00/và xsử dụng s:g/x/000/. Cuối cùng, với s/$/z/, chúng tôi thêm mộtzvào cuối, thêm rất nhiều dòng trống vào dưới cùng. (Chúng ta sẽ thấy lý do sau.)

Phần còn lại chỉ là một tuyên bố bản đồ lớn. Chúng tôi đang lập bản đồ .split("z").map: (*~0 x.chars).comb}), là chuỗi đầu vào (không có tốc ký 0), được chia thành các dòng tại z, với mỗi dòng được đệm đầu tiên 0 x.chars(tấn số 0, cụ thể là bằng tổng chiều dài của chuỗi đầu vào) ở bên phải và sau đó được chia thành một danh sách các ký tự riêng lẻ ( .comb). Cuối cùng, chúng tôi hoán đổi nó với [Z](giảm bằng zip). Nén kết thúc ngay khi danh sách ngắn nhất bị cạn kiệt, điều này dẫn đến tất cả các dòng có cùng độ dài. (Số lượng các số 0 vô dụng ở bên phải bằng với độ dài của dòng ngắn nhất. Ngoài ra, mẹo chuyển vị này không thành công cho một "ma trận" chỉ có một hàng. Đó là lý do tại sao chúng tôi buộc phải thêm một hàng khác ở cuối trước.)

Bây giờ, chúng ta chỉ cần ánh xạ qua các hàng (cột của ma trận gốc) và thay thế từng ký tự gặp phải với 5 bit tương ứng. Điều đó được thực hiện bằng cách sử dụng :32($_)(cơ sở 32 đến cơ sở 10) .fmt("%05b")(định dạng dưới dạng chuỗi bit có chiều rộng 5, được đệm bằng số 0) .flip(đảo ngược chuỗi, vì LSB nằm ở hàng trên cùng, không phải ở dưới cùng) .comb(chia chuỗi thành danh sách nhân vật). Chúng tôi đã sử dụng .flatmap, làm phẳng danh sách kết quả (nếu không chúng tôi sẽ nhận được một danh sách các danh sách trong mỗi cột). Sự hoán vị của kết quả sau đó được trả lại ngầm.

(Tôi cảm thấy hơi tệ vì lạm dụng khả năng theo dõi các số 0 rất khó. Nhưng nó đã làm giảm số lượng người dùng khá đáng kể:.

Thạch , 66 byte

^Yowza!

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

Một liên kết đơn âm mang lại một phiên bản chuyển đổi dưới dạng một danh sách các danh sách (thêm Zvào cuối để chuyển đổi trở lại).

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm (với đầu ra được in đẹp).

Võng mạc , 203 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải pháp thay thế, cũng 203 byte:

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

y(.)
#$1

Đầu tiên xử lý các trường hợp khó xử của ylệnh. Đáng buồn là bức thư sau này được phép là một yhoặc thậm chí là một z, vì vậy chúng ta phải cẩn thận ở đây. Tất cả các phép thuật yđầu tiên được chuyển thành #s.

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

Một vòng lặp sau đó xử lý #s. Đầu tiên, a 0được chuẩn bị cho #. Nếu đây là một #0thì nó được thay đổi để 000hoàn thành thao tác, nếu không thì ký tự sau #bị giảm và vòng lặp lặp lại cho đến khi tất cả các #s được xử lý.

w
000
x
00

Sửa lỗi ws và xs.

z
¶

Chia trên các dòng mới. ( S`zcũng hoạt động với cùng số byte.)

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

Tạo 5 bản sao của mỗi dòng, sau đó thực hiện chuyển đổi nhị phân bằng cách ánh xạ các chữ cái với bit thích hợp #và xóa bit đó, trong khi các chữ cái khác trở thành khoảng trắng. Các bit được xử lý theo thứ tự 16, 8, 4, 2, và sau đó bản dịch cuối cùng xử lý xóa 2bit và chuyển đổi 1bit cùng một lúc. (Phiên bản thay thế làm cho mỗi bản sao riêng lẻ có chi phí nhiều byte hơn nhưng chúng được lưu vì việc xử lý bit được đơn giản hóa.)

P`.+

Pad tất cả các dòng đến cùng một chiều dài.

Python 2 , 249 244 byte

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

Hãy thử trực tuyến!

5 byte được lưu bởi Jonathan Frech .

JavaScript (ES8), 192 byte

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

Trả về chuyển vị ... sau đó được phản ánh qua trục dọc; cho tôi biết nếu điều đó làm mất hiệu lực mục này. Đầu ra là một chuỗi các chuỗi chứa 0s và 1s.

Hãy thử trực tuyến!

Giải trình

Đối với mỗi ký tự c, k+1ước tính số lượng hàng cần sửa đổi. k = "wxy".search(c) + 1;, trong đó searchphương thức trả về chỉ mục hoặc -1. ksau đó được giảm cho đến khi đạt -1được bằng cách kiểm tra ~k--giá trị trung thực.

Nếu ký tự hiện tại là "y", hãy đặt cờ sao cho giá trị cơ sở-36 của ký tự tiếp theo - 1 trở thành giá trị cho k.

Khi gặp "z", chuỗi pad sang trái, tăng số lượng pad thêm 5và đặt lại chỉ mục mảng thành 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 byte

Cài đặt splitgói: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