Yalnızca yazdırılabilir ASCII (altıgen kodlar 20 ila 7E) kullanarak, 4 katmanla çevrili yorumlar içermeyen bir kare N × N çekirdek programı yazın , (N + 8) × (N + 8) kare programı (N> 0) oluşturun . N = 3 için düzen (gerçek kodla değiştirilecek) şöyle görünür:

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

• C'ler çekirdek 3 x 3 programını temsil eder.
• 1'ler birinci katmanı, 2'ler ikinci katmanı vb. Temsil eder.

Program her zaman 0 -1 31 -1 2 2 2stdin veya benzerleri gibi bir boşlukla ayrılmış tamsayılar alır (sadece düz sayılar, tırnaklar veya parantezler olmamalıdır). Çıktı, düzenin hangi bölümlerinin çalıştırıldığına bağlıdır.

Programı çalıştırmanın beş yolu vardır (yeni satırlar çalışmaya dahil edilir). Her biri listeden farklı bir şey yapar:

1. Sadece çekirdeği çalıştır:

   CCC
   CCC
   CCC
   

   Bu, giriş listesi öğelerinin mutlak değerlerinin maksimumunu hesaplar ve COREbirçok kez yeni bir satıra yazdırır . Eğer maksimum 0 ise hiçbir şey çıkmaz (yeni satır iyi).

   • İçin çıkış 0 -1 31 -1 2 2 2olur

     CORE
     CORE
     ...
     

     31 kez.

2. Çekirdeği 1. katmanla çalıştırın:

   11111
   1CCC1
   1CCC1
   1CCC1
   11111
   

   Bu ortalamayı çıkarır ( aritmetik ortalama , liste değerlerinin ) standart kayar nokta kesinliğine çıkarır.

   • Çıktı 35/7 0 -1 31 -1 2 2 2olacaktır = 5( 5.0iyi).

3. Çekirdeği 1. ve 2. katmanlarla çalıştırın:

   2222222
   2111112
   21CCC12
   21CCC12
   21CCC12
   2111112
   2222222
   

   Bu, ters çevrilmiş giriş listesinin boşlukla ayrılmış listesini çıkarır.

   • İçin çıktı 0 -1 31 -1 2 2 2olacaktır 2 2 2 -1 31 -1 0.

4. Çekirdeği 1, 2 ve 3 katmanlarıyla çalıştırın (desen açık olmalıdır).
   Bu, sıralanan giriş listesinin boşlukla ayrılmış listesini çıkarır.

   • İçin çıktı 0 -1 31 -1 2 2 2olacaktır -1 -1 0 2 2 2 31.

5. Çekirdeği 1, 2, 3 ve 4 katmanlarıyla çalıştırın.
   Bu, giriş listesinin boşluklarla ayrılmış bir listesini çıkarır, yinelenenler kaldırıldı, sipariş önemli değil.

   • Çıktı 0 -1 31 -1 2 2 2olabilir -1 0 2 31.

Tüm çıktılar stdout'a veya benzer bir alternatiftir.

Sadece bu 5 düzen kombinasyonunun davranışları belirlendi.

notlar

• Çekirdek veya katmanlar veya bunların kombinasyonlarında yorumlara izin verilmez . İşlem yapılmayan veya yapıcı bir şey yapmayan kod, yorum olarak sayılmaz.
• Çekirdeğin (pozitif) N × N boyutlara sahip olabileceğini unutmayın, ancak katmanlar yalnızca bir karakter kalınlığındadır.
• Girişin baştaki veya sondaki boşlukların ve sayılar arasında tam olarak bir boşluk olmadığını varsayabilirsiniz. Her zaman en az bir sayı içerecektir. (Çıktı listeleri de bu şekilde biçimlendirilmelidir.)
• Çıktı için gerekli olan listenin ve hesaplamaların, tam sayılarınızı (maks . 2 ¹⁶ gibi makul bir şey olduğu sürece) taşan (veya altındaki) değerlere sahip olmayacağını varsayabilirsiniz .

