Betrachten Sie ein Quadrat aus druckbaren ASCII- Zeichen (Codepunkte 0x20 bis 0x7E) für die Seitenlänge N wie folgt (hier N = 6 ):

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

Wir fordern auch, dass jede Zeile und jede Spalte mindestens 1 Leerzeichen und 1 Nicht-Leerzeichen enthält . (Das obige Beispiel erfüllt dies.)

Wir definieren das Negativ eines solchen Quadrats als ein Quadrat gleicher Größe, bei dem jedes Leerzeichen durch ein Nicht-Leerzeichen ersetzt wird und umgekehrt. ZB wäre das Folgende ein gültiges Negativ des obigen Beispiels:

  1234
a b cd  
 ZYXWV
   !  
{} [ ] 
  ?   

Die Auswahl von Nicht-Leerzeichen ist irrelevant (solange sie aus dem druckbaren ASCII-Bereich stammen).

Die Herausforderung

Sie müssen ein Programm mit quadratischem Quellcode mit der Seitenlänge N> 1 schreiben , das ein Negativ von sich selbst an STDOUT ausgibt. Nachgestellte Leerzeichen müssen gedruckt werden. Sie können eine einzelne nachgestellte Zeile drucken oder nicht.

Es gelten auch die üblichen Quine-Regeln. Sie dürfen also weder direkt noch indirekt Ihren eigenen Quellcode lesen. Ebenso dürfen Sie keine REPL-Umgebung annehmen, die automatisch den Wert jedes eingegebenen Ausdrucks ausgibt.

Der Gewinner ist das Programm mit der niedrigsten Seitenlänge N . Im Falle eines Gleichstands gewinnt die Einreichung mit den wenigsten Nicht-Leerzeichen im Quellcode. Wenn es immer noch ein Unentschieden gibt, gewinnt die früheste Antwort.

Jam, 4 x 4 (8 Nicht-Leerzeichen)

 L _
{ _ 
 _ }
_ p 

Probieren Sie es online im CJam-Interpreter aus .

Ausgabe

{ _ 
 _ }
{ _ 
 _ }

Wie es funktioniert

• Lverschiebt ein leeres Array und verschiebt _eine Kopie davon.

• Der Block

  { _ 
   _ }
  

  schiebt diesen Block auf den Stapel.

• _Drückt eine Kopie des Codeblocks und pdruckt sie aus, gefolgt von einem Zeilenvorschub.

• Schließlich druckt der Interpreter alle verbleibenden Elemente auf dem Stapel: zwei leere Arrays, die sich nicht auf die Ausgabe auswirken, und den ursprünglichen Codeblock.

Alternative Version

 L ~
{ _ 
 p }
_ ~ 

Probieren Sie es online im CJam-Interpreter aus .

Ausgabe

{ _ 
 p }
{ _ 
 p }

Wie es funktioniert

• Lverschiebt ein leeres Array und gibt ~es aus. Der Stapel ist wieder leer.

• Der Block

  { _ 
   p }
  

  schiebt diesen Block auf den Stapel.

• _verschiebt eine Kopie des Blocks und ~führt die Kopie aus.

  Die _Kopie des Blocks enthält eine Kopie des ursprünglichen Blocks, die pgedruckt wird, gefolgt von einem Zeilenvorschub.

• Schließlich druckt der Interpreter das verbleibende Element auf dem Stapel: den ursprünglichen Codeblock.

Perl, 7 × 7 (42 Nicht-Leerzeichen)

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

Ausgabe:

      7
     7 
    7  
   7   
  7    
 7     
7      

CJam, 4X4 ( 12 10 Nicht-Leerzeichen)

 6, 
SS +
* 4/
 N* 

Ausgabe:

0  1
  2 
 3  
4  5

Vorgängerversion mit 12 Leerzeichen:

 4a4
* 4S
** 4
/N* 

Und die Ausgabe ist

4   
 4  
  4 
   4

Wie von Martin hervorgehoben, hat diese Version

• 4 Räume,
• 4 * ,
• 4 4 ,
• 4 weitere Zeichen und
• 4 4 als Ausgang

;)

Probieren Sie es hier online aus

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 es hier! Leerzeichen, zylindrische Platinen und Include-Bibliotheken müssen alle überprüft werden.

Ausgabe

              07
            06  
          05    
        04      
      03        
    02          
  01            
01              

Erläuterung

Hier gibt es zwei Karten: die ssHauptkarte (siehe unten) und die Karte, die keine Ein- und Ausgänge für zwei Leerzeichen (0x20) für STDOUT verwendet.

Eine leere Zelle entspricht a .., und alles nach a #ist ein Kommentar.

