Viết một khối mã vuông rộng N ký tự và cao N ký tự, cho một số nguyên dương N.

Chẳng hạn, N của bạn có thể là 5 và khối trông như thế này:

ThisI
sMy5B
y5Cod
eBloc
kOkay

Khối này cần phải hành xử như sau:

1. Khi hàng trên cùng được trích xuất và chạy như một chương trình, văn bản chính xác rowcần được in ra thiết bị xuất chuẩn.

   Ví dụ, ThisIsẽ in row.

2. Khi cột bên trái được trích xuất và chạy như một chương trình, văn bản chính xác colcần được in ra thiết bị xuất chuẩn.

   Ví dụ, Tsyeksẽ in col.

3. Khi đường chéo chính từ góc trên bên trái đến góc dưới bên phải được trích xuất và chạy dưới dạng chương trình, văn bản chính xác diacần được in ra thiết bị xuất chuẩn.

   Ví dụ, TMCoysẽ in dia.

4. Khi toàn bộ khối được chạy dưới dạng một chương trình, bao gồm các dòng mới (với một dòng mới theo dõi tùy chọn), văn bản chính xác blkcần được in ra thiết bị xuất chuẩn.

   Ví dụ,

   ThisI
   sMy5B
   y5Cod
   eBloc
   kOkay
   

   sẽ in blk.

Chi tiết

• Tất cả bốn chương trình được chạy trong cùng một ngôn ngữ lập trình.
• Các ký tự N ² trong khối ban đầu có thể là bất cứ thứ gì ngoại trừ các đầu cuối dòng .
• Nếu ngôn ngữ của bạn không có thiết bị xuất chuẩn, bạn có thể sử dụng một phương thức đầu ra phổ biến khác. Nó phải là cùng một phương pháp trên tất cả bốn chương trình.

Bài nộp có khối ban đầu chứa ít ký tự riêng biệt nhất (không tính dòng mới) sẽ thắng. Tiebreaker đi đến trình với N nhỏ hơn

> <> (Cá) , 3 ký tự duy nhất (N = 2000)

Mã sử ​​dụng 1và -để đặt các số tùy ý trên ngăn xếp và pđể (tự-) sửa đổi mã dựa trên 3 số trên cùng của ngăn xếp. Ví dụ: Đặt một !vị trí 0 0sẽ trông giống như 003b*pbình thường> <> và với p1-nó trở thành 111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--11-11-p.

Sau khi sửa đổi, con trỏ lệnh (IP) bao quanh mã và chạy phần được sửa đổi. Trong trường hợp "chặn", IP được chuyển hướng để sửa đổi thêm (sau đó được điều chỉnh lại) để khác với trường hợp "hàng". Trong trường hợp "hàng", hai chuyển hướng giống nhau xảy ra nhưng không có mã ở giữa chúng để chúng không có hiệu lực.

Mã được tạo cuối cùng cho 4 trường hợp (bỏ qua các p1-phần không thay đổi ):

row:      "wor"\ooo;

column:   "loc"ooo;

diagonal: "dia"ooo;

block:    "wor"\"klb"ooo;

Kích thước mã là 4 MB và mã có thể truy cập ở đây . (Không có khó khăn để chạy nó.)

Chương trình tạo python3 có thể truy cập ở đây .

CJam, 13 12 ký tự duy nhất, N = 5

"row"
cd;"a
oaiaa
l"aa;
"blk"

Càng thẳng về phía trước

CẬP NHẬT : Chuyển đổi không gian thành a(không có op trong trường hợp này) như được chỉ ra bởi Runner112

Dùng thử trực tuyến tại đây

Bash, 19 ký tự duy nhất, N = 19

trap echo\ row exit
t=t trap exit      
t=t echo blk       
exit               
=                  
t    e             
      c            
e      h           
c       o          
h                  
o         d        
           i       
c           a      
o                  
l                  

