พิจารณาสแควร์ของอักขระ ASCII ที่พิมพ์ได้ (รหัสจุด 0x20 ถึง 0x7E) สำหรับความยาวด้านNเช่นดังต่อไปนี้ (ที่นี่, N = 6 ):

=\    
 g \  
7     
m+y "g
  L ~ 
e> PHq

นอกจากนี้เรายังต้องใช้แต่ละแถวและแต่ละคอลัมน์จะมีอย่างน้อย1 พื้นที่และ1 ไม่ใช่พื้นที่ของตัวละคร (ตัวอย่างข้างต้นเป็นไปตามนี้)

เรากำหนดค่าลบของสี่เหลี่ยมจัตุรัสดังกล่าวให้เป็นสี่เหลี่ยมจัตุรัสขนาดเดียวกันซึ่งแต่ละพื้นที่ถูกแทนที่ด้วยพื้นที่ว่างและในทางกลับกัน เช่นต่อไปนี้จะเป็นค่าลบที่ถูกต้องของตัวอย่างด้านบน:

  1234
a b cd  
 ZYXWV
   !  
{} [ ] 
  ?   

ตัวเลือกของอักขระที่ไม่ใช่ช่องว่างไม่เกี่ยวข้อง (ตราบใดที่อักขระเหล่านั้นมาจากช่วง ASCII ที่พิมพ์ได้)

ความท้าทาย

คุณจะเขียนโปรแกรมโดยใช้ซอร์สโค้ดแบบสี่เหลี่ยมที่มีความยาวด้านN> 1ซึ่งจะพิมพ์ค่าลบของตัวเองไปยัง STDOUT ต้องพิมพ์ช่องว่างต่อท้าย คุณสามารถหรือไม่พิมพ์บรรทัดใหม่ขึ้นบรรทัดเดียว

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

ผู้ชนะคือโปรแกรมที่มีความยาวด้านต่ำสุดN ในกรณีที่มีการผูกการส่งด้วยตัวอักษรที่ไม่ใช่ช่องว่างน้อยที่สุดในรหัสที่มาชนะ หากยังมีเสมอคำตอบที่เร็วที่สุดชนะ

CJam, 4 x 4 (ไม่มีที่ว่าง 8 แห่ง)

 L _
{ _ 
 _ }
_ p 

ลองใช้ออนไลน์ในล่าม CJam

เอาท์พุต

{ _ 
 _ }
{ _ 
 _ }

มันทำงานอย่างไร

• Lผลักอาร์เรย์ว่างเปล่าและ_ผลักดันสำเนาของมัน

• การปิดกั้น

  { _ 
   _ }
  

  ดันบล็อกนั้นบนสแต็ก

• _ผลักสำเนาของบล็อครหัสและpพิมพ์ตามด้วย linefeed

• ในที่สุดล่ามจะพิมพ์รายการที่เหลือทั้งหมดบนสแต็ก: สองอาร์เรย์ว่างที่ไม่มีผลต่อผลลัพธ์และบล็อกโค้ดต้นฉบับ

รุ่นอื่น

 L ~
{ _ 
 p }
_ ~ 

ลองใช้ออนไลน์ในล่าม CJam

เอาท์พุต

{ _ 
 p }
{ _ 
 p }

มันทำงานอย่างไร

• Lผลักอาร์เรย์ว่างและ~ทิ้งมัน สแต็กว่างเปล่าอีกครั้ง

• การปิดกั้น

  { _ 
   p }
  

  ดันบล็อกนั้นบนสแต็ก

• _ผลักสำเนาของบล็อกและ~ดำเนินการคัดลอก

  _ภายในสำเนาของบล็อกจะผลักดันสำเนาของบล็อกเดิมที่pจะพิมพ์ตามด้วยการเลื่อนบรรทัด

• ในที่สุดล่ามพิมพ์รายการที่เหลืออยู่ในกอง: บล็อกรหัสเดิม

Perl, 7 × 7 (42 ปลอดช่องว่าง)

for$i( 
1..56 )
{$_= $i
%8? $i%
7? $":7
: $/;1;
 print}

