Hanya menggunakan ASCII yang dapat dicetak (kode hex 20 hingga 7E), tulis program inti N × N persegi tanpa komentar yang dikelilingi oleh 4 lapisan lagi , membuat program persegi (N + 8) × (N + 8) persegi (N> 0) . Untuk N = 3 tata letak (harus diganti dengan kode aktual) terlihat seperti ini:

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

• C mewakili program inti 3 × 3.
• 1's mewakili lapisan pertama, 2 mewakili lapisan kedua, dll.

Program ini selalu mengambil string integer yang dipisahkan oleh ruang seperti 0 -1 31 -1 2 2 2via stdin atau sejenisnya (seharusnya hanya berupa angka polos, tanpa tanda kutip atau tanda kurung atau apa pun). Keluaran tergantung pada bagian tata letak mana yang dijalankan.

Ada lima cara untuk menjalankan program (baris baru termasuk dalam proses). Masing-masing melakukan sesuatu yang berbeda pada daftar:

1. Jalankan saja intinya:

   CCC
   CCC
   CCC
   

   Ini menghitung maksimum dari nilai absolut elemen daftar input, dan mencetak COREpada baris baru yang berkali-kali. Jika maks adalah 0, tidak ada output (baris baru baik-baik saja).

   • Output untuk 0 -1 31 -1 2 2 2menjadi

     CORE
     CORE
     ...
     

     31 kali.

2. Jalankan inti dengan layer 1:

   11111
   1CCC1
   1CCC1
   1CCC1
   11111
   

   Ini menghasilkan rata-rata (rata-rata aritmatika ) dari nilai daftar ke presisi floating point standar.

   • Output untuk 0 -1 31 -1 2 2 2akan menjadi 35/7 = 5( 5.0baik-baik saja).

3. Jalankan inti dengan layer 1 dan 2:

   2222222
   2111112
   21CCC12
   21CCC12
   21CCC12
   2111112
   2222222
   

   Ini menghasilkan daftar yang dipisahkan ruang dari daftar input yang dibalik.

   • Output untuk 0 -1 31 -1 2 2 2menjadi 2 2 2 -1 31 -1 0.

4. Jalankan inti dengan layer 1, 2, dan 3 (polanya harus jelas).
   Ini menghasilkan daftar yang dipisahkan oleh ruang dari daftar input yang diurutkan.

   • Output untuk 0 -1 31 -1 2 2 2menjadi -1 -1 0 2 2 2 31.

5. Jalankan core dengan layer 1, 2, 3, dan 4.
   Ini menampilkan daftar daftar input yang terpisah dengan duplikat yang dihapus, urutannya tidak menjadi masalah.

   • Output untuk 0 -1 31 -1 2 2 2bisa -1 0 2 31.

Semua output adalah stdout atau alternatif serupa.

Hanya 5 kombinasi tata letak ini yang memiliki perilaku tertentu.

Catatan

• Komentar tidak diperbolehkan di inti atau lapisan atau kombinasi keduanya. Kode yang merupakan no-op atau tidak konstruktif tidak dihitung sebagai komentar.
• Ingat bahwa inti dapat memiliki dimensi (positif) N × N, tetapi lapisannya hanya satu karakter.
• Anda dapat berasumsi bahwa input tidak memiliki spasi awal atau spasi dan tepat satu spasi di antara angka. Itu akan selalu mengandung setidaknya satu nomor. (Daftar output harus diformat seperti ini juga.)
• Anda dapat mengasumsikan daftar dan perhitungan yang diperlukan untuk output tidak akan memiliki nilai yang melimpah (atau melemahkan) bilangan bulat Anda (selama maks mereka adalah sesuatu yang masuk akal seperti 2 ¹⁶ ).

Mencetak gol

Menulis program ini secara normal akan mudah. Menulisnya dengan inti kecil itu sulit.

Program dengan ukuran inti terkecil (N terkecil) menang. Dalam hal ikatan, pemenangnya adalah program lengkap (kotak (N + 8) × (N + 8)) dengan karakter berbeda paling sedikit (tidak termasuk baris baru).