Jeder Tick ssgibt zwei Leerzeichen an STDOUT aus.

Der grüne Pfad ist eine einfache Schleife, die am Ende jedes siebten Ticks eine neue Zeile (0x0A) ausgibt.

Der blaue Pfad gibt die Zahlen aus ( Hpdruckt eine Murmel als zwei hexadezimale Ziffern), die am Ende jedes sechsten Ticks in der Ausgabe vorhanden sind.

Nachdem wir einmal gedruckt haben 01, endet die Schleife und bewegt sich den roten Pfad hinunter, der diese Murmel dupliziert.

Ein Duplikat wird gedruckt (das zweite 01), und das andere wird über den schwarzen Pfad gesendet, der die Karte an der !!Zelle terminiert . Aufgrund der Position des Hpin diesem letzten Ausdruck verwendeten Zeichens wird das vor den beiden Leerzeichen desselben Häkchens 01angezeigt und nicht nach dem Verhalten jedes anderen Aufrufs.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]]

Ausgabe

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

Es ist eine ziemlich schmutzige und langweilige Lösung, aber ich dachte nur, ich würde das zeigen ...

1. Dies kann in Python erfolgen
2. Wenn Sie Informationen über Ihren Code komprimieren können, die kürzer als Ihr Code sind, können Sie so etwas wie diesen abrufen :)

Diese Lösung nutzt die Tatsache, dass Sie, wenn Sie sich in Python in zwei Klammern befinden, Ihren Code auf mehrere Zeilen aufteilen und willkürlich Leerzeichen hinzufügen können, ohne ein zu erhalten IndentationError. Eine andere Möglichkeit besteht darin, die Zeile mit einem Backslash zu beenden.

Python - 7x7 (37 Nicht-Leerzeichen)

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

Ausgabe

      1
      1
      1
      1
      1
      1
111111 

Verwendet Python alt %Zeichenfolge Formatierung Bediener die Arbeit zu erledigen: +7und -7kümmern sich um Rechts- / Links - Ausrichtung und den letzten Raum die schließende Klammer passend für printinsbesondere. Bei der Vorbereitung des Formatstrings haben wir auch

• automatische Verkettung von Zeichenkettenliteralen über Zeilen hinweg und
• String-Wiederholung durch Multiplikation (wir erhalten mehrere Ersatzfelder zum Preis von einem)

JavaScript (9 x 9)

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

Ausgabe

1        
 1       
  1      
   1     
    1    
     1   
      1  
       1 
        1

Anmerkungen

Ich habe (nach bestem Wissen und Gewissen) einen Code für ein Quadrat mit einer Diagonale beliebiger Größe n erstellt und gespielt:

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

Ersetzen der *** asdf *** -Zahlen durch Konstanten in Abhängigkeit von der Seitenlänge n, zum Beispiel für n = 6:

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

Aber obwohl dieser Code die Länge 46 hat, konnte ich den konstanten Abstand nicht mit einem Abstand in der Diagonale des Codes ausrichten, bis er so groß war wie ein 9x9, mit einer verschwendeten Zeile (der fünften).

Bearbeiten: Geändert, um eine Warnung hinzuzufügen (). Vor:

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

CJam, 5x5, 12 Nicht-Leerzeichen

Kein Gewinner, aber ich wollte eine eher kleine und spärliche Einsendung hinzufügen , da die meisten Antworten nur eine Diagonale drucken.

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

druckt

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

Teste es hier.

Die letzten beiden Zeichen des Codes haben nichts zu tun, es sind also nur 10 Byte realer Code enthalten. Für ein kleineres Raster könnte ich es sogar um weitere zwei Bytes auf 8 reduzieren, aber das passt nicht für 3x3, und dieser Code funktioniert nicht für gerade Rastergrößen.

Wie es funktioniert:

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

Ich habe keine Ahnung, warum ich das getan habe. Es hat viel zu lange gedauert. Ich habe jetzt massive Kopfschmerzen.

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

Ausgabe:

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

Eine Erklärung

Der Code gliest die @Zeichen aus dem Raster "on the fly" (und auch das letzte Leerzeichen @ / 2) und pmodifiziert die Schleife, um die letzte Ausgabezeile zu schreiben.

Jedes einzelne Zeichen im Code wird irgendwann entweder als Code oder als Daten verwendet (das 9und das @in den beiden letzten Zeilen).

