考虑边长为N的正方形可打印ASCII字符（代码点0x20至0x7E），如下所示（此处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打印，然后换行。

• 最后，解释器将所有剩余的项目打印在堆栈上：两个不影响输出的空数组，以及原始代码块。

替代版本

 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不带输入且向STDOUT输出两个空格（0x20）的板。

空白单元格等同于..，而a之后的所有内容#均为注释。

每个刻度线，将ss两个空格输出到STDOUT。

绿色路径是一个简单的循环，在第7个刻度线的末尾输出换行符（0x0A）。

蓝色路径将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. 如果您可以压缩比代码短的有关代码的信息，那么您可以进行如下操作：）

该解决方案利用了以下事实的优势：如果您在Python中处于一对括号内，则可以将代码分成几行，并任意添加空格而无需获取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

笔记

我制作并打高尔夫球（尽我所能）编码一个正方形，对角线的大小为n：

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

根据边长n用常数替换*** asdf ***数字，例如对于n = 6：

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

但是，即使该代码的长度为46，我也无法获得恒定的空间来与代码对角线中的空间对齐，直到它与9x9一样大，并浪费了一行（第5个）

编辑：更改为添加alert（）。之前：

 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读取@网格中的字符（还有最后一个空格@ / 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

Ruby，8x8

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

输出：

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7

果酱，5X5

SSSS 
1N]4 
*B11 
    S

输出是

    1
    1
    1
    1
1111 

我当时接近4X4解决方案。<sigh>看到我的其他答案

在这里在线尝试

C ++，12x12

编辑：所以，我对这个挑战有些痴迷，并设法将其从17x17降低到12x12。我花了一段时间才意识到我可以/**/用作令牌定界符。该代码利用了以下事实：行拼接仍然可以在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和'代替。）

此解决方案基于以下事实：使用索引[0，width ^ 2）mod的正方形的宽度可以告诉您是在行的末尾还是对角线上。由于所有空间都沿对角线放置，因此很容易分辨何时打印非空间！

在伪代码中

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

讨论区

我为此感到非常自豪，尽管我希望我可以使每个非空格都变为非空白。我也为没有使用标准的Befunge get-put-tro望远镜而感到自豪！它为非空格打印出不同的符号，因为我有足够的空间并且不想感到无聊。

在Windows上使用BefungeSharp尝试一下！

CJam，4 x 4（8个非空格）

 N a
` S 
 * N
X $ 

在CJam解释器中在线尝试。

输出量

[ " 
 " ]
[ " 
 " ]

这个怎么运作

• N将换行作为单例字符串推送。a将该字符串包装在数组中。

• ` 检查结果，即，它推送数组的字符串表示形式。

  结果如下：

  ["
  "]
  

• S*连接结果字符串（字符数组），并使用空格分隔其元素。换句话说，它在字符串的所有成对相邻字符之间放置一个空格字符。

  结果如下：

  [ " 
   " ]
  

• N 推动另一个换行。

• X$ 复制索引为1（从顶部开始计数）的堆栈项，即多行字符串。

• 最后，解释器将所有项目打印在堆栈上：原始多行字符串，换行符和多行字符串的副本。

SOGL V0.12，2x2（2个非空格）

2 
 ╚

在这里尝试！

输出量

 /
/ 

说明

在SOGL中，除了最后一行以外的所有行都是替换行-它将在连续代码中的所有位置替换该行的最后一个字符，并替换之前的所有内容。所以这里的第一行是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 

Ruby，8x8 7x7

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

输出：

f      
f      
f      
f      
f      
f      
 ffalse

以前的版本，带有20个空格的8x8：

  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，以及一个递归函数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个非空格）

我花了很多时间浏览这些内容，并确保以某种方式小于7x7的Perl解决方案……这是一个非常有趣的挑战！此解决方案需要-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

简单的部分：Jelly忽略空格（只要只使用一字节的内置函数）。

困难的部分：Jelly中的每一行都是单独的链接（或函数），因此将常量语句分布在多行中并不是很短。使用字符串文字是一个很好的选择，但不知道如何生成否定的。