ใช้เฉพาะASCII ที่พิมพ์ได้ (รหัสฐานสิบหก 20 ถึง 7E) เขียนโปรแกรมหลัก N × N แบบสี่เหลี่ยมโดยไม่มีความคิดเห็นที่ล้อมรอบด้วยเลเยอร์เพิ่มอีก 4 ชั้นสร้างโปรแกรมสแควร์ (N + 8) × (N + 8) (N> 0) . สำหรับ N = 3 โครงร่าง (ที่จะถูกแทนที่ด้วยรหัสจริง) มีลักษณะดังนี้:

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

• C เป็นตัวแทนของโปรแกรมคอร์ 3 × 3
• 1`s หมายถึงเลเยอร์แรก, 2 หมายถึงเลเยอร์ที่สอง ฯลฯ

โปรแกรมจะใช้สตริงของช่องว่างจำนวนเต็มคั่นเช่น0 -1 31 -1 2 2 2ผ่าน stdin หรือคล้ายกัน (มันควรจะเป็นตัวเลขธรรมดาไม่มีคำพูดหรือวงเล็บหรืออะไร) เอาต์พุตขึ้นอยู่กับส่วนของโครงร่างที่ถูกรัน

มีห้าวิธีในการเรียกใช้โปรแกรม (ขึ้นบรรทัดใหม่จะรวมอยู่ในการเรียกใช้) แต่ละคนทำสิ่งที่แตกต่างจากรายการ:

1. เรียกใช้เพียงแกน:

   CCC
   CCC
   CCC
   

   สิ่งนี้คำนวณค่าสูงสุดของค่าสัมบูรณ์ขององค์ประกอบรายการอินพุตและพิมพ์COREบนบรรทัดใหม่หลายครั้ง ถ้าค่าสูงสุดคือ 0 ไม่มีอะไรจะเอาท์พุท (ขึ้นบรรทัดใหม่ก็โอเค)

   • ผลลัพธ์สำหรับ0 -1 31 -1 2 2 2จะเป็น

     CORE
     CORE
     ...
     

     31 ครั้ง

2. เรียกใช้คอร์ด้วยเลเยอร์ 1:

   11111
   1CCC1
   1CCC1
   1CCC1
   11111
   

   นี้ส่งออกค่าเฉลี่ย ( ค่าเฉลี่ยเลขคณิต ) ของค่ารายการไปยังความแม่นยำจุดลอยตัวมาตรฐาน

   • ผลลัพธ์สำหรับ0 -1 31 -1 2 2 2จะเป็น 35/7 = 5( 5.0ไม่เป็นไร)

3. เรียกใช้แกนกลางด้วยเลเยอร์ 1 และ 2:

   2222222
   2111112
   21CCC12
   21CCC12
   21CCC12
   2111112
   2222222
   

   นี่เป็นรายการที่คั่นด้วยช่องว่างของรายการอินพุตที่กลับรายการ

   • สำหรับการส่งออกจะเป็น0 -1 31 -1 2 2 22 2 2 -1 31 -1 0

4. เรียกใช้แกนกลางด้วยเลเยอร์ 1, 2 และ 3 (รูปแบบควรชัดเจน)
   นี่เป็นรายการที่คั่นด้วยช่องว่างของรายการอินพุตที่เรียงลำดับ

   • สำหรับการส่งออกจะเป็น0 -1 31 -1 2 2 2-1 -1 0 2 2 2 31

5. เรียกใช้แกนกลางด้วยเลเยอร์ 1, 2, 3 และ 4
   ซึ่งจะส่งออกรายการที่คั่นด้วยช่องว่างของรายการอินพุตด้วยการลบรายการที่ซ้ำกันออกไปการเรียงลำดับไม่สำคัญ

   • สำหรับการส่งออกอาจจะ0 -1 31 -1 2 2 2-1 0 2 31

เอาต์พุตทั้งหมดคือ stdout หรือทางเลือกอื่นที่คล้ายกัน

เฉพาะชุดค่าผสม 5 รูปแบบเหล่านี้เท่านั้นที่มีพฤติกรรมที่ระบุ

หมายเหตุ

• ไม่อนุญาตให้แสดงความคิดเห็นในแกนกลางหรือเลเยอร์หรือชุดค่าผสม รหัสที่ไม่มีตัวเลือกหรือไม่ทำสิ่งใดสร้างสรรค์ไม่นับเป็นความคิดเห็น
• โปรดจำไว้ว่าแกนกลางสามารถมีมิติใด ๆ (บวก) N × N แต่ชั้นมีความหนาเพียงตัวเดียว
• คุณอาจสมมติว่าอินพุตไม่มีช่องว่างนำหน้าหรือต่อท้ายและมีช่องว่างหนึ่งช่องระหว่างตัวเลข มันจะมีอย่างน้อยหนึ่งหมายเลข (รายการผลลัพธ์ควรจัดรูปแบบเช่นนี้ด้วย)
• คุณอาจคิดว่ารายการและการคำนวณที่จำเป็นสำหรับการส่งออกจะไม่มีค่าที่มากเกินไป (หรืออันเดอร์โฟลว์) จำนวนเต็มของคุณ (ตราบใดที่ค่าสูงสุดของพวกมันคือสิ่งที่สมเหตุสมผลเช่น 2 ¹⁶ )

เกณฑ์การให้คะแนน

การเขียนโปรแกรมนี้ตามปกติจะเป็นเรื่องง่าย การเขียนด้วยแกนขนาดเล็กนั้นยาก

โปรแกรมที่มีขนาดแกนที่เล็กที่สุด (N ที่เล็กที่สุด) จะชนะ ในกรณีที่มีความสัมพันธ์กันผู้ชนะคือโปรแกรมเต็มรูปแบบ (ตาราง (N + 8) × (N + 8)) ที่มีตัวละครน้อยที่สุด (ไม่นับบรรทัดใหม่)

กรุณารายงานค่า N ของคุณที่ด้านบนของคำตอบของคุณ

CJam, N = 5, 27 (26) อักขระที่ไม่ซ้ำกัน

เป็น 26 ตัวอักษรถ้าฉันไม่นับช่องว่าง โปรแกรมสามารถแปลงเป็นอันที่ไม่ใช้ช่องว่างได้โดยเติมช่องว่างทั้งหมดโดยไม่มีตัวเลือก (เช่นการ_;ทำซ้ำองค์ประกอบสแต็คด้านบนแล้วละทิ้งหรือโดยการจัดเรียงอาร์เรย์ซ้ำแล้วซ้ำอีก) แต่มัน จะหันเหความสนใจจากรหัสจริง

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

ทดสอบที่นี่

แกนกลางคือ

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

(บวกบรรทัดว่างไว้)

ฉันค่อนข้างแน่ใจว่าN = 4ไม่สามารถทำได้ใน CJam (และฉันแน่ใจว่าเดนนิสจะโน้มน้าวให้ฉันเป็นอย่างอื่น: D) ด้านบนมี 17 ตัวอักษรและในขณะที่มันอาจเป็นไปได้ที่จะลดลงถึง 16 (เช่นถ้า CJam ไม่มีข้อบกพร่องที่จะทำให้หายใจไม่ออก:zซึ่งต้องใช้{z}%หรือโดยใช้ ARGV) ฉันไม่คิดว่าคุณสามารถใส่มันได้ COREในรูปแบบโดยไม่ต้องแนะนำตัวแบ่งบรรทัดภายใน

การใช้งานทั้งหมดเป็นโซลูชั่นที่ตรงไปตรงมามากสำหรับงานที่ได้รับ ทั้งหมดของพวกเขาเริ่มต้นด้วยการl~]ที่อ่าน STDIN ประเมินมันและทำให้มันอยู่ในอาร์เรย์

เลเยอร์ก่อนหน้านี้ล้อมรอบเสมอ{...}ซึ่งทำให้เป็นบล็อกที่ไม่ได้ดำเนินการโดยอัตโนมัติ และแทนที่จะใช้มันฉันแค่ทิ้งมันจาก stack ด้วย;ดังนั้นชั้นจึงไม่ขึ้นกับรหัสในชั้นก่อนหน้า ในเลเยอร์ 1 รหัสไม่พอดีกับบรรทัดแรกดังนั้นฉันจึงดำเนินการต่อหลังจากทิ้งบล็อกหลัก

ตอนนี้สำหรับโปรแกรมจริง:

• แกนหลัก:

  {z}%$W="CORE
  "*
  

  แผนที่absลงในรายการเรียงลำดับใช้องค์ประกอบสุดท้ายทำซ้ำCORE(และตัวแบ่งบรรทัด) ที่หลายต่อหลายครั้ง

• ชั้นที่ 1:

  _,\:+d\/
  

  ทำซ้ำรายการใช้ความยาวสลับองค์ประกอบสแต็กรับผลรวมส่งไปยังdoubleสลับองค์ประกอบสแต็กหาร ฉันคิดว่ามันสั้นกว่านี้ แต่ไม่มีแรงจูงใจให้ทำ

• ชั้นที่ 2:

  W%S*
  

  ย้อนกลับอาร์เรย์, ระลอกคลื่นน้อยด้วยช่องว่าง

• ชั้นที่ 3:

  $S*
  

  เรียงลำดับอาร์เรย์เป็นระลอกคลื่นน้อยด้วยช่องว่าง

• ชั้นที่ 4:

  ทำซ้ำตั้งค่าสหภาพ riffle ด้วยช่องว่าง

การเพิ่มประสิทธิภาพอื่น ๆ บางอย่างอาจเป็นไปได้เช่นการนำกลับมาใช้;และ*Sของเลเยอร์ 2 อีกครั้ง แต่กลับไม่ส่งผลกระทบต่อคะแนน

Python 2 - N = 17, 53 ตัวอักษร

โอ้ฉันชอบความท้าทายรูปแบบซอร์สกับ 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;"   (_)   :|   (_)   ";

ยังมีช่องว่างที่ไม่ได้ใช้อยู่

ฉันยังคงสามารถปรับปรุงจำนวนตัวละครที่เป็นเอกลักษณ์ได้ แต่ฉันจะสามารถอ่านได้ดีขึ้น - ถ้ามีเลย

แก้ไข:โอ้มันคือสแตนอีกครั้ง !

Python 3: N = 11, 40 อักขระที่แตกต่าง

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

ขอบคุณ @Falko ที่เป็นคนรำพึงของฉัน วิธีนี้ใช้งานได้เพราะ Python ไม่ได้สร้างขอบเขตใหม่สำหรับแต่ละคำสั่ง if ดังนั้นตัวแปรจะยังคงอยู่ในprintคำสั่งด้านนอก สิ่งหนึ่งที่น่ารำคาญคือmapวัตถุ (ในกรณีของเราn) สามารถใช้ได้เพียงครั้งเดียว ดังนั้นจึงจำเป็นที่จะต้องวางR=E(...)สาย แต่Rก็ไม่ได้กำหนดไว้ ดังนั้นฉันโชคดีที่มีช่องว่างเหลืออยู่สี่บรรทัดในบรรทัดแรก!

เอาต์พุตสามารถแก้ไขได้โดยจัดเตรียมหลายอิลิเมนต์*b[::-1]แทนรายการ ทางเลือก' '.join(...)คงจะยาวเกินไป

C (gcc) , N = 15, 47 อักขระที่ไม่ซ้ำกัน

ถือว่าและsizeof(int) == 4sizeof(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 ชั้น

3 ชั้น

2 ชั้น

1 ชั้น

แกน

Runic Enchantments , N = 9 N = 8, 38 ตัวอักษร

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

ลองออนไลน์!

กลับกลายเป็นว่าฉันผิดฉันลืมว่าฉันมีoคำสั่งs rt ที่ชัดเจนอยู่แล้วเนื่องจากพบปัญหา "เรียงลำดับรายการ" ก่อนหน้านี้ อย่างไรก็ตามสิ่งนี้จะ จำกัด ขนาดของอินพุตที่โปรแกรมขั้นสุดท้ายสามารถรับได้ (8 ค่า) เนื่องจากต้นทุนภายในของคำสั่ง sort การปรับแต่งเล็กน้อยสามารถเพิ่มขนาดอินพุตเป็น 13 ด้วยราคาของอักขระที่ไม่ซ้ำกัน 1 ตัวหรือถึง19สำหรับอักขระที่ไม่ซ้ำกันสองตัว (อักขระเพิ่มเติมทั้งหมดอยู่ในเลเยอร์ 1 และเพิ่มในเวลาเดียวกัน แต่ความจุที่เพิ่มขึ้นของสแต็คของ IP ไม่ได้ ต้องการจนกระทั่งเลเยอร์ 3 เช่น C, L1 และ L2 สามารถทำการคำนวณได้โดยไม่ต้องถืออินพุตทั้งหมดในหน่วยความจำ)

หลัก: ลองออนไลน์!

ชั้น 1: ลองออนไลน์!

ชั้นที่ 2: ลองออนไลน์!

ชั้นที่ 3: ลองออนไลน์!

ชั้นที่ 4: ลองออนไลน์!

การบีบอัดเพิ่มเติมไม่น่าเป็นไปได้สูงเนื่องจากพื้นที่ขนาดเล็กจำเป็นต้องเพิ่มจำนวนของอักขระควบคุมการไหล ฉันพบข้อตกลงที่ให้พื้นที่ว่าง 9 รายการในโปรแกรมหลัก แต่ไม่เพียงพอตามที่เราต้องการ (จัดเรียงอย่างถูกต้อง) 15

อธิบายว่าโปรแกรมเหล่านี้ทำงานอย่างไรโดยไม่ต้องใช้แผนที่ที่แสดงเส้นทางที่ IP ใช้ซึ่งยุ่งยากและเสียเวลาในการสร้าง จุดเริ่มต้นเริ่มต้นคือมุมบนซ้ายของโปรแกรมหลัก ( ^) ซึ่งอนุญาตให้ควบคุมการไหลที่สอดคล้องกันเมื่อมีการเพิ่มเลเยอร์ใหม่เนื่องจากแต่ละชั้นมีโอกาสที่จะสกัดกั้นบรรทัดที่เพิ่มใหม่ที่ด้านบนหรือด้านล่าง

เลเยอร์ 1 และ 2 ตัดที่ด้านล่าง (เพื่อให้บรรทัดบนสุดยังคงว่างเปล่าสำหรับเลเยอร์ในอนาคต) จากนั้นดำเนินการตามขอบด้านขวามือ (การวนซ้ำที่จัดในแนวตั้ง) เลเยอร์ 1 ยาวเกินไปเล็กน้อยและใช้อักขระ 3 ตัวที่ขอบด้านบนเช่นกัน แต่ตัวสะท้อนแนวทแยงมุม ( \) ที่มุมขวาบนจะปรับ IP ด้วยการวนซ้ำถัดไป

เลเยอร์ 3 ตัดตามแนวขอบด้านบนเพื่อรับค่าอินพุตแรกก่อนที่จะเปลี่ยนเส้นทางไปที่ขอบด้านล่าง (เลเยอร์ 4 ปล่อย NOP ในคอลัมน์นี้ที่บรรทัดล่างสุด) และอ่านอินพุตแบบเต็มโดยใช้ลูปขอบด้านล่างเปลี่ยนเส้นทางบนล่าง command ( D) ที่ด้านล่างซ้าย จากนั้น IP จะเด้งสองสามครั้งก่อนที่จะสิ้นสุดใน$ลูปเอาท์พุท ( ) ที่ด้านซ้ายล่างเพื่อแยกช่องว่างค่า

เลเยอร์ 4 ใช้ฟังก์ชันการทำงานทั้งหมดของเลเยอร์ 3 (ดังนั้นพื้นที่ว่าง) แต่ดักอยู่ที่ขอบด้านบนใหม่ (บนซ้าย) เพื่อทำหน้าที่ของตัวเองเมื่อการประมวลผลของเลเยอร์ 3 สิ้นสุดลง มุมซ้ายบนแทรกสตริง"@"ที่ใช้เพื่อแสดงถึงจุดสิ้นสุดของอาร์เรย์ก่อนที่จะเข้าสู่การประมวลผลวนรอบด้านล่าง หากพบค่าที่ซ้ำกันก็จะเกิดขึ้น ( ~มุมล่างขวา) มิฉะนั้นจะมีการแยกสาขาที่ใช้ขอบด้านขวาใหม่ สาขาด้านนี้ตรวจสอบเพื่อดูว่าถึงจุดสิ้นสุดของอาร์เรย์แล้วหรือไม่และแยกออกจากกันแล้วมุ่งหน้าไปที่ลูปเอาท์พุทที่คั่นด้วยช่องว่างเดียวกันจากเลเยอร์ 3 มิฉะนั้นใช้พื้นที่ว่างบนเลเยอร์ 3 เพื่อกลับไปที่หน้าหลัก ห่วง