Considere um quadrado de caracteres ASCII imprimíveis (pontos de código 0x20 a 0x7E) para o comprimento lateral N , como o seguinte (aqui, N = 6 ):

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

Também exigimos que cada linha e cada coluna contenha pelo menos 1 espaço e 1 caractere não espacial . (O exemplo acima satisfaz isso.)

Definimos o negativo de tal quadrado, como um quadrado do mesmo tamanho, onde cada espaço é substituído por um não-espaço e vice-versa. Por exemplo, o seguinte seria um negativo válido do exemplo acima:

  1234
a b cd  
 ZYXWV
   !  
{} [ ] 
  ?   

A escolha de caracteres não espaciais é irrelevante (desde que sejam do intervalo ASCII imprimível).

O desafio

Você deve escrever um programa, com um código-fonte quadrado com o comprimento do lado N> 1 , que imprima um negativo para STDOUT. Os espaços à direita devem ser impressos. Você pode ou não imprimir uma única linha nova à direita.

As regras habituais de quine também se aplicam, portanto, você não deve ler seu próprio código fonte, direta ou indiretamente. Da mesma forma, você não deve assumir um ambiente REPL, que imprime automaticamente o valor de cada expressão inserida.

O vencedor é o programa com o menor comprimento lateral N . Em caso de empate, o envio com o menor número de caracteres não espaciais no código-fonte vence. Se ainda houver um empate, a resposta mais antiga vence.

CJam, 4 x 4 (8 não espaços)

 L _
{ _ 
 _ }
_ p 

Experimente online no intérprete CJam .

Resultado

{ _ 
 _ }
{ _ 
 _ }

Como funciona

• Lempurra uma matriz vazia e _empurra uma cópia dela.

• O bloco

  { _ 
   _ }
  

  empurra esse bloco na pilha.

• _empurra uma cópia do bloco de código e o pimprime, seguido por um avanço de linha.

• Finalmente, o intérprete imprime todos os itens restantes na pilha: duas matrizes vazias que não afetam a saída e o bloco de código original.

Versão alternativa

 L ~
{ _ 
 p }
_ ~ 

Experimente online no intérprete CJam .

Resultado

{ _ 
 p }
{ _ 
 p }

Como funciona

• Lempurra uma matriz vazia e a ~despeja. A pilha está vazia novamente.

• O bloco

  { _ 
   p }
  

  empurra esse bloco na pilha.

• _empurra uma cópia do bloco e ~executa a cópia.

  A parte _interna da cópia do bloco enviará uma cópia do bloco original, que pserá impresso, seguido de um avanço de linha.

• Finalmente, o intérprete imprime o item restante na pilha: o bloco de código original.

Perl, 7 × 7 (42 não espaços)

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

Resultado:

      7
     7 
    7  
   7   
  7    
 7     
7      

CJam, 4X4 ( 12 10 não espaços)

 6, 
SS +
* 4/
 N* 

Resultado:

0  1
  2 
 3  
4  5

Versão anterior com 12 não espaços:

 4a4
* 4S
** 4
/N* 

E a saída é

4   
 4  
  4 
   4

Como apontado por Martin, esta versão tem

• 4 Espaços,
• 4 * ,
• 4 4 ,
• 4 outros caracteres e
• 4 4 como a saída

;)

Experimente online aqui

Marbelous - 16x16

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

Teste aqui! Espaços como espaços em branco, placa cilíndrica e bibliotecas de inclusão devem ser verificados.

Resultado

              07
            06  
          05    
        04      
      03        
    02          
  01            
01              

Explicação

Existem duas placas aqui: a placa principal (mostrada abaixo) e a ssplaca, que não recebe entradas e gera dois espaços (0x20) para STDOUT.

Uma célula em branco é equivalente a a .., e qualquer coisa após a #é um comentário.

Cada tick ssgera dois espaços para STDOUT.

O caminho verde é um loop simples que gera uma nova linha (0x0A) no final de cada 7º tick.

O caminho azul produzirá os números ( Hpimprime uma bola de gude com dois dígitos hexadecimais) presentes na saída, no final de cada sexto tique.

Depois de imprimir 01uma vez, o loop termina e desce o caminho vermelho, que duplica esse mármore.

Uma duplicata é impressa (a segunda 01) e a outra é enviada pelo caminho preto, que termina a placa na !!célula. Devido à localização do Hpusado nesta última impressão, ele 01aparece antes dos dois espaços do mesmo tick, e não depois, do comportamento de todas as outras Hpchamadas.

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

Resultado

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

É uma solução bastante bagunçada e chata, mas pensei em mostrar isso ...

1. Isso pode ser feito em Python
2. Se você pode compactar informações sobre seu código mais curtas que seu código, pode executar algo assim :)