• Hàng đầu tiên là trap echo\ row exit. Điều này gây ra echo rowđược thực thi khi tập lệnh thoát (chỉ dòng đầu tiên)
• Cột đầu tiên là ttt=t echo col
• Đường chéo là t=tt echo dia
• Toàn bộ khối hoạt động bằng cách hủy trình xử lý EXIT được thiết lập trong dòng đầu tiên, sau echo blkđó thoát.

> <> , 14 ký tự duy nhất, N = 10

"wor"\ooo;
     "    
l a  k    
o  i l    
c   db    
"    "    
o    oo   
o    o o  
o    o  o 
;    ;   ;

Khá đơn giản trong một ngôn ngữ 2D. Phần khó khăn duy nhất là chúng ta cần \phân biệt giữa rowvà blk.

Brainfuck, 2 ký tự duy nhất, N = 378

Với khả năng uốn cong nhẹ của quy tắc.

Chương trình này có quy mô lớn, vì vậy đây là một liên kết đến nó trên Pastebin .

Các row, colvà diacác chương trình là đơn giản. Họ chỉ cần tăng ô byte cho đến khi đạt được mã ASCII đúng và sau đó xuất ra. Nếu chữ cái đã được chuyển, nó sẽ tăng cho đến khi ô tràn ra để nó có thể bắt đầu lại ở 0.

Các blkchương trình là nơi mà các quy tắc uốn nhẹ xảy ra. Để in "văn bản chính xác blk" như được hỏi trong thử thách, không gian được sử dụng (mã ASCII 8), yêu cầu bảng điều khiển / thiết bị đầu cuối hiển thị để hỗ trợ nó. Bất cứ khi nào giá trị sai lầm từ row/ col/ diachương trình được in, tôi đảm bảo chúng sẽ bị xóa bằng cách xuất một vài mã điều khiển backspace. Để đơn giản hóa mọi thứ, tôi đã đảm bảo rằng tất cả các giá trị sai lầm xuất ra tại một thời điểm là một phần của phạm vi ASCII có thể in được.

C (gcc) , 26 ký tự duy nhất, N = 29

*w;main(){printf(w?w:"row");}
ww;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;/*;;;;;;;;;;;;;;;;;;;;;;;;
m;;m;;;;;;;;;;;;;;;;;;;;;;;;;
a;;;a;;;;;;;;;;;;;;;;;;;;;;;;
i;;;;i;;;;;;;;;;;;;;;;;;;;;;;
n;;;;;n;;;;;;;;;;;;;;;;;;;;;;
(;;;;;;(;;;;;;;;;;;;;;;;;;;;;
);;;;;;;);;;;;;;;;;;;;;;;;;;;
{;;;;;;;;{;;;;;;;;;;;;;;;;;;;
p;;;;;;;;;p;;;;;;;;;;;;;;;;;;
r;;;;;;;;;;r;;;;;;;;;;;;;;;;;
i;;;;;;;;;;;i;;;;;;;;;;;;;;;;
n;;;;;;;;;;;;n;;;;;;;;;;;;;;;
t;;;;;;;;;;;;;t;;;;;;;;;;;;;;
f;;;;;;;;;;;;;;f;;;;;;;;;;;;;
(;;;;;;;;;;;;;;;(;;;;;;;;;;;;
";;;;;;;;;;;;;;;;";;;;;;;;;;;
c;;;;;;;;;;;;;;;;;d;;;;;;;;;;
o;;;;;;;;;;;;;;;;;;i;;;;;;;;;
l;;;;;;;;;;;;;;;;;;;a;;;;;;;;
";;;;;;;;;;;;;;;;;;;;";;;;;;;
);;;;;;;;;;;;;;;;;;;;;);;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
};;;;;;;;;;;;;;;;;;;;;;;};;*/
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;*w="blk";

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

Ruby, 24 ký tự độc đáo, N = 17

trap(0){$><<:row}
rr=a=:blk;%;00000
a0a00000000000000
p00p0000000000000
(000(000000000000
00000000000000000
)00000)0000000000
{000000{000000000
$0000000$00000000
>00000000>0000000
<000000000<000000
<0000000000<00000
:00000000000:0000
c000000000000d000
o0000000000000i00
l;;trap(0){$><<a;
};000000000000;{}

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