puanlama

Bu programı normal olarak yazmak kolay olacaktır. Küçük bir çekirdekle yazmak zor.

En küçük çekirdek boyutuna sahip program (en küçük N) kazanır. Kravat durumunda kazanan, en az farklı karaktere sahip (yeni satırları saymaz) tam programdır ((N + 8) × (N + 8) kare).

Lütfen N değerinizi cevabınızın tepesinde bildirin.

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

Boşlukları saymazsam 26 karakterdir. Program aslında boşluk bırakmayan bir programa dönüştürülebilir, tüm boş alanları no-ops ile doldurmak suretiyle (ör._; , üst yığın elemanını kopyalayan ve sonra atılan veya diziyi tekrar tekrar sıralayarak), ancak program Sadece gerçek kodun dikkatini dağıtır.

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

Burada test et.

Çekirdek

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

(Ayrıca boş bir satır.)

N = 4CJam'da yapılamayacağından oldukça eminim (ve Dennis'in beni başka türlü ikna edeceğinden eminim: D). Yukarıdakilerin 17 karakteri vardır ve 16'ya düşürmek mümkün olsa da (örneğin, CJam boğulmak için bir hata yapmadıysa :z, gerektiren {z}%veya ARGV kullanarak), sığabileceğini sanmıyorum. mizanpaj içinde bir satır sonu tanıtmadan CORE.

Uygulamaların tümü verilen görevlere çok basit bir çözümdür. Hepsi l~]STDIN okuyan, değerlendiren ve diziye koyan başlıyor .

Önceki katman her zaman etrafına sarılır {...}, bu onu otomatik olarak çalıştırılmayan bir blok yapar. Ve onu çalıştırmak yerine, sadece yığından atıyorum ;, bu yüzden hiçbir katman önceki katmandaki koda bağlı değil. Katman 1'de kod ilk satıra uymuyordu, ben de çekirdek bloğu attıktan sonra devam ettim.

Şimdi gerçek programlar için:

• Çekirdek:

  {z}%$W="CORE
  "*
  

  Harita abssıralama bu son öğe, tekrarla almak, listenin üzerine CORE(ve satır sonu) o birçok kez.

• 1. Katman:

  _,\:+d\/
  

  Listeyi çoğalt, uzunluğu al, yığın öğelerini değiştir, toplamı al, double , yığın öğelerini değiştirin, bölün. Bunun daha kısa olabileceğini düşünüyorum, ancak bunu yapmak için hiçbir teşvik yok.

• Katman 2:

  W%S*
  

  Diziyi ters çevirin, boşluklarla karıştırın.

• Katman 3:

  $S*
  

  Diziyi sıralayın, boşluklarla karıştırın.

• Katman 4:

  Çoğaltın, birleşme ayarını yapın, boşlukları karıştırın.

Katman 2’yi ;ve *SKatmanı yeniden kullanmak gibi bazı diğer optimizasyonlar da mümkündür, ancak yine de skoru etkilemez.

Python 2 - N = 17, 53 karakter

Oh Python ile kaynak düzeni zorluklarını seviyorum.

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;"   (_)   :|   (_)   ";

Yine de kullanılmayan bir boşluk var.

Eşsiz karakter sayısını hala artırabilirim, ancak daha iyi okunabilirliğe sadık kalacağım - eğer varsa.

Düzenleme: Ah, yine Stan !

Python 3: N = 11, 40 farklı karakter

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

Eşim olduğum için @ Falko'ya teşekkürler. Bu işe yarar, çünkü Python her if ifadesi için yeni bir kapsam yaratmaz, bu nedenle değişkenler dış printifadelerde kalır . Can sıkıcı bir şey, bir mapnesnenin (bizim durumumuzda n) yalnızca bir kez kullanılabileceği idi. Bu yüzden R=E(...)çizgiyi yaymak gerekliydi , ancak daha sonra Rtanımlanmadı. Bu yüzden ilk satırda dört boşluk kaldığı için şanslıydım!