Esta solução tira proveito do fato de que, se você estiver dentro de um par de colchetes no Python, poderá dividir seu código em várias linhas e adicionar espaços arbitrariamente sem obter um IndentationError. Outra maneira de fazer algo assim é encerrando a linha com uma barra invertida.

Python - 7x7 (37 não espaços)

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

Resultado

      1
      1
      1
      1
      1
      1
111111 

Usa o antigo %operador de formatação de string do Python para fazer o trabalho: +7e -7cuida da justificação direita / esquerda e do último espaço para corresponder ao parêntese de fechamento, printem particular. Ao preparar a string de formato, também temos

• concatenação automática de literais de string através de linhas e
• repetição de string por multiplicação (fornecendo vários campos de substituição pelo preço de um)

JavaScript (9x9)

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

Resultado

1        
 1       
  1      
   1     
    1    
     1   
      1  
       1 
        1

Notas

Criei e joguei golfe (da melhor maneira possível) para um quadrado com diagonal de qualquer tamanho n:

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

substituindo os números *** asdf *** por constantes, dependendo do comprimento do lado n, por exemplo, para n = 6:

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

Mas, mesmo que esse código tenha o tamanho 46, não consegui alinhar o espaço constante com um espaço na diagonal do código até que fosse tão grande quanto um 9x9, com uma linha desperdiçada (a 5ª)

Editar: alterado para adicionar alerta (). Antes:

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

CJam, 5x5, 12 não espaços

Não sou um vencedor, mas queria adicionar um envio pequeno e esparso , pois a maioria das respostas imprime apenas uma diagonal.

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

impressões

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

Teste aqui.

Os dois últimos caracteres do código não fazem nada; portanto, ele possui apenas 10 bytes de código real. Para uma grade menor, eu poderia reduzi-la em mais dois bytes para 8, mas isso não se encaixa em 3x3, e esse código não funciona para tamanhos de grade iguais.

Como funciona:

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

Eu não tenho idéia do por que fiz isso. Levou caminho muito longo. Eu tenho uma dor de cabeça enorme agora.

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

Resultado:

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

Alguma explicação

O código usa gpara ler os @caracteres da grade "on the fly" (e também o espaço final, que é @ / 2), e pmodificar o loop para escrever a última linha de saída.

Cada caractere único no código é usado em algum momento, como código ou como dados (o 9e o @nas duas últimas linhas).

Eu basicamente tive que fazer várias soluções alternativas para fazer o código funcionar. O ponteiro de instruções faz várias interseções durante a execução, das quais algumas são saltadas. (Eu não poderia usar nenhuma instrução lá para direções diferentes, pois elas interfeririam. Não existe NOP.) Em outros lugares, eu reutilizei o mesmo caractere ou apenas o desfiz (veja $:no meio).

Também fiz alguns trabalhos criativos na pilha:

• Quando o loop de gravação de caracteres (interno) termina (todos os espaços feitos para esta linha), a pilha possui n,0. Eu então tenho que diminuir n. A solução óbvia seria $1-, mas consegui reduzi-la usando !-.
• Quando o loop de escrita da linha (externa) termina (todas as linhas normais impressas), a pilha possui a 0. Organizei o changer de código ( 20g46p7g46\p) para usá-lo 0, em vez de desperdiçar 2 caracteres $0.

Python 3, 8x8

Existem 50 caracteres não espaciais e 14 espaços. A última linha tem um caráter inútil, mas tudo o mais é necessário.

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

Resultado:

       p
       p
ppppppp 
       p
       p
       p
       p
       p

Ruby, 8x8

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

Resultado:

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7

CJam, 5X5

SSSS 
1N]4 
*B11 
    S

E a saída é

    1
    1
    1
    1
1111 

Eu estava tão perto da solução 4X4. <sigh>Veja minha outra resposta

Experimente online aqui

C ++, 12x12

Edit: Então, fiquei um pouco obcecado com esse desafio e consegui reduzi-lo de 17x17 para 12x12. Demorei um pouco para perceber que eu poderia usar /**/como um delimitador de token. Esse código tira proveito do fato de que uma emenda de linha ainda funciona em Clang com um espaço a seguir, apesar de emitir avisos e arruinar a coloração do código pelo Xcode.

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

Resultado:

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

Befunge-98 , 8x8 (56 não espaços [11 nops])

Nota: No interesse de uma boa pessoa esportiva, ela lê sua própria fonte ', tornando-a um truque para alguns. Leia o debate aqui .

Programa

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

Resultado