Ich musste im Grunde eine Menge Workarounds machen, um den Code zum Laufen zu bringen. Der Befehlszeiger führt während der Ausführung mehrere Schnittpunkte aus, von denen einige übersprungen werden. (Ich konnte dort keine Anweisung für verschiedene Richtungen verwenden, da sie stören würde. Es gibt keine NOP.) An anderer Stelle habe ich entweder dasselbe Zeichen wiederverwendet oder es einfach wieder rückgängig gemacht (siehe $:in der Mitte).

Ich habe auch ein paar kreative Arbeiten am Stack gemacht:

• Wenn die (innere) Zeichenschreibschleife endet (alle Leerzeichen für diese Zeile), hat der Stapel n,0. Ich muss dann dekrementieren n. Die naheliegende Lösung wäre $1-, aber ich habe es geschafft, sie mit Hilfe von zu verkürzen !-.
• Wenn die (äußere) Zeilenschreibschleife endet (alle normalen Zeilen gedruckt), hat der Stapel ein 0. Ich organisierte dann Code Changer ( 20g46p7g46\p), um das zu verwenden 0, anstatt 2 Zeichen weiter zu verschwenden $0.

Python 3, 8x8

Es gibt 50 Nicht-Leerzeichen und 14 Leerzeichen. Die letzte Zeile hat einen unnützen Charakter, aber alles andere ist notwendig.

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

Ausgabe:

       p
       p
ppppppp 
       p
       p
       p
       p
       p

Rubin, 8x8

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

Ausgabe:

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7

CJam, 5X5

SSSS 
1N]4 
*B11 
    S

Und die Ausgabe ist

    1
    1
    1
    1
1111 

Ich war so nah an 4X4 Lösung. <sigh>Siehe meine andere Antwort

Probieren Sie es hier online aus

C ++, 12 × 12

Edit: Also war ich ein bisschen besessen von dieser Herausforderung und habe es geschafft, sie von 17x17 auf 12x12 zu reduzieren. Es dauerte eine Weile, bis mir klar wurde, dass ich /**/einen Token-Begrenzer verwenden konnte. Dieser Code macht sich die Tatsache zunutze, dass ein Linienspleiß in Clang immer noch mit einem Leerzeichen dahinter funktioniert, obwohl er Warnungen ausgibt und die Farbgebung des Codes durch Xcode ruiniert.

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

Ausgabe:

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

Befunge-98 , 8x8 (56 Nicht-Leerzeichen [11 Nein])

Hinweis: Im Interesse eines guten Sportpersönlichkeitsschiffs liest dieses seine eigene Quelle über ', was es für einige zu einem Betrüger schlechthin macht. Lesen Sie die Debatte hier .

Programm

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

Ausgabe

