Considera un quadrato di caratteri ASCII stampabili (punti di codice da 0x20 a 0x7E) per la lunghezza del lato N , come il seguente (qui, N = 6 ):

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

Richiediamo inoltre che ogni riga e ogni colonna contengano almeno 1 spazio e 1 carattere non spaziale . (L'esempio sopra soddisfa questo.)

Definiamo il negativo di un tale quadrato, per essere un quadrato della stessa dimensione, in cui ogni spazio è sostituito da un non-spazio e viceversa. Ad esempio, il seguente sarebbe un valido negativo dell'esempio precedente:

  1234
a b cd  
 ZYXWV
   !  
{} [ ] 
  ?   

La scelta di caratteri non spaziali è irrilevante (purché provengano dall'intervallo ASCII stampabile).

La sfida

Devi scrivere un programma, con codice sorgente quadrato con lunghezza del lato N> 1 , che stampa un negativo di se stesso su STDOUT. Gli spazi finali devono essere stampati. È possibile o meno stampare una nuova riga finale.

Si applicano anche le solite regole quine, quindi non è necessario leggere il proprio codice sorgente, direttamente o indirettamente. Allo stesso modo, non devi assumere un ambiente REPL, che stampa automaticamente il valore di ogni espressione immessa.

Il vincitore è il programma con la più bassa lunghezza del lato N . In caso di pareggio, vince l'invio con il minor numero di caratteri non spaziali nel codice sorgente. Se c'è ancora un pareggio, vince la prima risposta.

CJam, 4 x 4 (8 non spazi)

 L _
{ _ 
 _ }
_ p 

Provalo online nell'interprete CJam .

Produzione

{ _ 
 _ }
{ _ 
 _ }

Come funziona

• Linvia un array vuoto e ne _invia una copia.

• Il blocco

  { _ 
   _ }
  

  spinge quel blocco in pila.

• _invia una copia del blocco di codice e lo pstampa, seguito da un avanzamento riga.

• Infine, l'interprete stampa tutti gli elementi rimanenti nello stack: due array vuoti che non influiscono sull'output e il blocco di codice originale.

Versione alternativa

 L ~
{ _ 
 p }
_ ~ 

Provalo online nell'interprete CJam .

Produzione

{ _ 
 p }
{ _ 
 p }

Come funziona

• Lspinge un array vuoto e lo ~scarica. Lo stack è di nuovo vuoto.

• Il blocco

  { _ 
   p }
  

  spinge quel blocco in pila.

• _ spinge una copia del blocco e ~ esegue la copia.

  L' _interno della copia del blocco spingerà una copia del blocco originale, che pverrà stampato, seguito da un avanzamento riga.

• Infine, l'interprete stampa l'elemento rimanente nello stack: il blocco di codice originale.

Perl, 7 × 7 (42 non spazi)

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

Produzione:

      7
     7 
    7  
   7   
  7    
 7     
7      

CJam, 4X4 ( 12 10 non spazi)

 6, 
SS +
* 4/
 N* 

Produzione:

0  1
  2 
 3  
4  5

Versione precedente con 12 non spazi:

 4a4
* 4S
** 4
/N* 

E l'output è

4   
 4  
  4 
   4

Come sottolineato da Martin, questa versione ha

• 4 spazi,
• 4 * ,
• 4 4 ,
• Altri 4 personaggi e
• 4 4 come uscita

;)

Provalo online qui

Marbelous - 16x16

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

Provalo qui! Gli spazi come spazi vuoti, bordo cilindrico e includono librerie devono essere controllati.

Produzione

              07
            06  
          05    
        04      
      03        
    02          
  01            
01              

Spiegazione

Ci sono due schede qui: la scheda principale (mostrata sotto) e la ssscheda, che non accetta input e genera due spazi (0x20) su STDOUT.

Una cella vuota equivale a .., e qualsiasi cosa dopo a #è un commento.

Ogni tick, ssgenera due spazi su STDOUT.

Il percorso verde è un semplice ciclo che genera una nuova riga (0x0A) alla fine di ogni 7 ° tick.

Il percorso blu produrrà i numeri ( Hpstampa un marmo come due cifre esadecimali) presenti nell'output, alla fine di ogni 6 ° tick.

Dopo aver stampato 01una volta, il ciclo termina e si sposta lungo il percorso rosso, che duplica questo marmo.

Viene stampato un duplicato (il secondo 01) e l'altro viene inviato lungo il percorso nero, che termina la scheda nella !!cella. A causa della posizione Hpdell'usato in quest'ultima stampa, 01appare prima dello stesso segno di spunta due spazi, piuttosto che dopo, il comportamento di ogni altra Hpchiamata.

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

Produzione

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

È una soluzione piuttosto disordinata e noiosa, ma ho solo pensato di mostrare che ...

1. Può essere fatto in Python
2. Se riesci a comprimere informazioni sul tuo codice più brevi del tuo codice, puoi estrarre qualcosa del genere :)

