Hãy xem xét một hình vuông các ký tự ASCII có thể in (mã điểm 0x20 đến 0x7E) cho độ dài cạnh N , như sau (ở đây, N = 6 ):

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

Chúng tôi cũng yêu cầu mỗi hàng và mỗi cột phải chứa ít nhất 1 khoảng trắng và 1 ký tự không phải dấu cách. (Ví dụ trên thỏa mãn điều này.)

Chúng tôi xác định âm của một hình vuông như vậy, là một hình vuông có cùng kích thước, trong đó mỗi không gian được thay thế bằng một không gian và ngược lại. Ví dụ, sau đây sẽ là một phủ định hợp lệ của ví dụ trên:

  1234
a b cd  
 ZYXWV
   !  
{} [ ] 
  ?   

Việc lựa chọn các ký tự không phải là không gian là không liên quan (miễn là chúng thuộc phạm vi ASCII có thể in được).

Các thách thức

Bạn đang viết một chương trình, với mã nguồn vuông có độ dài cạnh N> 1 , nó sẽ in một số âm của chính nó sang STDOUT. Không gian lưu trữ phải được in. Bạn có thể hoặc không thể in một dòng mới.

Các quy tắc quine thông thường cũng được áp dụng, vì vậy bạn không được đọc mã nguồn của riêng mình, trực tiếp hoặc gián tiếp. Tương tự, bạn không được giả sử môi trường REPL, tự động in giá trị của từng biểu thức đã nhập.

Người chiến thắng là chương trình với chiều dài phía thấp nhất N . Trong trường hợp hòa, bài nộp có ít ký tự không gian nhất trong mã nguồn sẽ thắng. Nếu vẫn còn hòa, câu trả lời sớm nhất sẽ thắng.

CJam, 4 x 4 (8 không gian)

 L _
{ _ 
 _ }
_ p 

Hãy thử trực tuyến trong trình thông dịch CJam .

Đầu ra

{ _ 
 _ }
{ _ 
 _ }

Làm thế nào nó hoạt động

• Lđẩy một mảng trống và _đẩy một bản sao của nó.

• Khối

  { _ 
   _ }
  

  đẩy khối đó lên ngăn xếp.

• _đẩy một bản sao của khối mã và pin nó, theo sau là một dòng cấp.

• Cuối cùng, trình thông dịch in tất cả các mục còn lại trên ngăn xếp: hai mảng trống không ảnh hưởng đến đầu ra và khối mã gốc.

Phiên bản thay thế

 L ~
{ _ 
 p }
_ ~ 

Hãy thử trực tuyến trong trình thông dịch CJam .

Đầu ra

{ _ 
 p }
{ _ 
 p }

Làm thế nào nó hoạt động

• Lđẩy một mảng trống và ~đổ nó. Ngăn xếp lại trống rỗng.

• Khối

  { _ 
   p }
  

  đẩy khối đó lên ngăn xếp.

• _đẩy một bản sao của khối và ~thực hiện bản sao.

  Bản _sao bên trong khối sẽ đẩy một bản sao của khối ban đầu, psẽ in, theo sau là một dòng cấp.

• Cuối cùng, trình thông dịch in ra mục còn lại trên ngăn xếp: khối mã gốc.

Perl, 7 × 7 (42 không gian)

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

Đầu ra:

      7
     7 
    7  
   7   
  7    
 7     
7      

CJam, 4X4 ( 12 10 không gian)

 6, 
SS +
* 4/
 N* 

Đầu ra:

0  1
  2 
 3  
4  5

Phiên bản trước với 12 không gian:

 4a4
* 4S
** 4
/N* 

Và đầu ra là

4   
 4  
  4 
   4

Như Martin đã chỉ ra, phiên bản này có

• 4 không gian,
• 4 * ,
• 4 4 ,
• 4 nhân vật khác, và
• 4 4 là đầu ra

;)

Dùng thử trực tuyến tại đây

Tuyệt vời - 16x16

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

Kiểm tra nó ở đây! Không gian như khoảng trống, bảng hình trụ, và bao gồm tất cả các thư viện phải được kiểm tra.

Đầu ra

              07
            06  
          05    
        04      
      03        
    02          
  01            
01              

Giải trình

Có hai bảng ở đây: bảng chính (hiển thị bên dưới) và ssbảng không có đầu vào và đầu ra hai khoảng trắng (0x20) thành STDOUT.

Một ô trống tương đương với a ..và bất cứ điều gì sau #một bình luận.

Mỗi đánh dấu, ssxuất ra hai khoảng trắng thành STDOUT.