(       
 ,      
  &     
   %    
    $   
     #  
      " 
       !

Erläuterung

Die nicht golfene Version

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

(Nicht-Leerzeichen und Leerzeichen werden aus Gründen der Lesbarkeit durch 'n' und 's' ersetzt.)

Diese Lösung basiert auf der Tatsache, dass mit einem Index [0, width ^ 2) mod die Breite des Quadrats Ihnen sagen kann, ob Sie sich am Ende der Zeile oder auf der Diagonale befinden. Da alle Leerzeichen entlang der Diagonalen platziert sind, ist es einfach zu bestimmen, wann ein Nicht-Leerzeichen gedruckt werden soll!

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

Diskussion

Ich bin sehr stolz darauf, obwohl ich wünschte, ich hätte jedes Nicht-Leerzeichen auch zu einem Nicht-Nein machen können. Ich bin auch stolz darauf, dass ich nicht das Standard-Befunge-Get-Increment-Put-Trope verwendet habe! Es druckt verschiedene Symbole für Nicht-Leerzeichen aus, weil ich den Raum dafür hatte und nicht langweilig sein wollte.

Probieren Sie es unter Windows mit BefungeSharp aus !

Jam, 4 x 4 (8 Nicht-Leerzeichen)

 N a
` S 
 * N
X $ 

Probieren Sie es online im CJam-Interpreter aus .

Ausgabe

[ " 
 " ]
[ " 
 " ]

Wie es funktioniert

• Nschiebt einen Zeilenvorschub als Singleton-String. aBricht diesen String in ein Array ein.

• ` Prüft das Ergebnis, dh es wird eine Zeichenfolgendarstellung des Arrays übertragen.

  Das ist das Ergebnis:

  ["
  "]
  

• S*Verbindet die resultierende Zeichenfolge (Array von Zeichen) und trennt ihre Elemente durch Leerzeichen. Mit anderen Worten, es wird ein Leerzeichen zwischen alle Paare benachbarter Zeichen der Zeichenfolge eingefügt.

  Das ist das Ergebnis:

  [ " 
   " ]
  

• N drückt einen anderen Zeilenvorschub.

• X$ kopiert das Stapelelement am Index 1 (von oben gezählt), dh die mehrzeilige Zeichenfolge.

• Schließlich druckt der Interpreter alle Elemente auf dem Stapel: die ursprüngliche mehrzeilige Zeichenfolge, den Zeilenvorschub und die Kopie der mehrzeiligen Zeichenfolge.

SOGL V0.12 , 2x2 (2 Nicht-Leerzeichen)

2 
 ╚

Probieren Sie es hier aus!

Ausgabe

 /
/ 

Erläuterung

In SOGL ersetzen alle Zeilen außer den letzten Zeilen die Zeilen - überall im fortlaufenden Code wird das letzte Zeichen der Zeile durch alles davor ersetzt. SO ist die 1. Zeile hier replace space with 2 in the next line.
Dann wird die nächste Zeile 2╚ausgeführt: 2drückt 2 und ╚erzeugt eine Diagonale der Größe 2.

CBM BASIC v2.0 (8 × 8)

Eine Verbesserung gegenüber meiner vorherigen Antwort mit einem völlig anderen Ansatz:

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

Ausgabe:

       ?
       ?
       ?
       ?
       ?
       ?
       ?
-262144 

Ruby, 8x8 7x7

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

Ausgabe:

f      
f      
f      
f      
f      
f      
 ffalse

Vorherige Version, 8x8 mit 20 Leerzeichen:

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

Ausgabe:

ff     
ff     
ff     
ff     
ff     
ff
ff     
  ffalse

Aufdringlich , 4x4 Quadrat

Nicht konkurrierend, da die Sprache die Herausforderung datiert:

Code:

 H32
2 C4
:" } 
\o/

Ausgänge:

d   
 d  
  d 
   d

Probieren Sie es online!

Da Leerzeichen in Pushy keine Rolle spielen, kann der Code einfach so angeordnet werden, dass er mit dem Negativ seiner Ausgabe übereinstimmt. Das eigentliche Programm sieht so aus:

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

Backslashes beginnen mit einem Kommentar, sodass der Schlussstrich \o/nur dazu dient, das Negativ zu vervollständigen und cool auszusehen.

Alternativ können wir für die gleiche Punktzahl die folgenden Lösungen haben:

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

Definiert eine Hilfsfunktion a ! b, die eine Zeile des Formulars druckt bbbbbbbbba, und eine rekursive Funktion n & c, die nZeilen des Formulars druckt , ccccccccc␣gefolgt von einer Zeile des Formulars ␣␣␣␣␣␣␣␣␣c.

Verwendet <$( fmap constwieder) einen Bereich, um ein Zeichen zu wiederholen. Beachten Sie, dass dies <$nur ohne Import seit GHC 7.10 möglich ist, da dies nach dieser Herausforderung erfolgt. Ich bin mir nicht ganz sicher, ob dies zu einem Wettbewerbsverbot führt.

Nichts wirklich Aufregendes bei der Wahl des Layouts oder des Algorithmus; Ich hatte nicht viele Bytes übrig und es ist nur ein Glück, dass die Zeilenumbrüche so auftreten, putStrLnwie sie es getan haben.

05AB1E , 3x3 (6 Nicht-Leerzeichen- Bytes )

 3Ð
Λ q
°° 

Ausgabe:

3  
 3 
  3

Probieren Sie es online aus.

Erläuterung:

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 Nicht-Leerzeichen)

Ich habe diese Seiten gründlich durchgesehen und war mir sicher, dass es eine Perl-Lösung geben würde, die kleiner als 7x7 ist ... Eine sehr lustige Herausforderung! Diese Lösung erfordert -E.

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

Verwendungszweck:

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

Ausgabe:

     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:

Ausgabe:

        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        

C (gcc) , 7 × 7 8 × 8

BEARBEITEN: Vorherige Version hatte falsches Verhalten.

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

Probieren Sie es online!

Gelee , 4 x 4 (12 Nicht-Leerzeichen)

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

Probieren Sie es online!

Ausgabe:

!   
 !  
  ! 
   !

Das war ziemlich lustig.

Wie es funktioniert

 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

Einfacher Teil: Jelly ignoriert Leerzeichen (solange nur Ein-Byte-Builtins verwendet werden).

Schwieriger Teil: Jede Zeile in Jelly ist eine separate Verknüpfung (oder Funktion), daher ist es nicht sehr kurz, eine konstante Anweisung in mehrere Zeilen zu verteilen. Die Verwendung eines String-Literal ist ein guter Kandidat, aber keine Ahnung, wie das Negativ generiert werden soll.