Chỉ sử dụng ASCII có thể in (mã hex 20 đến 7E), viết chương trình lõi N × N vuông mà không có nhận xét được bao quanh bởi 4 lớp nữa , tạo ra chương trình vuông (N + 8) × (N + 8) (N> 0) . Với N = 3, bố cục (được thay thế bằng mã thực tế) trông như thế này:

44444444444
43333333334
43222222234
43211111234
4321CCC1234
4321CCC1234
4321CCC1234
43211111234
43222222234
43333333334
44444444444

• Chữ C đại diện cho chương trình 3 × 3 cốt lõi.
• 1 `đại diện cho lớp đầu tiên, 2 'đại diện cho lớp thứ hai, v.v.

Chương trình luôn lấy một chuỗi các số nguyên được phân tách bằng dấu cách, chẳng hạn như 0 -1 31 -1 2 2 2thông qua stdin hoặc tương tự (nó chỉ nên là số đơn giản, không có dấu ngoặc kép hoặc dấu ngoặc hoặc bất cứ thứ gì). Đầu ra phụ thuộc vào phần nào của bố cục đã được chạy.

Có năm cách để chạy chương trình (dòng mới được bao gồm trong quá trình chạy). Mỗi người làm một cái gì đó khác nhau trong danh sách:

1. Chỉ chạy lõi:

   CCC
   CCC
   CCC
   

   Điều này sẽ tính toán tối đa các giá trị tuyệt đối của các thành phần danh sách đầu vào và in COREtrên một dòng mới nhiều lần. Nếu tối đa là 0 thì không có gì là đầu ra (một dòng mới là tốt).

   • Đầu ra cho 0 -1 31 -1 2 2 2sẽ là

     CORE
     CORE
     ...
     

     31 lần.

2. Chạy lõi với lớp 1:

   11111
   1CCC1
   1CCC1
   1CCC1
   11111
   

   Điều này đưa giá trị trung bình (trung bình số học ) của các giá trị danh sách thành độ chính xác của dấu phẩy động chuẩn.

   • Đầu ra cho 0 -1 31 -1 2 2 2sẽ là 35/7 = 5( 5.0là tốt).

3. Chạy lõi với lớp 1 và 2:

   2222222
   2111112
   21CCC12
   21CCC12
   21CCC12
   2111112
   2222222
   

   Điều này xuất ra một danh sách ngăn cách không gian của danh sách đầu vào đảo ngược.

   • Đầu ra cho 0 -1 31 -1 2 2 2sẽ là 2 2 2 -1 31 -1 0.

4. Chạy lõi với các lớp 1, 2 và 3 (mô hình nên rõ ràng).
   Điều này xuất ra một danh sách ngăn cách không gian của danh sách đầu vào được sắp xếp.

   • Đầu ra cho 0 -1 31 -1 2 2 2sẽ là -1 -1 0 2 2 2 31.

5. Chạy lõi với các lớp 1, 2, 3 và 4.
   Điều này tạo ra một danh sách được phân tách bằng dấu cách của danh sách đầu vào với các mục trùng lặp được loại bỏ, thứ tự không thành vấn đề.

   • Đầu ra cho 0 -1 31 -1 2 2 2có thể -1 0 2 31.

Tất cả đầu ra là stdout hoặc một sự thay thế tương tự.

Chỉ có 5 kết hợp bố trí có hành vi được chỉ định.

Ghi chú

• Nhận xét không được phép trong lõi hoặc các lớp hoặc kết hợp của chúng. Mã không có hoặc không có gì mang tính xây dựng không được tính là một nhận xét.
• Hãy nhớ rằng lõi có thể có bất kỳ kích thước N × N (dương) nào, nhưng các lớp chỉ dày một ký tự.
• Bạn có thể giả sử đầu vào không có khoảng trắng ở đầu hoặc cuối và chính xác một khoảng trắng giữa các số. Nó sẽ luôn chứa ít nhất một số. (Danh sách đầu ra cũng nên được định dạng như thế này.)
• Bạn có thể giả sử danh sách và các tính toán cần thiết cho đầu ra sẽ không có giá trị tràn (hoặc tràn) số nguyên của bạn (miễn là mức tối đa của chúng là hợp lý như 2 ¹⁶ ).

Chấm điểm

Viết chương trình này thông thường sẽ dễ dàng. Viết nó với một lõi nhỏ là khó.

Chương trình có kích thước lõi nhỏ nhất (N nhỏ nhất) sẽ thắng. Trong trường hợp quan hệ, người chiến thắng là chương trình đầy đủ (hình vuông (N + 8) × (N + 8)) với ít ký tự riêng biệt nhất (không tính dòng mới).

Vui lòng báo cáo giá trị N của bạn ở đầu câu trả lời của bạn.

Các ký tự độc đáo của CJam, N = 5, 27 (26)

Đó là 26 ký tự nếu tôi không đếm khoảng trắng. Chương trình thực sự có thể được chuyển đổi thành một không sử dụng khoảng trắng, chỉ bằng cách lấp đầy tất cả các khoảng trống bằng no-op (ví dụ: _;sao chép phần tử ngăn xếp trên cùng và sau đó loại bỏ hoặc sắp xếp lại mảng đó), nhưng nó sẽ chỉ phân tâm từ mã thực tế.

l~]_|S*      
{l~]$S*      
 {l~]W%S*    
  {l~]_,\    
   {l~]{z    
    }%$W=    
    "CORE    
    "*       
         }   
   ;:+d\/ }  
  ;        } 
 ;          }
;            

Kiểm tra nó ở đây.

Cốt lõi là

l~]{z
}%$W=
"CORE
"*

(Cộng với một dòng trống.)

Tôi khá chắc chắn rằng điều đó N = 4không thể được thực hiện ở CJam (và tôi chắc chắn rằng Dennis sẽ thuyết phục tôi bằng cách khác: D). Trên đây có 17 ký tự, và mặc dù có thể giảm xuống còn 16 ký tự (ví dụ: nếu CJam không có lỗi để sặc :z, điều này đòi hỏi {z}%hoặc bằng cách sử dụng ARGV), tôi không nghĩ bạn có thể phù hợp với nó trong bố trí mà không giới thiệu một ngắt dòng trong CORE.

Tất cả các triển khai là các giải pháp rất đơn giản cho các nhiệm vụ nhất định. Tất cả đều bắt đầu bằng l~]việc đọc STDIN, đánh giá nó và đặt nó vào một mảng.

Lớp trước luôn được bao quanh {...}, làm cho nó trở thành một khối không được thực thi tự động. Và thay vì thực thi nó, tôi chỉ loại bỏ nó khỏi ngăn xếp với ;, vì vậy không có lớp nào phụ thuộc vào mã trong lớp trước. Trong Lớp 1, mã không phù hợp với dòng đầu tiên, vì vậy tôi tiếp tục mã đó sau khi loại bỏ khối lõi.

Bây giờ cho các chương trình thực tế:

• Cốt lõi:

  {z}%$W="CORE
  "*
  

  Ánh absxạ vào danh sách, sắp xếp nó, lấy phần tử cuối cùng, lặp lại CORE(và ngắt dòng) nhiều lần.

• Lớp 1:

  _,\:+d\/
  

  Sao chép danh sách, lấy độ dài, hoán đổi các phần tử ngăn xếp, lấy tổng, chuyển sang double, hoán đổi các phần tử ngăn xếp, chia. Tôi nghĩ rằng điều này có thể ngắn hơn, nhưng không có động lực để làm như vậy.

• Lớp 2:

  W%S*
  

  Đảo ngược mảng, riffle với khoảng trắng.

• Lớp 3:

  $S*
  

  Sắp xếp các mảng, riffle với không gian.

• Lớp 4:

  Nhân đôi, thiết lập liên minh, riffle với khoảng trắng.

Một số tối ưu hóa khác cũng có thể, như sử dụng lại ;và *SLớp 2, nhưng một lần nữa, nhưng nó không ảnh hưởng đến điểm số.

Python 2 - N = 17, 53 ký tự

Ồ tôi thích những thách thức về bố cục nguồn với Python ...

i=4                     ;
ii=3                    ;
iii=2                   ;
iiii=1                  ;
iiiii=0;R=raw_input     ;
iiiii;w=R().split()     ;
iiiii;n=map(int,w)      ;
iiiii;S=set(n);M=max    ;
iiiii;s=sorted(n)       ;
iiiii;J="\n".join       ;
iiiii;j=" ".join        ;
iiiii;k=M(map(abs,n))   ;
iiiii;A=J(["CORE"]*k)   ;
iiiii;B=sum(n)/len(n)   ;
iiiii;C=j(w[::-1])      ;
iiiii;D=j(map(str,s))   ;
iiiii;E=j(map(str,S))   ;
iiiii;P=A,B,C,D,E       ;
iiiii;print P[i]        ;
iiiii;" /__----__\  "   ;
iiiii;"|/ (')(') \| "   ;
iiii;"  \   __   /  "   ;
iii;"   ,'--__--'.   "  ;
ii;"   /    :|    \   " ;
i;"   (_)   :|   (_)   ";

Vẫn còn một số khoảng trắng chưa sử dụng.

Tôi vẫn có thể cải thiện số lượng ký tự duy nhất, nhưng tôi sẽ gắn bó với khả năng đọc tốt hơn - nếu có bất kỳ thứ gì.

Chỉnh sửa: Oh, đó là Stan một lần nữa !

Python 3: N = 11, 40 ký tự riêng biệt

if 1:              
 if 1:             
  if 1:            
   if 1:           
    p=print;R=0    
    a=input()      
    b=a.split()    
    m=map;a=abs    
    E=max;l=len    
    n=m(int,b);    
    C=['CORE']     
   "R=E(m(a,n))"   
   OO=C*R;s=sum    
   "x='\n'.join"   
   "p(x(O))    "   
  "p(s(n)/l(b)) "  
 "p(*b[::-1])    " 
"p(*sorted(n))    "
p(*set(n))         

Cảm ơn @Falko vì đã là nàng thơ của tôi. Điều này hoạt động, bởi vì Python không tạo ra một phạm vi mới cho mỗi câu lệnh if, vì vậy các biến vẫn tồn tại trong các printcâu lệnh bên ngoài . Một điều khó chịu là một mapđối tượng (trong trường hợp của chúng tôi n) chỉ có thể được sử dụng một lần. Vì vậy, cần phải xâu chuỗi R=E(...)dòng, nhưng sau đó Rkhông được xác định. Vì vậy, tôi đã may mắn khi có bốn khoảng trống còn lại trong dòng đầu tiên!

Đầu ra có thể được giải quyết bằng cách cung cấp nhiều yếu tố *b[::-1]thay vì danh sách. Sự thay thế ' '.join(...)sẽ là quá dài.

C (gcc) , N = 15, 47 ký tự duy nhất

Giả định sizeof(int) == 4và sizeof(int*) >= sizeof(int).

;                     ;
 ;                   ; 
  ;                 ;  
   ;           float   
    s;c(a,b)int*a,*    
    b;{b=*b-*a;}i,n    
    ,*f;*q,*R,C,E ;    
    main(a){for(;0<    
    scanf("%i",&a);    
    i=i<abs(a)?a:i,    
    s+=f[n-!0]=a)f=    
    realloc(f,++n*4    
    );qsort(f,n*C,4    
    ,c);for(i=q?R?n    
    :!0:i;i--;a=f[i    
    ])!E|n-i<2|a!=f    
    [i]&&printf(q?R    
    ?R:q:"CORE\n",!    
    q+R?f[i]:s/n);}    
   ;*q="%f";       ;   
  ;*R="%.0f ";      ;  
 ;C=!0;              ; 
;E=!0;                ;

4 lớp

3 lớp

2 người chơi

1 lớp

Cốt lõi

Bùa mê , N = 9 N = 8, 38 ký tự

/ o/\  \     \S\
" //RiU\      \}
@            q "
"        }+1\r @
}   ^U \    {q "
     \{\?)}\+  }
  o\/'|A:{:/R' S
 //r/Ril2=?\?R :
   ,A~/"OC"/=? {
   @| \"RE"\3= =
 D$\' /rqka/l2S?
    i \*@   il\/
   'R1i     Ui ~
 R$/Rak      U \
 ?!D  Rlril1-{=
R   R: }S:{=?\~

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

Hóa ra tôi đã sai , tôi quên rằng tôi đã có olệnh rt rõ ràng , do đã gặp phải vấn đề "sắp xếp danh sách" trước đây. Tuy nhiên, điều này làm giới hạn kích thước của các đầu vào mà chương trình cuối cùng có thể lấy (8 giá trị) do chi phí nội bộ của lệnh sort. Một tinh chỉnh nhỏ có thể tăng kích thước đầu vào lên 13 với giá 1 ký tự duy nhất hoặc 19 cho hai ký tự duy nhất (tất cả các ký tự bổ sung nằm trên Lớp 1 và được thêm cùng lúc, nhưng dung lượng tăng của ngăn xếp IP không cần thiết cho đến khi Lớp 3, như C, L1 và L2 có thể thực hiện các phép tính của chúng mà không giữ toàn bộ đầu vào trong bộ nhớ).

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

Lớp 1: Dùng thử trực tuyến!

Lớp 2: Dùng thử trực tuyến!

Lớp 3: Dùng thử trực tuyến!

Lớp 4: Dùng thử trực tuyến!

Việc nén thêm rất khó xảy ra, do không gian nhỏ hơn đòi hỏi phải tăng số lượng ký tự điều khiển luồng. Tôi tìm thấy một sự sắp xếp đưa ra 9 khoảng trống trong chương trình cốt lõi, nhưng điều đó là không đủ, vì chúng ta cần (một sự sắp xếp chính xác) 15.

Giải thích làm thế nào bất kỳ chương trình nào trong số này hoạt động là khó khăn nếu không có bản đồ trực quan về con đường mà IP đi, rất khó khăn và tốn thời gian để xây dựng. Điểm vào ban đầu là góc trên bên trái của chương trình Core ( ^) cho phép kiểm soát luồng nhất quán khi các lớp mới được thêm vào, vì mỗi lớp có cơ hội chặn trên dòng mới được thêm ở trên cùng hoặc dưới cùng.

Các lớp 1 và 2 chặn ở phía dưới (để dòng trên cùng trống cho các lớp trong tương lai) và sau đó thực hiện các thao tác của chúng dọc theo cạnh bên phải (một vòng được sắp xếp theo chiều dọc). Lớp 1 hơi quá dài và cũng có 3 ký tự dọc theo cạnh trên, nhưng bộ phản xạ chéo ( \) ở trên cùng bên phải sẽ sắp xếp lại IP với lần lặp lặp tiếp theo.

Lớp 3 chặn dọc theo cạnh trên cùng để lấy giá trị đầu vào đầu tiên trước khi chuyển hướng đến cạnh dưới (Lớp 4 để lại một NOP trong cột này trên dòng dưới cùng của nó) và đọc toàn bộ đầu vào bằng cách sử dụng vòng lặp cạnh dưới, chuyển hướng trên Xuống lệnh ( D) ở phía dưới bên trái. Từ đó, IP bị trả lại một vài lần trước khi kết thúc $vòng lặp đầu ra ( ) ở phía dưới bên trái để phân tách các giá trị.

Lớp 4 sử dụng tất cả các chức năng của lớp 3 (do đó là khoảng trống), nhưng chặn ở cạnh trên mới của nó (phía trên bên trái) để thực hiện chức năng của chính nó khi kết thúc quá trình xử lý của Lớp 3. Góc trên bên trái chèn một chuỗi "@"được sử dụng để biểu thị phần cuối của mảng trước khi vào vòng xử lý dọc phía dưới. Nếu tìm thấy một giá trị trùng lặp, nó sẽ xuất hiện ( ~, góc dưới bên phải) nếu không, nhánh được lấy sẽ tiêu thụ cạnh bên phải mới. Nhánh bên này kiểm tra xem đã kết thúc mảng hay chưa, và nếu vậy, hãy thoát ra và đi đến vòng lặp đầu ra được phân tách bằng không gian từ Lớp 3. Nếu không, hãy sử dụng khoảng trống trên Lớp 3 để quay lại chính vòng lặp.