Questa soluzione sfrutta il fatto che, se ti trovi all'interno di una coppia di parentesi in Python, puoi dividere il codice su più righe e aggiungere arbitrariamente spazi senza ottenere un IndentationError. Un altro modo di fare qualcosa del genere è terminare la linea con una barra rovesciata.

Python - 7x7 (37 non spazi)

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

Produzione

      1
      1
      1
      1
      1
      1
111111 

Utilizza il vecchio %operatore di formattazione delle stringhe di Python per fare il lavoro: +7e -7prenditi cura della giustificazione destra / sinistra, e dell'ultimo spazio per abbinare la parentesi di chiusura, printin particolare. Nel preparare la stringa di formato, abbiamo anche

• concatenazione automatica dei letterali di stringa tra le righe e
• ripetizione stringa per moltiplicazione (dandoci più campi di sostituzione al prezzo di uno)

JavaScript (9x9)

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

Produzione

1        
 1       
  1      
   1     
    1    
     1   
      1  
       1 
        1

Appunti

Ho creato e giocato a golf (al meglio delle mie capacità) il codice per un quadrato con diagonale di qualsiasi dimensione n:

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

sostituendo i numeri *** asdf *** con costanti in base alla lunghezza del lato n, ad esempio per n = 6:

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

Ma, anche se quel codice ha lunghezza 46, non sono riuscito a ottenere lo spazio costante per allinearlo con uno spazio nella diagonale del codice fino a quando non era grande come un 9x9, con una linea sprecata (la 5a)

Modifica: modificato per aggiungere avviso (). Prima:

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

CJam, 5x5, 12 non spazi

Non un vincitore, ma volevo aggiungere una presentazione piuttosto piccola e sparsa , poiché la maggior parte delle risposte stampa solo una diagonale.

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

stampe

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

Provalo qui.

Gli ultimi due caratteri del codice, non fanno nulla, quindi in realtà ha solo 10 byte di codice reale. Per una griglia più piccola, potrei addirittura ridurla di altri due byte a 8, ma questo non si adatta a 3x3 e questo codice non funziona anche con dimensioni della griglia.

Come funziona:

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

Non ho idea del perché l'ho fatto. Ci sono voluti modo troppo a lungo. Adesso ho un forte mal di testa.

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

Produzione:

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

Qualche spiegazione

Il codice utilizza gper leggere i @caratteri dalla griglia "al volo" (e anche lo spazio finale, che è @ / 2), e pper modificare il ciclo per scrivere l'ultima riga di output.

Ogni singolo carattere del codice viene utilizzato ad un certo punto, come codice o come dati (il 9e il @sulle ultime due righe).

Fondamentalmente ho dovuto fare molte soluzioni alternative per far funzionare il codice. Il puntatore dell'istruzione esegue più intersezioni durante l'esecuzione, di cui alcune vengono saltate. (Non ho potuto usare alcuna istruzione lì per direzioni diverse in quanto interferirebbero. Non c'è NOP.) Altrove ho riutilizzato lo stesso personaggio o semplicemente annullato (vedi $:il centro).

Ho anche fatto un lavoro creativo nello stack:

• Quando termina il ciclo di scrittura del carattere (interno) (tutti gli spazi fatti per questa riga), lo stack ha n,0. Devo quindi diminuire n. La soluzione ovvia sarebbe $1-, ma sono riuscito ad accorciarlo usando !-.
• Quando termina il ciclo di scrittura (esterno) delle linee (stampate tutte le linee normali), la pila ha a 0. Ho quindi organizzato il code changer ( 20g46p7g46\p) per usarlo 0, invece di sprecare 2 caratteri $0.

Python 3, 8x8

Ci sono 50 caratteri non spaziali e 14 spazi. L'ultima riga ha un carattere inutile, ma tutto il resto è necessario.

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

Produzione:

       p
       p
ppppppp 
       p
       p
       p
       p
       p

Rubino, 8x8

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

Produzione:

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7

CJam, 5X5

SSSS 
1N]4 
*B11 
    S

E l'output è

    1
    1
    1
    1
1111 

Ero così vicino alla soluzione 4X4. <sigh>Vedi la mia altra risposta

Provalo online qui

C ++, 12x12

Modifica: Quindi, sono diventato un po 'ossessionato da questa sfida e sono riuscito a farlo scendere da 17x17 a 12x12. Mi ci è voluto un po 'di tempo per capire che potevo usare /**/come delimitatore di token. Questo codice sfrutta il fatto che una giunzione di riga funziona ancora in Clang con uno spazio dopo di essa, sebbene fornisca avvertimenti e rovini la colorazione del codice da parte di Xcode.

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

Produzione:

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

Befunge-98 , 8x8 (56 non spazi [11 nops])

Nota: nell'interesse di una buona nave sportiva-persona, questo legge la propria fonte via ', rendendola un cheat-quine per alcuni. Leggi il dibattito qui .

Programma

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

Produzione