Silakan laporkan nilai N Anda di bagian atas jawaban Anda.

CJam, N = 5, 27 (26) karakter unik

Ini 26 karakter jika saya tidak menghitung spasi. Program ini sebenarnya dapat dikonversi menjadi yang tidak menggunakan spasi, hanya dengan mengisi semua ruang kosong tanpa-ops (misalnya _;yang menduplikasi elemen tumpukan atas dan kemudian membuang, atau dengan mengurutkan array berulang-ulang), tetapi hanya akan mengalihkan perhatian dari kode yang sebenarnya.

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

Uji di sini.

Intinya adalah

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

(Ditambah garis kosong.)

Saya cukup yakin itu N = 4tidak dapat dilakukan di CJam (dan saya yakin Dennis akan meyakinkan saya sebaliknya: D). Di atas memiliki 17 karakter, dan walaupun dimungkinkan untuk menurunkannya menjadi 16 (misalnya jika CJam tidak memiliki bug untuk dicek :z, yang memerlukan {z}%, atau dengan menggunakan ARGV), saya tidak berpikir Anda dapat menyesuaikannya dalam tata letak tanpa memperkenalkan jeda baris di dalamCORE .

Semua implementasi adalah solusi yang sangat mudah untuk tugas-tugas yang diberikan. Semuanya dimulai dengan l~]yang membaca STDIN, mengevaluasinya, dan meletakkannya dalam sebuah array.

Lapisan sebelumnya selalu dikelilingi {...}, yang membuatnya menjadi blok yang tidak dieksekusi secara otomatis. Dan alih-alih menjalankannya, saya hanya membuangnya dari tumpukan ;, jadi tidak ada lapisan yang bergantung pada kode di lapisan sebelumnya. Di Layer 1, kode tidak masuk ke baris pertama, jadi saya melanjutkannya setelah membuang blok inti.

Sekarang untuk program aktual:

• Inti:

  {z}%$W="CORE
  "*
  

  Peta abske daftar, sortir, ambil elemen terakhir, ulangi CORE(dan satu baris) yang berkali-kali.

• Lapisan 1:

  _,\:+d\/
  

  Gandakan daftar, ambil panjangnya, tukar elemen tumpukan, dapatkan jumlah, pilih untuk double, tukar elemen tumpukan, bagi. Saya pikir ini bisa lebih pendek, tetapi tidak ada insentif untuk melakukannya.

• Lapisan 2:

  W%S*
  

  Membalikkan array, jepit dengan spasi.

• Layer 3:

  $S*
  

  Sortir array, riffle dengan spasi.

• Layer 4:

  Gandakan, ambil set union, riffle dengan spasi.

Beberapa optimisasi lain juga dimungkinkan, seperti menggunakan kembali ;dan *Sdari Layer 2, tetapi sekali lagi, tetapi itu tidak mempengaruhi skor.

Python 2 - N = 17, 53 karakter

Oh, aku suka tantangan sumber-tata letak dengan 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;"   (_)   :|   (_)   ";

Masih ada beberapa spasi putih yang tidak digunakan.

Saya masih bisa meningkatkan jumlah karakter yang unik, tapi saya akan tetap dengan keterbacaan yang lebih baik - jika ada sama sekali.

Sunting: Oh, ini Stan lagi !

Python 3: N = 11, 40 karakter berbeda

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

Terima kasih kepada @Falko karena telah menjadi muse saya. Ini berfungsi, karena Python tidak membuat ruang lingkup baru untuk setiap pernyataan if, sehingga variabel tetap ada di printpernyataan luar . Satu hal yang mengganggu adalah bahwa suatu mapobjek (dalam kasus kami n) dapat digunakan hanya sekali. Jadi itu perlu untuk merangkai R=E(...)garis, tetapi kemudian Rtidak didefinisikan. Karena itu saya beruntung ada empat ruang tersisa di baris pertama!