Đường dẫn màu xanh lá cây là một vòng lặp đơn giản tạo ra một dòng mới (0x0A) vào cuối mỗi tích tắc thứ 7.

Đường dẫn màu xanh sẽ xuất ra các số ( Hpin một viên bi dưới dạng hai chữ số hex) có trong đầu ra, ở cuối mỗi thứ 6.

Sau khi chúng tôi đã in 01một lần, vòng lặp kết thúc và di chuyển xuống đường dẫn màu đỏ, trùng lặp với viên bi này.

Một bản sao được in (cái thứ hai 01) và cái còn lại được gửi xuống đường dẫn màu đen, chấm dứt bảng ở !!ô. Do vị trí Hpđược sử dụng trong lần in cuối cùng này, 01xuất hiện trước hai khoảng trắng của cùng một dấu, thay vì sau, hành vi của mọi Hpcuộc gọi khác .

Con trăn - 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]]

Đầu ra

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

Đó là một giải pháp khá lộn xộn và nhàm chán, nhưng tôi chỉ nghĩ rằng tôi đã cho thấy rằng ...

1. Nó có thể được thực hiện bằng Python
2. Nếu bạn có thể nén thông tin về mã của mình ngắn hơn mã của mình, thì bạn có thể rút ra một cái gì đó như thế này :)

Giải pháp này lợi dụng thực tế là, nếu bạn nằm trong một cặp dấu ngoặc trong Python, thì bạn có thể chia mã của mình thành nhiều dòng và tùy ý thêm khoảng trắng mà không cần lấy IndentationError. Một cách khác để làm một cái gì đó như thế này là bằng cách kết thúc dòng bằng dấu gạch chéo ngược.

Python - 7x7 (37 không gian)

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

Đầu ra

      1
      1
      1
      1
      1
      1
111111 

Sử dụng %toán tử định dạng chuỗi cũ của Python để thực hiện công việc: +7và -7quan tâm đến việc chứng minh phải / trái và không gian cuối cùng để khớp với dấu ngoặc đơn đóng printcụ thể. Khi chuẩn bị chuỗi định dạng, chúng ta cũng có

• tự động nối chuỗi ký tự chuỗi trên các dòng và
• lặp lại chuỗi bằng cách nhân (cung cấp cho chúng tôi nhiều trường thay thế cho giá của một)

JavaScript (9x9)

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

Đầu ra

1        
 1       
  1      
   1     
    1    
     1   
      1  
       1 
        1

Ghi chú

Tôi đã thực hiện và đánh gôn (với khả năng tốt nhất của mình) cho một hình vuông có đường chéo có kích thước n:

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

thay thế các số *** asdf *** bằng các hằng số phụ thuộc vào độ dài cạnh n, ví dụ cho n = 6:

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

Nhưng, mặc dù mã đó có độ dài 46, tôi không thể có không gian liên tục để xếp hàng với một khoảng trắng theo đường chéo của mã cho đến khi nó lớn bằng 9x9, với một dòng bị lãng phí (dòng thứ 5)

Chỉnh sửa: Thay đổi để thêm cảnh báo (). Trước:

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

CJam, 5x5, 12 không gian

Không phải là người chiến thắng, nhưng tôi muốn thêm một bài nộp khá nhỏ và thưa thớt , vì hầu hết các câu trả lời chỉ in một đường chéo.

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

in

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

Kiểm tra nó ở đây.

Hai ký tự cuối cùng của mã, không làm gì cả, vì vậy nó thực sự chỉ có 10 byte mã thực. Đối với lưới nhỏ hơn, tôi thậm chí có thể giảm hai byte khác xuống còn 8 byte, nhưng điều đó không phù hợp với 3x3 và mã này không hoạt động đối với các kích thước lưới chẵn.

Làm thế nào nó hoạt động:

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

Tôi không biết tại sao tôi làm điều này. Nó đã đi quá lâu. Bây giờ tôi bị đau đầu dữ dội.

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

Đầu ra:

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

Một số giải thích

Mã này sử dụng gđể đọc các @ký tự từ lưới "đang hoạt động" (và cũng là không gian cuối cùng @ / 2) và psửa đổi vòng lặp để viết dòng đầu ra cuối cùng.

Mỗi ký tự trên mã được sử dụng tại một số điểm, dưới dạng mã hoặc dưới dạng dữ liệu ( 9và @trên hai dòng cuối cùng).