(       
 ,      
  &     
   %    
    $   
     #  
      " 
       !

Spiegazione

La versione senza golf

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

(non-spazio e spazio sono sostituiti con 'n' e per motivi di leggibilità.)

Questa soluzione si basa sul fatto che usando un indice index [0, width ^ 2) la larghezza del quadrato può dirti se sei alla fine della riga o sulla diagonale. Poiché tutti gli spazi sono posizionati lungo la diagonale, è facile dire quando stampare un non-spazio!

In Pseudocodice

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

Discussione

Ne sono molto orgoglioso, anche se vorrei poter rendere ogni non-spazio anche un non-no. Sono anche orgoglioso di non aver usato il trope get-increment-put standard di Befunge! Stampa diversi simboli per il non-spazio perché avevo spazio per esso e non volevo essere noioso.

Provalo su Windows con BefungeSharp !

CJam, 4 x 4 (8 non spazi)

 N a
` S 
 * N
X $ 

Provalo online nell'interprete CJam .

Produzione

[ " 
 " ]
[ " 
 " ]

Come funziona

• Nspinge un avanzamento di riga come una stringa singleton. aavvolge quella stringa in un array.

• ` controlla il risultato, ovvero invia una rappresentazione in formato stringa dell'array.

  Questo è il risultato:

  ["
  "]
  

• S*unisce la stringa risultante (matrice di caratteri), separandone gli elementi usando gli spazi. In altre parole, inserisce uno spazio tra tutte le coppie di caratteri adiacenti della stringa.

  Questo è il risultato:

  [ " 
   " ]
  

• N spinge un altro avanzamento di riga.

• X$ copia l'elemento dello stack nell'indice 1 (contando dall'alto), ovvero la stringa multilinea.

• Infine, l'interprete stampa tutti gli elementi nello stack: la stringa multilinea originale, l'alimentazione di linea e la copia della stringa multilinea.

SOGL V0.12 , 2x2 (2 non spazi)

2 
 ╚

Provalo qui!

Produzione

 /
/ 

Spiegazione

In SOGL tutte le righe tranne l'ultima sostituiscono le righe - sostituisce ovunque nel codice continuo l'ultimo carattere della riga con tutto ciò che lo precede. Quindi la prima riga qui è replace space with 2 in the next line.
Quindi la riga successiva - 2╚viene eseguita: 2spinge 2 e ╚crea una diagonale di dimensione 2.

CBM BASIC v2.0 (8 × 8)

Un miglioramento rispetto alla mia risposta precedente , utilizzando un approccio completamente diverso:

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

Produzione:

       ?
       ?
       ?
       ?
       ?
       ?
       ?
-262144 

Rubino, 8x8 7x7

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

Produzione:

f      
f      
f      
f      
f      
f      
 ffalse

Versione precedente, 8x8 con 20 spazi:

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

Produzione:

ff     
ff     
ff     
ff     
ff     
ff
ff     
  ffalse

Pushy , 4x4 quadrato

Non competitiva in quanto la lingua postdatizza la sfida:

Codice:

 H32
2 C4
:" } 
\o/

Uscite:

d   
 d  
  d 
   d

Provalo online!

Poiché lo spazio bianco è irrilevante in Pushy, il codice è facilmente organizzato in modo da corrispondere al negativo del suo output. Il programma attuale è simile al seguente:

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

Le barre rovesciate iniziano un commento, quindi il trascinamento \o/è lì solo per completare il negativo e apparire alla moda.

In alternativa, per lo stesso punteggio, possiamo avere le seguenti soluzioni:

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

Definisce una funzione di supporto a ! bche stampa una linea del modulo bbbbbbbbbae una funzione ricorsiva n & cche stampa le nlinee del modulo ccccccccc␣seguite da una linea del modulo ␣␣␣␣␣␣␣␣␣c.

Usa <$( fmap const, di nuovo) su un intervallo per ripetere un personaggio. Si noti che <$è disponibile solo senza importazioni dal GHC 7.10, che post-date questa sfida.Non sono del tutto sicuro se questo rende questa presentazione non competitiva.

Niente di veramente eccitante con la scelta del layout o dell'algoritmo qui; Non avevo molti byte da risparmiare ed è solo una fortuna che le interruzioni di linea si verifichino in putStrLnquesto modo.

05AB1E , 3x3 (6 byte non spaziali )

 3Ð
Λ q
°° 

Produzione:

3  
 3 
  3

Provalo online.

Spiegazione:

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

Ho trascorso un whlie guardando attraverso questi ed ero sicuro che ci sarebbe stata una soluzione Perl più piccola di 7x7 in qualche modo ... Una sfida molto divertente! Questa soluzione richiede-E .

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

Uso:

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

Produzione:

     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:

Produzione:

        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        

C (gcc) , 7x7 8x8

EDIT: la versione precedente aveva un comportamento errato.

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

Provalo online!

Gelatina , 4 x 4 (12 non spazi)

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

Provalo online!

Produzione:

!   
 !  
  ! 
   !

Questo è stato abbastanza divertente.

Come funziona

 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 facile: Jelly ignora gli spazi bianchi (purché vengano utilizzati solo built-in a un byte).

Parte difficile: ogni riga in Jelly è un collegamento (o una funzione) separato, quindi non è molto breve diffondere un'istruzione costante su più righe. L'uso di una stringa letterale è un buon candidato, ma non ho idea di come generare il negativo.