Çıktı *b[::-1], liste yerine birden fazla eleman sağlayarak çözülebilir . Alternatif ' '.join(...)çok uzun olurdu.

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

Varsayım sizeof(int) == 4ve 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 kat

3 kat

2 kat

1 kat

çekirdek

Runik Büyüler , 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:{=?\~

Çevrimiçi deneyin!

Yanıldığımı fark ettim, daha oönce "sıralama listesi" sorunuyla karşılaştığım için zaten açık bir s rt komutum olduğunu unuttum . Bununla birlikte, sıralama komutunun dahili maliyetleri nedeniyle, son programın alabileceği girdilerin boyutunu (8 değer) sınırlar. Hafif bir ince ayar , giriş boyutunu 1 benzersiz karakter maliyetiyle 13’e veya iki benzersiz karakter için 19’a yükseltebilir (tüm ek karakterler Katman 1’dedir ve aynı anda eklenir, ancak IP yığınının artan kapasitesi Katman 3'e kadar, C, L1 ve L2 gibi tüm girişleri bellekte tutmadan hesaplamaları yapabilir).

Çekirdek: Çevrimiçi deneyin!

Katman 1: Çevrimiçi deneyin!

Katman 2: Çevrimiçi deneyin!

Katman 3: Çevrimiçi deneyin!

Katman 4: Çevrimiçi deneyin!

Daha fazla sıkıştırma, akış kontrol karakterlerinin sayısında bir artış gerektiren daha küçük alan nedeniyle olası değildir. Çekirdek programında 9 boş alan veren bir düzenleme buldum, fakat ihtiyacımız olduğu gibi yetmiyor (doğru bir şekilde düzenlenmiş) 15.

Bu programlardan herhangi birinin nasıl çalıştığını açıklamak, IP'nin kullandığı yolun görsel bir haritasını çıkarmadan zahmetli ve zaman alıcıdır. İlk giriş noktası, ^yeni katmanlar eklendikçe tutarlı akış kontrolüne olanak sağlayan Core programının ( ) sol üst köşesidir , çünkü her katmanın üstünde veya altında yeni eklenen çizgiyi kesmek için bir fırsat vardır.

Katmanlar 1 ve 2 altta kesişir (böylece üst sıra gelecekteki katmanlar için boş kalır) ve sonra sağ kenar boyunca işlemlerini gerçekleştirir (dikey olarak düzenlenmiş bir halka). Katman 1 biraz fazla uzun ve üst kenar boyunca da 3 karakter alıyor, ancak \sağ üstte bulunan çapraz reflektör ( ), sonraki döngü yinelemesinde IP'yi yeniden hizalar.

Katman 3, alt kenara yönlendirmeden önce ilk giriş değerini almak için üst kenar boyunca araya girer (Katman 4, alt satırında bu sütunda bir NOP bırakır) ve Aşağıya yönlendirerek, alt kenar döngüsünü kullanarak tam girişi okur. Dsol altta command ( ). Oradan IP $, değerleri alandan ayırmak için sol altta bulunan bir output ( ) döngüsünde sona ermeden önce birkaç kez zıplar .

Katman 4, Katman 3'ün tüm işlevselliğini kullanır (bu nedenle boşluk), ancak Katman 3'ün işleminin sonunda kendi fonksiyonelliğini gerçekleştirmek için kendi yeni üst kenarı (sol üst) kenetlenir. Sol üst köşe "@", alttan işlem döngüsüne girmeden önce dizinin sonunu belirtmek için kullanılan bir dize ekler . Eğer yinelenen bir değer bulunursa, ( ~sağ alt köşenin alt köşesinde) çıkar. Aksi halde yeni sağ kenarı tüketen dal alınır. Bu yan dal, dizinin sonuna ulaşılıp ulaşılmadığını kontrol eder ve öyleyse ayrılır ve Kat 3'ten aynı boşlukla ayrılmış çıktı döngüsüne gider. Aksi halde, ana sayfaya geri dönmek için Kat 3'teki boş alanı kullanın. döngü.