Về cơ bản tôi đã phải làm rất nhiều cách giải quyết để làm cho mã hoạt động. Con trỏ lệnh thực hiện nhiều giao điểm trong khi thực hiện, trong đó một số được nhảy qua. (Tôi không thể sử dụng bất kỳ hướng dẫn nào ở đó cho các hướng khác nhau vì chúng sẽ can thiệp. Không có NOP.) Ở những nơi khác, tôi có thể sử dụng lại cùng một nhân vật hoặc chỉ xóa nó (xem phần$: ở giữa).

Tôi cũng đã làm một số công việc sáng tạo trên ngăn xếp:

• Khi vòng lặp viết ký tự (bên trong) chấm dứt (tất cả các khoảng trắng được thực hiện cho dòng này), ngăn xếp có n,0. Sau đó tôi phải giảm giá n. Giải pháp rõ ràng là $1-, nhưng tôi đã rút ngắn nó bằng cách sử dụng!- .
• Khi vòng lặp ghi dòng (bên ngoài) chấm dứt (tất cả các dòng bình thường được in), ngăn xếp có a 0. Sau đó tôi đã tổ chức bộ đổi mã ( 20g46p7g46\p) để sử dụng nó 0, thay vì lãng phí 2 ký tự trên $0.

Trăn 3, 8/8

Có 50 nhân vật không gian và 14 không gian. Dòng cuối cùng có một nhân vật vô dụng, nhưng mọi thứ khác là cần thiết.

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

Đầu ra:

       p
       p
ppppppp 
       p
       p
       p
       p
       p

Ruby, 8/8

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

Đầu ra:

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7

CJam, 5x30

SSSS 
1N]4 
*B11 
    S

Và đầu ra là

    1
    1
    1
    1
1111 

Tôi đã gần với giải pháp 4X4 này. <sigh>Xem câu trả lời khác của tôi

Dùng thử trực tuyến tại đây

C ++, 12x12

Chỉnh sửa: Vì vậy, tôi trở nên hơi bị ám ảnh với thử thách này và đã cố gắng giảm nó từ 17x17 xuống 12x12. Phải mất một lúc tôi mới nhận ra mình có thể sử dụng /**/như một dấu phân cách mã thông báo. Mã này lợi dụng thực tế là một mối nối dòng vẫn hoạt động trong Clang với một khoảng trắng sau nó, mặc dù nó đưa ra các cảnh báo và làm hỏng màu sắc mã của Xcode.

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

Đầu ra:

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

Befunge-98 , 8x8 (56 không gian [11 nops])

Lưu ý: Vì lợi ích của người chơi thể thao tốt, điều này đọc nguồn của chính nó thông qua ', làm cho nó trở thành một trò lừa đảo đối với một số người. Đọc cuộc tranh luận ở đây .

Chương trình

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

Đầu ra