Outputnya dapat diselesaikan dengan menyediakan beberapa elemen, *b[::-1]bukan daftar. Alternatifnya ' '.join(...)akan terlalu lama.

C (gcc) , N = 15, 47 karakter unik

Asumsi sizeof(int) == 4dan 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 Layers

3 lapisan

2 lapisan

1 lapisan

Inti

Pesona Rise , N = 9 N = 8, 38 Karakter

/ 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:{=?\~

Cobalah online!

Ternyata saya salah , saya lupa saya sudah memiliki operintah rt eksplisit , karena telah mengalami masalah "urutkan daftar" sebelumnya. Ini, bagaimanapun, membatasi ukuran input yang dapat diambil oleh program akhir (nilai 8) karena biaya internal dari perintah sortir. Tweak sedikit dapat meningkatkan ukuran input ke 13 dengan biaya 1 karakter unik atau ke 19 untuk dua karakter unik (semua karakter tambahan ada di Layer 1 dan ditambahkan pada saat yang sama, tetapi peningkatan kapasitas tumpukan IP tidak diperlukan hingga Layer 3, karena C, L1, dan L2 dapat melakukan perhitungannya tanpa menahan seluruh input dalam memori).

Inti: Coba online!

Layer 1: Cobalah secara online!

Layer 2: Cobalah secara online!

Layer 3: Cobalah online!

Layer 4: Cobalah secara online!

Kompresi lebih lanjut sangat tidak mungkin, karena ruang yang lebih kecil mengharuskan peningkatan jumlah karakter kontrol aliran. Saya menemukan pengaturan yang memberikan 9 ruang kosong di program inti, tetapi itu tidak cukup, seperti yang kita butuhkan (diatur dengan benar) 15.

Menjelaskan bagaimana salah satu dari program ini bekerja sulit tanpa peta visual dari jalur IP, yang rumit dan memakan waktu untuk membangun. Titik masuk awal adalah sudut kiri atas program Core ( ^) yang memungkinkan untuk kontrol aliran yang konsisten ketika lapisan baru ditambahkan, karena setiap lapisan memiliki kesempatan untuk menyadap garis yang baru ditambahkan di bagian atas atau bawah.

Lapisan 1 dan 2 memotong di bagian bawah (sehingga garis atas tetap kosong untuk lapisan masa depan) dan kemudian melakukan operasi mereka di sepanjang tepi kanan (loop diatur secara vertikal). Layer 1 agak terlalu panjang dan membutuhkan 3 karakter di sepanjang tepi atas juga, tetapi reflektor diagonal ( \) di kanan atas menyelaraskan IP dengan iterasi loop berikutnya.

Layer 3 memotong di sepanjang tepi atas untuk meraih nilai input pertama sebelum mengarahkan ke tepi bawah (Layer 4 meninggalkan NOP di kolom ini di garis bawahnya) dan membaca input penuh menggunakan loop tepi bawah, mengarahkan pada Bawah command ( D) di kiri bawah. Dari sana IP memantul beberapa kali sebelum berakhir di $loop output ( ) di kiri bawah untuk memisahkan nilai-nilai.

Layer 4 menggunakan semua fungsionalitas layer 3 (karena itu ruang kosong), tetapi memotong pada tepi atas baru sendiri (kiri atas) untuk melakukan fungsionalitasnya sendiri pada akhir pemrosesan Layer 3. Sudut kiri atas menyisipkan string "@"yang digunakan untuk menunjukkan akhir array sebelum memasukkan loop pemrosesan di sepanjang bagian bawah. Jika nilai duplikat ditemukan, itu muncul ( ~, sudut kanan bawah) jika tidak cabang diambil yang mengkonsumsi tepi kanan baru. Cabang samping ini memeriksa untuk melihat apakah akhir array telah tercapai, dan jika demikian, keluar dan menuju ke loop keluaran yang dipisahkan spasi dari Layer 3. Jika tidak, gunakan ruang kosong pada Layer 3 untuk kembali ke main. lingkaran.