(       
 ,      
  &     
   %    
    $   
     #  
      " 
       !

Explicação

A versão sem golfe

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

(não-espaço e espaço são substituídos por 'n' e 'para facilitar a leitura.)

Essa solução é baseada no fato de que, usando um índice [0, width ^ 2) mod, a largura do quadrado pode dizer se você está no final da linha ou na diagonal. Como todos os espaços são colocados ao longo da diagonal, é fácil saber quando imprimir um não espaço!

Em Pseudocódigo

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

Discussão

Estou muito orgulhoso disso, apesar de desejar ter feito de todos os não-espaços também um não-nop. Também estou orgulhoso de não ter usado o padrão Befunge get-increment-put trope! Ele imprime símbolos diferentes para o não-espaço, porque eu tinha espaço para isso e não queria ser chato.

Experimente no Windows com o BefungeSharp !

CJam, 4 x 4 (8 não espaços)

 N a
` S 
 * N
X $ 

Experimente online no intérprete CJam .

Resultado

[ " 
 " ]
[ " 
 " ]

Como funciona

• Nenvia um avanço de linha como uma sequência de singleton. aquebra essa string em uma matriz.

• ` inspeciona o resultado, ou seja, empurra uma representação de string da matriz.

  Este é o resultado:

  ["
  "]
  

• S*une a sequência resultante (matriz de caracteres), separando seus elementos usando espaços. Em outras palavras, coloca um caractere de espaço entre todos os pares de caracteres adjacentes da sequência.

  Este é o resultado:

  [ " 
   " ]
  

• N empurra outro avanço de linha.

• X$ copia o item da pilha no índice 1 (contando a partir do topo), ou seja, a sequência de várias linhas.

• Por fim, o intérprete imprime todos os itens da pilha: a sequência de múltiplas linhas original, o avanço de linha e a cópia da sequência de várias linhas.

SOGL V0.12 , 2x2 (2 não espaços)

2 
 ╚

Experimente aqui!

Resultado

 /
/ 

Explicação

No SOGL, todas as linhas, exceto a última, estão substituindo as linhas - ele substitui em todo lugar no código contínuo o último caractere da linha por tudo o que está antes. Então a primeira linha aqui é replace space with 2 in the next line.
Em seguida, a próxima linha - 2╚é executada: 2empurra 2 e ╚cria uma diagonal de tamanho 2.

CBM BASIC v2.0 (8 × 8)

Uma melhoria em relação à minha resposta anterior , usando uma abordagem completamente diferente:

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

Resultado:

       ?
       ?
       ?
       ?
       ?
       ?
       ?
-262144 

Rubi, 8x8 7x7

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

Resultado:

f      
f      
f      
f      
f      
f      
 ffalse

Versão anterior, 8x8 com 20 espaços:

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

Resultado:

ff     
ff     
ff     
ff     
ff     
ff
ff     
  ffalse

Pushy , quadrado 4x4

Não competir, pois o idioma pós o desafio:

Código:

 H32
2 C4
:" } 
\o/

Saídas:

d   
 d  
  d 
   d

Experimente online!

Como o espaço em branco é irrelevante no Pushy, o código é facilmente organizado para corresponder ao negativo de sua saída. O programa atual é assim:

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

As barras invertidas iniciam um comentário; portanto, o final \o/está lá para concluir o negativo e parecer legal.

Como alternativa, para a mesma pontuação, podemos ter as seguintes soluções:

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

Define uma função auxiliar a ! bque imprime uma linha do formulário bbbbbbbbbae uma função recursiva n & cque imprime nlinhas do formulário ccccccccc␣seguidas por uma linha do formulário ␣␣␣␣␣␣␣␣␣c.

Usa <$( fmap const, novamente) em um intervalo para repetir um caractere. Observe que <$só está disponível sem importações desde o GHC 7.10, que pós-data deste desafio. Não tenho muita certeza se isso torna este envio não competitivo.

Nada realmente emocionante com a escolha do layout ou algoritmo aqui; Eu não tinha muitos bytes de sobra e é uma sorte que as quebras de linha ocorram putStrLnda maneira que ocorreram .

05AB1E , 3x3 (6 bytes sem espaço )

 3Ð
Λ q
°° 

Resultado:

3  
 3 
  3

Experimente online.

Explicação:

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 não espaços)

Passei um tempo analisando essas informações e tinha certeza de que haveria uma solução Perl menor que 7x7 de alguma forma ... Um desafio muito divertido! Esta solução requer -E.

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

Uso:

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

Resultado:

     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:

Resultado:

        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        

C (gcc) , 7x7 8x8

EDIT: versão anterior teve comportamento incorreto.

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

Experimente online!

Gelatina , 4 x 4 (12 não espaços)

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

Experimente online!

Resultado:

!   
 !  
  ! 
   !

Isso foi bem divertido.

Como funciona

 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

Parte fácil: o Jelly ignora os espaços em branco (desde que apenas os bytes de um byte sejam usados).

Parte difícil: cada linha no Jelly é um link (ou função) separado, portanto não é muito curto espalhar uma declaração constante em várias linhas. Usar um literal de cadeia de caracteres é um bom candidato, mas não faz ideia de como gerar o negativo.