(       
 ,      
  &     
   %    
    $   
     #  
      " 
       !

Giải trình

Phiên bản không chơi gôn

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

(không phải không gian và không gian được thay thế bằng 'n và' vì mục đích dễ đọc.)

Giải pháp này dựa trên thực tế là sử dụng một chỉ số [0, chiều rộng ^ 2), chiều rộng của hình vuông có thể cho bạn biết nếu bạn ở cuối hàng hoặc trên đường chéo. Vì tất cả các không gian được đặt dọc theo đường chéo, thật dễ dàng để biết khi nào cần in một không gian!

Trong mã giả

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

Thảo luận

Tôi rất tự hào về điều đó, mặc dù tôi ước mình có thể biến mọi thứ ngoài không gian cũng trở thành không phải là không. Tôi cũng tự hào rằng tôi đã không sử dụng trope tăng-đặt Befunge tiêu chuẩn! Nó in ra các biểu tượng khác nhau cho phi không gian bởi vì tôi có chỗ cho nó và không muốn nhàm chán.

Hãy thử nó trên Windows với BefungeSharp !

CJam, 4 x 4 (8 không gian)

 N a
` S 
 * N
X $ 

Hãy thử trực tuyến trong trình thông dịch CJam .

Đầu ra

[ " 
 " ]
[ " 
 " ]

Làm thế nào nó hoạt động

• Nđẩy một linefeed dưới dạng một chuỗi singleton. akết thúc chuỗi đó trong một mảng.

• ` kiểm tra kết quả, nghĩa là, nó đẩy một chuỗi đại diện của mảng.

  Đây là kết quả:

  ["
  "]
  

• S*nối chuỗi kết quả (mảng ký tự), phân tách các phần tử của nó bằng khoảng trắng. Nói cách khác, nó đặt một ký tự khoảng trắng giữa tất cả các cặp ký tự liền kề của chuỗi.

  Đây là kết quả:

  [ " 
   " ]
  

• N đẩy dòng khác.

• X$ sao chép mục ngăn xếp ở chỉ mục 1 (tính từ đầu), tức là chuỗi nhiều dòng.

• Cuối cùng, trình thông dịch in tất cả các mục trên ngăn xếp: chuỗi nhiều dòng gốc, nguồn cấp dữ liệu và bản sao của chuỗi nhiều dòng.

SOGL V0.12 , 2x2 (2 không gian)

2 
 ╚

Hãy thử nó ở đây!

Đầu ra

 /
/ 

Giải trình

Trong SOGL, tất cả các dòng ngoại trừ dòng cuối cùng đang thay thế các dòng - nó thay thế ở mọi nơi trong mã tiếp tục ký tự cuối cùng của dòng với mọi thứ trước nó. Vì vậy, dòng đầu tiên ở đây là replace space with 2 in the next line.
Sau đó, dòng tiếp theo - 2╚được thực hiện: 2đẩy 2 và ╚tạo một đường chéo có kích thước 2.

CBM BASIC v2.0 (8 × 8)

Một cải tiến so với câu trả lời trước đây của tôi , sử dụng một cách tiếp cận hoàn toàn khác:

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

Đầu ra:

       ?
       ?
       ?
       ?
       ?
       ?
       ?
-262144 

Ruby, 8x8 7x7

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

Đầu ra:

f      
f      
f      
f      
f      
f      
 ffalse

Phiên bản trước, 8x8 với 20 khoảng trắng:

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

Đầu ra:

ff     
ff     
ff     
ff     
ff     
ff
ff     
  ffalse

Pushy , hình vuông 4 x 4

Không cạnh tranh như ngôn ngữ hoãn thách thức:

Mã số:

 H32
2 C4
:" } 
\o/

Đầu ra:

d   
 d  
  d 
   d

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

Vì khoảng trắng không liên quan trong Pushy, mã dễ dàng được sắp xếp để phù hợp với tiêu cực của đầu ra của nó. Chương trình thực tế trông như thế này:

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

Dấu gạch chéo ngược bắt đầu một nhận xét, vì vậy dấu vết \o/chỉ ở đó để hoàn thành phủ định và trông thật tuyệt.

Ngoài ra, với cùng số điểm, chúng tôi có thể có các giải pháp sau:

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&'*' 
         )

Xác định hàm trợ giúp a ! bin một dòng của biểu mẫu bbbbbbbbbavà một hàm đệ quy n & cin ncác dòng của biểu mẫu ccccccccc␣theo sau là một dòng của biểu mẫu␣␣␣␣␣␣␣␣␣c .

Sử dụng <$( fmap const, một lần nữa) trên một phạm vi để lặp lại một ký tự. Lưu ý rằng <$chỉ có sẵn mà không có nhập khẩu kể từ GHC 7.10, sau ngày thử thách này. Tôi không hoàn toàn chắc chắn nếu điều này làm cho đệ trình này không bị xóa.

Không có gì thực sự thú vị với sự lựa chọn bố trí hoặc thuật toán ở đây; Tôi đã không có nhiều byte dự phòng và thật may mắn là người ta có thể khiến các ngắt dòng xảy ra xung quanh putStrLncách họ đã làm.

05AB1E , 3x3 (6 byte không gian )

 3Ð
Λ q
°° 

Đầu ra:

3  
 3 
  3

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

Giải trình:

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 không gian)

Tôi đã dành một khoảng thời gian để xem qua những thứ này và chắc chắn sẽ có một giải pháp Perl nhỏ hơn 7x7 bằng cách nào đó ... Một thử thách rất thú vị! Giải pháp này đòi hỏi -E.

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

Sử dụng:

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

Đầu ra:

     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:

Đầu ra:

        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        

C (gcc) , 7x7 8x8

EDIT: Phiên bản trước có hành vi không chính xác.

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

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

Jelly , 4 x 4 (12 không gian)

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

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

Đầu ra:

!   
 !  
  ! 
   !

Điều này khá thú vị.

Làm thế nào nó hoạt động

 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

Phần dễ: Jelly bỏ qua khoảng trắng (miễn là chỉ sử dụng một byte được tạo ra).

Phần cứng: Mỗi dòng trong Jelly là một liên kết (hoặc hàm) riêng biệt, do đó, không quá ngắn để trải một câu lệnh không đổi trong nhiều dòng. Sử dụng một chuỗi ký tự là một ứng cử viên tốt, nhưng không biết làm thế nào để tạo ra tiêu cực.