เอาท์พุท:

      7
     7 
    7  
   7   
  7    
 7     
7      

CJam, 4X4 ( 12 10 ไม่ใช่ที่ว่าง)

 6, 
SS +
* 4/
 N* 

เอาท์พุท:

0  1
  2 
 3  
4  5

รุ่นก่อนหน้าพร้อมช่องว่าง 12 ช่อง:

 4a4
* 4S
** 4
/N* 

และผลลัพธ์ก็คือ

4   
 4  
  4 
   4

ตามที่ระบุโดย Martin รุ่นนี้มี

• 4ช่องว่าง
• 4 * ,
• 4 4 ,
• 4ตัวละครอื่น ๆ และ
• 4 4เป็นผลลัพธ์

;)

ลองออนไลน์ได้ที่นี่

Marbelous - 16x16

....@0..@1....  
@3..0A08..@2  ..
/\--....>1  ..Hp
..@2..\\  =0@3..
ss..//  --\\\\..
@0/\  @1/\Hp..!!
:s  #the-cake-is
  2020#a-pie/lie

ทดสอบที่นี่! ช่องว่างเป็นช่องว่างกระดานทรงกระบอกและรวมถึงห้องสมุดทั้งหมดจะต้องตรวจสอบ

เอาท์พุต

              07
            06  
          05    
        04      
      03        
    02          
  01            
01              

คำอธิบาย

มีสองบอร์ดที่นี่: กระดานหลัก (แสดงด้านล่าง) และssบอร์ดซึ่งไม่มีอินพุตและเอาต์พุตสองช่องว่าง (0x20) ไปยัง STDOUT

เซลล์ว่างเท่ากับเซลล์ a ..และทุกสิ่งที่อยู่หลัง#ความคิดเห็น

ทุกช่องทำเครื่องหมายssส่งเอาต์พุตสองช่องว่างไปที่ STDOUT

เส้นทางสีเขียวเป็นลูปแบบง่ายที่ส่งเอาต์พุตขึ้นบรรทัดใหม่ (0x0A) ที่จุดสิ้นสุดของทุก ๆ ขีดที่ 7

เส้นทางสีน้ำเงินจะส่งออกตัวเลข ( Hpพิมพ์หินอ่อนเป็นเลขฐานสิบหกสองหลัก) ที่มีอยู่ในผลลัพธ์เมื่อสิ้นสุดทุกขีดที่ 6

หลังจากเราพิมพ์01ครั้งเดียวลูปจะสิ้นสุดลงและเลื่อนไปตามทางสีแดงซึ่งทำซ้ำหินอ่อนนี้

สำเนาที่ซ้ำกันจะถูกพิมพ์ (ที่สอง01) และที่อื่น ๆ จะถูกส่งลงในเส้นทางสีดำซึ่งจะจบกระดานใน!!เซลล์ เนื่องจากตำแหน่งของที่Hpใช้ในการพิมพ์ล่าสุดนี้จึง01ปรากฏขึ้นก่อนที่ช่องว่างสองเห็บเดียวกันแทนที่จะเป็นพฤติกรรมของการHpโทรทุกครั้ง

Python - 11x11

import re
[print(
    re.sub(
"0",   " ",
bin(x)[
2:].zfill(
11)))for x
in[19,15,
1920,116,
15,1,5,3,
3,3, 67]]

เอาท์พุต

      1  11
       1111
1111       
    111 1  
       1111
          1
        1 1
         11
         11
         11
    1    11

มันเป็นวิธีที่ยุ่งและน่าเบื่อ แต่ฉันแค่คิดว่าฉันจะแสดงให้เห็นว่า ...

1. มันสามารถทำได้ใน Python
2. หากคุณสามารถบีบอัดข้อมูลเกี่ยวกับรหัสของคุณสั้นกว่ารหัสของคุณคุณสามารถดึงบางสิ่งออกมาเช่นนี้ :)

IndentationErrorการแก้ปัญหานี้จะได้ประโยชน์จากความจริงที่ว่าหากคุณอยู่ในคู่ของวงเล็บในหลามแล้วคุณสามารถแยกรหัสของคุณในช่วงหลายเส้นและพลเพิ่มช่องว่างโดยไม่ได้รับ อีกวิธีในการทำบางสิ่งเช่นนี้คือการสิ้นสุดบรรทัดด้วยแบ็กสแลช

Python - 7x7 (37 ช่องว่าง)

print( 
'%+7s' 
'\n'%1 
*6+'%' 
'-7s'% 
111111 
      )

เอาท์พุต

      1
      1
      1
      1
      1
      1
111111 

ใช้%โอเปอเรเตอร์การจัดรูปแบบสตริงเก่าของ Python เพื่อทำงาน: +7และ-7ดูแลการจัดชิดขวา / ซ้ายและช่องว่างสุดท้ายเพื่อจับคู่วงเล็บปิดprintโดยเฉพาะ ในการจัดรูปแบบสตริงเรายังมี

• การต่อข้อมูลอัตโนมัติของสตริงตัวอักษรข้ามบรรทัดและ
• การทำซ้ำสตริงด้วยการคูณ (ให้ฟิลด์การแทนที่หลายฟิลด์สำหรับราคาหนึ่ง)

JavaScript (9x9)

 i=9;q=""
; for(;++
i< 91;){;
var q=q+(
!(i% 10.0
)?1:" ");
;i%9|| (q
+="\n") }
alert(q) 

เอาท์พุต

1        
 1       
  1      
   1     
    1    
     1   
      1  
       1 
        1

หมายเหตุ

ฉันสร้างและ golfed (ตามความสามารถของฉันที่ดีที่สุด) สำหรับสี่เหลี่ยมที่มีเส้นทแยงมุมของขนาดใด ๆ n:

q="";for(i=***n***;++i<***n^2+n+1***;i%***n***||(q+="\n"))q+=i%***n+1***?"0":1

แทนที่หมายเลข *** asdf *** ด้วยค่าคงที่ซึ่งขึ้นอยู่กับความยาวด้าน n ตัวอย่างเช่น n = 6:

q="";for(i=6;++i<43;i%6||(q+="\n"))q+=i%7?" ":1

แต่ถึงแม้ว่ารหัสนั้นจะมีความยาว 46 แต่ฉันก็ไม่สามารถรับพื้นที่คงที่เพื่อให้สอดคล้องกับช่องว่างในเส้นทแยงมุมของรหัสจนกว่ามันจะมีขนาดใหญ่เท่ากับ 9x9 โดยมีเส้นที่เสียไป (เส้นที่ 5)

แก้ไข: เปลี่ยนเพื่อเพิ่มการแจ้งเตือน () ก่อน:

 i=9;q=""
; while((
++ i)<91)
{q= q+""+
""+( "")+
(!((i %10
))?1:" ")
;i%9||( q
+="\n")} 

CJam, 5x5, 12 ช่องว่าง

ไม่ใช่ผู้ชนะ แต่ฉันต้องการเพิ่มการส่งที่ค่อนข้างเล็กและกระจัดกระจายเนื่องจากคำตอบส่วนใหญ่เพียงพิมพ์เส้นทแยงมุม

 1 ]
D * S
 * 5
/ N *
 1 ; 

พิมพ์

1 1 1
 1 1 
1 1 1
 1 1 
1 1 1

ทดสอบที่นี่

อักขระสองตัวสุดท้ายของโค้ดไม่ได้ทำอะไรเลยดังนั้นจึงมีรหัสจริงเพียง 10 ไบต์เท่านั้น สำหรับกริดที่เล็กกว่าฉันสามารถลดขนาดมันลงได้อีกสองไบต์ถึง 8 แต่นั่นไม่เหมาะกับ 3x3 และรหัสนี้ใช้ไม่ได้กับขนาดกริดแม้แต่ตัวเดียว

มันทำงานอย่างไร:

1]           "Push [1].";
  D*         "Repeat 13 times.";
    S*       "Riffle with spaces.";
      5/     "Split into runs of five elements.";
        N*   "Join those with line breaks.";
          1; "Push and pop a 1. No-op.";

Befunge , 9x9

ฉันไม่รู้ว่าทำไมฉันถึงทำแบบนี้ มันเอาวิธีที่ยาวเกินไป ตอนนี้ฉันปวดหัวมาก

8>v_20gv 
v9<^v#<4 
1@,/<>^6 
v1,*$:<p 
->,!-^87 
:^*25<^g 
_88g,^^4 
9vp\v#6< 
        @

เอาท์พุท:

        @
        @
        @
        @
        @
        @
        @
        @
$$$$$$$$ 

คำอธิบายบางอย่าง

รหัสที่ใช้gในการอ่าน@อักขระจากกริด "on the fly" (และพื้นที่สุดท้ายซึ่งก็คือ@ / 2) และpเพื่อแก้ไขลูปเพื่อเขียนบรรทัดเอาต์พุตสุดท้าย

อักขระทุกตัวในรหัสถูกใช้ในบางจุดไม่ว่าจะเป็นรหัสหรือข้อมูล ( 9และ@บนสองบรรทัดสุดท้าย)

โดยทั่วไปฉันต้องทำหลายวิธีเพื่อให้โค้ดทำงานได้ ตัวชี้คำสั่งทำหลายทางแยกในระหว่างการดำเนินการซึ่งบางส่วนถูกข้ามไป (ฉันไม่สามารถใช้คำสั่งใด ๆ ที่นั่นสำหรับทิศทางที่แตกต่างกันตามที่พวกเขาจะรบกวนไม่มี NOP.) ที่อื่นฉันใช้ซ้ำตัวละครเดียวกันหรือเพียงแค่ยกเลิกมัน (ดู$:ตรงกลาง)

ฉันยังทำงานสร้างสรรค์ในกองซ้อน:

• เมื่อ (ภายใน) เขียนตัวอักษรห่วงยุติ (พื้นที่ทั้งหมดที่ทำสำหรับสายนี้) n,0สแต็คมี nจากนั้นผมก็ต้องพร่อง วิธีการแก้ปัญหาที่ชัดเจนจะแต่ฉันจัดการเพื่อลดระยะโดยใช้$1-!-
• เมื่อ (นอก) บรรทัดเขียนห่วงยุติ (เส้นปกติทุกพิมพ์), 0สแต็คมี จากนั้นผมก็จัดเปลี่ยนรหัส ( 20g46p7g46\p) เพื่อใช้0แทนการเสีย 2 $0ตัวอักษรบน

Python 3, 8x8

มีอักขระที่ไม่ใช่ช่องว่าง 50 ตัวและช่องว่าง 14 ช่อง บรรทัดสุดท้ายมีอักขระหนึ่งตัวที่ไร้ประโยชน์ แต่ทุกอย่างก็จำเป็น

(*_,q,n 
)=p=''' 
       p
'''[2:] 
print(p 
*2+q*7, 
n+p*4+p 
[0:-1]) 

เอาท์พุท:

       p
       p
ppppppp 
       p
       p
       p
       p
       p

ทับทิม 8x8

 (0...8)
. map(){
|x |$><<
32. chr*
x+[x ]*'
'<<32 .\
chr*(7 -
x)+?\n} 

เอาท์พุท:

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7

CJam, 5X5

SSSS 
1N]4 
*B11 
    S

และผลลัพธ์ก็คือ

    1
    1
    1
    1
1111 

ฉันใกล้จะถึงโซลูชัน 4X4 แล้ว <sigh>ดูคำตอบอื่นของฉัน

ลองออนไลน์ได้ที่นี่

C ++, 12x12

แก้ไข:ดังนั้นฉันเริ่มรู้สึกหมกมุ่นกับความท้าทายนี้เล็กน้อยและจัดการลงจาก 17x17 เป็น 12x12 ฉันใช้เวลาสักครู่เพื่อตระหนักว่าฉันสามารถใช้/**/เป็นตัวคั่นโทเค็นได้ รหัสนี้ใช้ประโยชน์จากความจริงที่ว่า Splice Line ยังคงทำงานใน Clang ด้วยช่องว่างหลังจากนั้นแม้ว่าจะให้คำเตือนและการทำลายรหัสสีของ Xcode

#include<c\ 
stdio>/***/ 
int/**/mai\ 
n(){for(in\ 
t/**/i=0;i\ 
<12;++i)pr\ 
intf(i^8?"\ 
           \
|\n":"~~~~\ 
~~~~~~~\x2\ 
0\n");}/**/ 

เอาท์พุท:

           |
           |
           |
           |
           |
           |
           |
           |
~~~~~~~~~~~ 
           |
           |
           |

Befunge-98 , 8x8 (ไม่มีที่ว่าง 56 อัน [11 nops])

หมายเหตุ: เพื่อประโยชน์ของคนที่ชื่นชอบการเล่นกีฬาสิ่งนี้จะเป็นการอ่านแหล่งข้อมูลของตัวเองผ่านทาง'ทำให้มันเป็นเรื่องหลอกลวงสำหรับบางคน อ่านการอภิปรายที่นี่

โครงการ

 07'?>:8v
v y+da:%<
<v ':vj!-
,+# '<zzv
v1#a vj!<
>z,\1 -\v
z>+,$v z<
1_@#:<v -
zzzzzv<z 

เอาท์พุต

(       
 ,      
  &     
   %    
    $   
     #  
      " 
       !

คำอธิบาย

รุ่นที่ยังไม่ตีกอล์ฟ

07'?>:8%:ad+y-!jv>'n,$v
  !jv   a,\1-\v > 's,  
    >         >       v
    v-1_@#:           <

(ไม่ใช่ที่ว่างและที่ว่างถูกแทนที่ด้วย 'n และ' s เพื่อประโยชน์ในการอ่าน)

วิธีการแก้ปัญหานี้ขึ้นอยู่กับข้อเท็จจริงที่ว่าการใช้ดัชนี [0, ความกว้าง ^ 2) ปรับความกว้างของสี่เหลี่ยมจัตุรัสสามารถบอกคุณได้ว่าคุณอยู่ท้ายแถวหรือในแนวทแยง เนื่องจากช่องว่างทั้งหมดถูกวางในแนวทแยงจึงเป็นเรื่องง่ายที่จะบอกได้ว่าเมื่อใดที่ต้องพิมพ์พื้นที่ว่าง!

ใน Pseudocode

const int WIDTH = 8
push 0    //Because of the way the 'y' instruction works when picking
int row=7 //8-1 rows
int i=63  //Starting at the end allows for the cheaper i != 0
do
{
    pick variable row from the stack bottom + 1//ad+y
    if(i%WIDTH == row)
    {
        print non-space
    }
    else
    {
        print space
        if(i%WIDTH == 0)
        {
            print new-line
            --row
        }
    }
  --i
}
while(i != 0);

อภิปรายผล

ฉันภูมิใจในตัวมันมากถึงแม้ว่าฉันหวังว่าฉันจะสามารถทำให้ทุกพื้นที่ที่ไม่ใช่พื้นที่ยังไม่เป็น ฉันก็ภูมิใจเช่นกันที่ฉันไม่ได้ใช้ Trope ใส่เพิ่ม Befunge มาตรฐาน! มันพิมพ์สัญลักษณ์ที่แตกต่างกันออกไปสำหรับที่ไม่มีที่ว่างเพราะฉันมีพื้นที่สำหรับมันและไม่ต้องการที่จะน่าเบื่อ

ลองใช้งานบน Windows ด้วยBefungeSharp !

CJam, 4 x 4 (ไม่มีที่ว่าง 8 แห่ง)

 N a
` S 
 * N
X $ 

ลองใช้ออนไลน์ในล่าม CJam

เอาท์พุต

[ " 
 " ]
[ " 
 " ]

มันทำงานอย่างไร

• Nดัน linefeed เป็นสตริงเดี่ยว aตัดสตริงนั้นในอาร์เรย์

• ` ตรวจสอบผลคือมันจะผลักดันการเป็นตัวแทนสตริงของอาร์เรย์

  นี่คือผลลัพธ์ที่ได้:

  ["
  "]
  

• S*รวมสตริงผลลัพธ์ (อาร์เรย์ของอักขระ) โดยแยกองค์ประกอบโดยใช้ช่องว่าง กล่าวอีกนัยหนึ่งมันใส่อักขระช่องว่างระหว่างคู่ของอักขระที่อยู่ติดกันทั้งหมดของสตริง

  นี่คือผลลัพธ์ที่ได้:

  [ " 
   " ]
  

• N ดัน linefeed อื่น

• X$ คัดลอกรายการสแต็คที่ดัชนี 1 (นับจากด้านบน) เช่นสตริงหลายบรรทัด

• ในที่สุดล่ามจะพิมพ์รายการทั้งหมดในสแต็ก: สตริงหลายบรรทัดดั้งเดิม linefeed และสำเนาของสตริงหลายบรรทัด

SOGL V0.12 , 2x2 (ไม่มีที่ว่าง 2 แห่ง)

2 
 ╚

ลองที่นี่!

เอาท์พุต

 /
/ 

คำอธิบาย

ใน SOGL ทุกบรรทัดยกเว้นบรรทัดสุดท้ายจะแทนที่บรรทัด - มันจะแทนที่ทุกหนทุกแห่งในโค้ดต่อเนื่องซึ่งเป็นอักขระตัวสุดท้ายของบรรทัดด้วยทุกอย่างที่อยู่ก่อนหน้า ดังนั้นเส้นที่ 1 replace space with 2 in the next lineที่นี่คือ
จากนั้นบรรทัดถัดไป - 2╚ถูกเรียกใช้: 2กด 2 และ╚สร้างเส้นทแยงมุมของขนาด 2

CBM BASIC v2.0 (8 × 8)

การปรับปรุงคำตอบก่อนหน้าของฉันโดยใช้วิธีที่แตกต่างอย่างสิ้นเชิง:

1s=56/8 
2?sP7); 
3?"?":: 
4s=s-+1 
5ifsgO2 
6?-8^6; 
7?sP1): 
       8

เอาท์พุท:

       ?
       ?
       ?
       ?
       ?
       ?
       ?
-262144 

ทับทิม8x8 7x7

 print(
 (?f+"\
 "*6+?\
 )*6).!
 $><<"\
 f"<<!1
;      

เอาท์พุท:

f      
f      
f      
f      
f      
f      
 ffalse

รุ่นก่อนหน้า 8x8 มี 20 ช่องว่าง:

  puts((
  "ff"+#
  ?\s*6+
  ?\n)*7
  );$><<
  ?\s*2+
  ?f;p:p
.!

เอาท์พุท:

ff     
ff     
ff     
ff     
ff     
ff
ff     
  ffalse

รุกพื้นที่ 4x4

การไม่แข่งขันเมื่อภาษาโพสต์ความท้าทาย:

รหัส:

 H32
2 C4
:" } 
\o/

ขาออก:

d   
 d  
  d 
   d

ลองออนไลน์!

เนื่องจากช่องว่างไม่เกี่ยวข้องใน Pushy รหัสจึงถูกจัดเรียงอย่างง่ายเพื่อให้ตรงกับผลลบของมัน โปรแกรมจริงมีลักษณะดังนี้:

H      \ Push char 100, 'd'
32 2C  \ Push char 32, a space, and make 2 extra copies
       \ We now have the string 'd   '
4:     \ 4 times do:
  "    \   Print the string
   }   \   Cyclically shift it right, once

แบ็กสแลชเริ่มต้นความคิดเห็นดังนั้นการติดตาม \o/จะอยู่ตรงนั้นเพื่อให้การลบเสร็จสมบูรณ์และดูดี

อีกทางเลือกหนึ่งสำหรับคะแนนเดียวกันเราสามารถมีทางออกต่อไปนี้:

Code    Output

 35;    #
3 2j     #
2C 4      #
:"}        #

K 36     #
33 2      #
Ct4        #
 :}"    #

Haskell, 10 × 10

main=let{ 
0&c='\32' 
!c;n&c=c! 
'\32'>>(n 
-1)&c;a!b 
=putStrLn 
$(b<$[1.. 
10])++[a] 
}in(9&'*' 
         )

กำหนดฟังก์ชั่นผู้ช่วยa ! bที่พิมพ์เส้นของรูปแบบbbbbbbbbbaและฟังก์ชั่น recursive n & cที่พิมพ์nเส้นของรูปแบบตามด้วยหนึ่งบรรทัดของแบบฟอร์มccccccccc␣␣␣␣␣␣␣␣␣␣c

ใช้<$( fmap const, อีกครั้ง) ในช่วงเพื่อทำซ้ำอักขระ โปรดทราบว่า<$จะสามารถใช้ได้โดยไม่มีการนำเข้าตั้งแต่ GHC 7.10 ซึ่งลงวันที่ความท้าทายนี้ฉันไม่แน่ใจว่าสิ่งนี้ทำให้การส่งไม่ใช่การแข่งขันหรือไม่

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

05AB1E , 3x3 (6 ไบต์ที่ไม่ใช่ช่องว่าง)

 3Ð
Λ q
°° 

เอาท์พุท:

3  
 3 
  3

ลองออนไลน์

คำอธิบาย:

3Ð       # Push three 3s to the stack
  Λ      # Canvas with parameters num; filler; pattern
         #  num: The amount of characters to display (3)
         #  filler: The character to display ('3')
         #  pattern: The available options are single-digit integers in the range [0,7]
         #           indicating the direction to print in.
         #           (Option 3 is a top-left to bottom-right diagonal line)
    q    # Exit the program
°°       # no-ops to complete the pattern

Perl, 6x6 (ไม่ใช่ 26 ช่องว่าง)

ฉันใช้เวลาดู whlie ผ่านสิ่งเหล่านี้และมั่นใจว่าจะมีทางออก Perl น้อยกว่า 7x7 อย่างใด ... ความท้าทายที่สนุกมาก! -Eวิธีการแก้ปัญหานี้ต้องใช้

say+( 
$"x5, 
"5$/" 
)x5,5 
x5,$" 
     ;

การใช้งาน:

perl -E 'say+( 
$"x5, 
"5\n" 
)x5,5 
x5,$" 
     ;'

เอาท์พุท:

     5
     5
     5
     5
     5
55555 

CBM BASIC v2.0 (9 × 9)

0dA8,7,6 
1dA5,4, 3
2dA2,1 ,0
3rEs: rem
4?sP s)::
5:? "*";:
6p =8---s
7 ?sPp):?
 8ifsgO3:

เอาท์พุท:

        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        

C (gcc) , 7x7 8x8

แก้ไข: รุ่นก่อนหน้ามีพฤติกรรมที่ไม่ถูกต้อง

 main(i)
{ for(;i
<9 ;pri\
ntf ("%\
*d%" "*\
c",i, 1,
9-i,10 )
,i++);} 

ลองออนไลน์!

เยลลี่ , 4 x 4 (12 ปลอดช่องว่าง)

 4=þ
¢ +⁴
¢+ ⁴
¢ỌY

ลองออนไลน์!

เอาท์พุท:

!   
 !  
  ! 
   !

มันสนุกดี

มันทำงานอย่างไร

 4=þ    Link 1 (nilad): Generate an identity matrix of size 4
¢ +⁴    Link 2 (nilad): Add 16 to above
¢+ ⁴    Link 3 (nilad): Add 16 again
¢ỌY     Main link (nilad): Convert the above to ASCII chars, and join by newline

ส่วนที่ง่าย: เยลลี่ไม่สนใจช่องว่าง (ตราบเท่าที่มีการใช้บิวด์อินเดียวเท่านั้น)

ส่วนที่ยาก: แต่ละบรรทัดในเยลลี่เป็นลิงค์แยกต่างหาก (หรือฟังก์ชั่น) ดังนั้นจึงไม่สั้นมากในการกระจายคำสั่งคงที่ในหลายบรรทัด การใช้สตริงตัวอักษรเป็นตัวเลือกที่ดี แต่ไม่รู้ว่าจะสร้างค่าลบได้อย่างไร