Sah dies in einer PHP-Herausforderung. Das Ziel ist es, ein Schachbrett mit 64 Feldern (8 * 8) mit der minimalen Menge an Code zu erstellen. Ganz einfach, ich habe meine in PHP in 356 Bytes erstellt (nicht beeindruckend, ich weiß) und ich würde gerne ein paar andere Ansätze sehen. Dies kann in einer Sprache Ihrer Wahl gemacht werden, solange Sie es vanille halten, also keine Importe. Die kleinste Byteanzahl gewinnt.

Die Ausgabe sollte folgendermaßen aussehen:

Und mein Code:

<table><?php
$c='black';function p($c,$n){echo'<td style="width:50px;height:50px;background:'.$c.'"></td>';if($n==1){echo"<tr>";}}for($i=1;$i<=64;$i++){if($i%8==0&&$c=="black"){$c="white";$n=1;}elseif($i%8==0&&$c=="white"){$c="black";$n=1;}elseif(isset($n)&&$n==1){$n=0;}elseif($c=="black"){$n=0;$c="white";}elseif($c=="white"){$n=0;$c="black";}p($c,$n);}

Oder lesbar:

<table><tr>
<?php
$color = 'black';
function printcolor($color, $nl) {

    echo '<td style="width:50px; height:50px; background:' . $color . '"></td>';
    if ($nl == true) {
        echo "</tr><tr>";
    }
}
for ($i=1; $i<=64;$i++) {
    if ($i % 8 == 0 && $color == "black") {
        $color = "white";
        $nl = true;
    } elseif ($i % 8 == 0 && $color == "white") {
        $color = "black";
        $nl = true;
    } elseif (isset($nl) && $nl == true) {      
        $nl = false;
    } elseif ($color == "black") {
        $nl = false;
        $color = "white";           
        } 
    elseif ($color == "white")  {
        $nl = false;
        $color = "black";
    }       
    printcolor($color, $nl);
}

Bearbeiten:

Entschuldigung, ich war anfangs nicht sehr spezifisch:

• Quadrate sollten 50px * 50px haben, mit Ausnahme von Vektorbildern.
• Ausgabeformat oder -größe sind nicht relevant und es muss sich nicht um ein Bild handeln.
• Zu Evaluierungszwecken muss die Ausgabe sichtbar sein, z. B. in einer Bilddatei oder einem Screenshot
• Nach dem Posten der Challenge wurden keine Bibliotheken geschrieben

Oktave, 20 bis 18 Bytes

Vielen Dank an @Bruno für das Abschneiden von 2 Bytes.

imshow(invhilb(8))

Ergebnis:

Diese Antwort verwendet eine Technik, die hier zu finden ist . Es basiert auch auf der automatischen Skalierung von Bildern in Octave in Abhängigkeit von der Größe des Figurenfensters.

vim, 47 46 44 43

^{durchgestrichen 44 ist immer noch regulär 44 ...}

iP1 400 <C-p><cr><esc>50i1<esc>YpVr0yk3PyG49PyG:m$<cr>p2GyG3P

i          enter insert mode
P1         signal to NetPPM that we're using black&white (PBM) format
400        width
<C-p>      fancy trick that inserts the other 400 for height
<cr><esc>  exit insert mode on the next line
50i1<esc>  insert 50 '1's (black)
YpVr0      insert 50 '0's (white) by duplicating the line and replacing all chars
yk         copy both lines (yank-up)
3P         paste three times; this leaves us on line two
yG         copy from line 2 to end of file (this is a full row of pixels now)
49P        we need 50 rows of pixels to make a complete "row"; paste 49 times
yG         copy the entire row of the checkerboard
:m$<cr>    move line 2 (the line we're currently on) to the end of the file
           this gives us the "alternating rows" effect
p          we're now on the last line: paste the entire row we copied earlier
2G         hop back to line 2 (beginning of image data)
yG3P       copy the entire image data, paste 3 times

Ausgaben im NetPPM-Format (PBM):

CSS, 244 Bytes

html{background:#fff}body{width:400px;height:400px;background:linear-gradient(45deg,#000 25%,transparent 25%,transparent 75%,#000 75%)0 0/100px 100px,linear-gradient(45deg,#000 25%,transparent 25%,transparent 75%,#000 75%)50px 50px/100px 100px}

html {
    background: white;
}
body {
    width: 400px;
    height: 400px;
    background:
        linear-gradient(45deg, black 25%, transparent 25%, transparent 75%, black 75%) 0px 0px / 100px 100px,
        linear-gradient(45deg, black 25%, transparent 25%, transparent 75%, black 75%) 50px 50px / 100px 100px
}

Erläuterung: Ein linearer Farbverlauf mit einer Diagonale von 100 x 100 Pixel wird mit vier Blenden erstellt, sodass der größte Teil des Farbverlaufs bis auf zwei dreieckige 50-Pixel-Ecken transparent ist. (Siehe unten Schnipsel). Durch Hinzufügen eines zweiten Farbverlaufs mit einem Versatz von 50 x 50 Pixel werden die fehlenden Hälften der Quadrate ausgefüllt. Wenn Sie den Körper vergrößern, kann sich das resultierende Muster wiederholen, um das gesamte Schachbrett auszufüllen.

html {
    background: white;
}
body {
    width: 100px;
    height: 100px;
    background: linear-gradient(45deg, black 25%, transparent 25%, transparent 75%, black 75%) 0px 0px / 100px 100px
}

Mathematica, 34 Bytes

ArrayPlot@Array[Mod[+##,2]&,{8,8}]

Die Ausgabe ist ein Vektorbild und ist in einem Rahmen umgeben.

Anstatt 32 Rechtecke richtig zu positionieren, können wir einfach eine binäre Matrix generieren und ArrayPlotfür uns arbeiten lassen:

Mathematica, 81 72 55 Bytes

Graphics[Rectangle/@Select[Range@8~Tuples~2,2∣Tr@#&]]

Das Bild ist von einer früheren Version, sieht aber immer noch gleich aus.

Oktave, 48 Bytes

​​​​​​​​​​​​​​​imwrite(kron(mod((t=0:7)+t',2),ones(50)),'.png')

Dies funktioniert genauso wie meine Matlab-Antwort , aber es gibt keinespiral in Octave. Stattdessen verwenden wir eine Funktion, die Matlab nicht bietet: Wir können die Zuweisung von verwendent bereits als Ausdruck verwenden und später verwendent erneut in demselben Ausdruck verwenden.

(Dies ist die neu skalierte Version, ich möchte die Antworten hier nicht überladen =)

Pure Bash (keine externen Dienstprogramme), 133

Ich habe den Kommentar von @ Doorknob als Herausforderung gesehen. Es ist ein bisschen lang, aber hier geht:

echo \# ImageMagick pixel enumeration:400,400,1,rgb
for((;x=p%400,y=p/400,c=1-(x/50^y/50)&1,p++<160000;));{
echo "$x,$y:($c,$c,$c)"
}

Die Ausgabe erfolgt im TXT-Format von Imagemagick . Beachten Sie, dass dies reine Bash ist. Weder Imagemagick noch andere externe Dienstprogramme werden erstellt, um diese Ausgabe zu generieren. Die Ausgabe kann jedoch in eine TXT-Datei umgeleitet und mit dem displayDienstprogramm ImageMagick angezeigt werden :

Dieses Bildformat ist schön, da es sich nicht nur um reinen Text handelt, sondern auch nur um eine Liste aller Pixel (x, y und Farbwert), eines pro Zeile. Es ist ziemlich einfach, alle Pixelwerte in einer großen Schleife arithmetisch abzuleiten.

Vorherige Antwort, 167

echo "\"400 400 2 1\"
\"  c white\"
\"b c black\""
printf -vf %50s
a="$f${f// /b}"
o=("\"$a$a$a$a\"" "\"${f// /b}$a$a$a$f\"")
for i in {0..399};{
echo "${o[i/50%2]}"
}

Die Ausgabe erfolgt im X_PixMap-Text-Image-Dateiformat , das auch mit ImageMagick angezeigt werden kanndisplay Dienstprogramm .

Beachten Sie, dass ich so viel wie möglich aus dem XPM-Format genommen habe, sodass displayes immer noch akzeptiert wird. Mit Ausnahme der doppelten Anführungszeichen um jede Zeile konnte ich das gesamte c- Boilerplate herausnehmen ". Keine Ahnung, welche anderen - wenn überhaupt - Dienstprogramme dies akzeptieren werden.

PowerShell + Browser Ihrer Wahl, 149 143 Bytes

_{Die Unfähigkeit, Importe zu verwenden, ist sehr schwierig, da alle GDI-Aufrufe (dh das, was PowerShell zum Zeichnen verwendet) hinter den Importen in .NET vergraben sind ...}

"<table><tr>"+((1..8|%{$a=$_;-join(1..8|%{'<td style="width:50px;height:50px'+("",";background:#000")[($a+$_)%2]+'"></td>'})})-join'</tr><tr>')

_{Bearbeiten - 6 Bytes dank @NotThatCharles gespeichert}

Hierbei werden zwei for-Schleifen von verwendet 1..8, um einen großen HTML-String zu generieren, der dem bereitgestellten PHP-Beispiel ähnelt, und ihn in der Pipeline auszugeben. Bei jedem Durchlauf berechnen wir, ob ;background:#000die schwarzen Hintergründe angehängt werden sollen, indem wir unsere aktuelle Position auf dem Board modulo 2 einnehmen.

Um dies zu verwenden, leiten Sie die Ausgabe in eine Datei Ihrer Wahl um (z. B. mit etwas Ähnlichem > chessboard.htm) und starten Sie diese dann in einem Browser Ihrer Wahl. Für den Screenshot unten habe ich "c.htm" und Firefox verwendet.

PHP + CSS + HTML, 136 Bytes

Den Tisch auf eine höhere Ebene bringen:

<table><?for(;++$i<9;)echo'<tr>',str_repeat(["<td b><td>","<td><td b>"][$i&1],4);?><style>td{width:50px;height:50px}[b]{background:#000}

Es generiert den folgenden Code:

<table><tr><td><td b><td><td b><td><td b><td><td b><tr><td b><td><td b><td><td b><td><td b><td><tr><td><td b><td><td b><td><td b><td><td b><tr><td b><td><td b><td><td b><td><td b><td><tr><td><td b><td><td b><td><td b><td><td b><tr><td b><td><td b><td><td b><td><td b><td><tr><td><td b><td><td b><td><td b><td><td b><tr><td b><td><td b><td><td b><td><td b><td><style>td{width:50px;height:50px}[b]{background:#000}

Es hängt stark von der Freundlichkeit des Browsers und von CSS ab.

Gelee, 26 Bytes

400R%2ẋ€50FU;$ẋ4;;;1j⁶;”PU

Da Jelly keine eingebauten Bilder unterstützt, drucken wir ein PPM-Bild.

Probieren Sie es online! (kleinere Karte für Geschwindigkeit, Roh-PPM)

Ergebnisse

Wie es funktioniert

400R%2ẋ€50FU;$ẋ4;;;1j⁶;”PU  Main link. No arguments.

400                         Set the left argument to 400.
   R                        Yield [1, ..., 400].
    %2                      Compute the parity of each integer.
      ẋ€50                  Replace each parity by an array of 50 copies of itself.
          F                 Flatten the resulting, nested list.
                            This creates the first rank of the board.
             $              Combine the two atoms to the left:
           U                  Reverse the array of parities.
            ;                 Concatenate the reversed array with the original.
                            This creates the first two ranks of the board.
              ẋ4            Repeat the resulting list four times.
                            This creates all eight ranks of the board.
                ;           Append 400, the link's left argument.
                 ;          Append 400, the link's left argument.
                  ;1        Append 1.
                    j⁶      Join, separating by spaces.
                      ;”P   Append the character 'P'.
                         U  Reverse the resulting list.

Nicht konkurrierende Version (24 Bytes)

Der neueste Jelly-Interpreter vor diesem Beitrag wurde nicht xrichtig vektorisiert . Mit der neuesten Version können 2 zusätzliche Bytes gespeichert werden.

400R%2x50U;$ẋ4;;;1j⁶;”PU

Der einzige Unterschied besteht darin, dass sich x50eine flache Liste ergibt (wobei jedes Originalelement 50 Mal wiederholt wird), sodass dies Fnicht mehr erforderlich ist.

MATL , 11 (27) Bytes

8:t!+Q2\TYG

Dies ergibt die folgende Abbildung. Es hat keine innere Größe; es wird automatisch abhängig von der Größe des Figurenfensters skaliert. Dies scheint die Herausforderung zuzulassen.

Erläuterung

8:      % row vector [1,2,...8]
t!      % duplicate and transpose into column vector
+       % 8x8 matrix with all pairwise additions
Q       % add 1
2\      % modulo 2. Gives 8x8 matrix of zeros and ones
TYG     % draw image

Wenn die automatische Skalierung nicht zulässig ist:

'imshow'8:t!+Q2\50t3$Y"0#X$

erzeugt die folgende Abbildung mit 50x50-Pixel-Quadraten

Erläuterung

'imshow'   % name of Matlab function
8:t!+Q2\   % same as above. Produces 8x8 matrix of zeros and ones
50t3$Y"    % repeat each element 50 times in each dimension
0#X$       % call imshow function with above matrix as input

Pyth, 28 26 Bytes

J*4+*50]255*50]0.wm_mxkdJJ

Erläuterung

J                          - Autoassign J = V
           *50]0           - 50*[0]
    *50]255                - 50*[255]
   +                       - ^^+^
 *4                        - 4*^
                .w         - write_greyscale(V)
                  m      J - [V for d in J]
                   _       - reversed(V) 
                    m   J  - [V for k in J]
                     xkd   - k^d

Python-Äquivalent

J = 4*(50*[255]+50*[0])
write_greyscale([[k^d for k in J][::-1] for d in J])

Probieren Sie es hier aus (nur die Farbwerte)

Ausgabe:

Matlab, 47 (24) Bytes

imwrite(kron(mod(spiral(8),2),ones(50)),'.png')

Dies funktioniert genauso wie meine Octave-Antwort , aber ich konnte verwenden, spiralwas ein Byte sparte. spiral(n)erstellt eine nxnMatrix und füllt sie spiralförmig mit den ersten n^2ganzen Zahlen.

Wenn Vektorgrafiken erlaubt sind, könnten wir das in 24 Bytes machen:

imshow(mod(spiral(8),2))

(Dies ist die neu skalierte Version, ich möchte die Antworten hier nicht überladen =)

FFmpeg, 78 82 100 Bytes

Endlich bin ich dazu gekommen, das Board zu putzen.

ffplay -f lavfi color=s=400x400,geq='255*mod(trunc(X/50)+trunc(Y/50)+1,2):128'

Älter :

ffmpeg -f lavfi -i "color=tan@0:256x256,format=ya8" -vf "scale=400:-1:alphablend=checkerboard" .jpg

Wird mit Fehler beendet, aber nach der Erstellung des Bildes unten.

(Board hat etwas Staub gesammelt)

CJam, 27 Bytes

"P1"400__,2f%50e*_W%+4*~]S*

Probieren Sie es online! (kleinere Karte für Geschwindigkeit, Roh-PPM)

Ergebnisse

Wie es funktioniert

"P1"                        e# Push that string.
    400__                   e# Push three copies of 400.
         ,                  e# Turn the last one into [0 ... 399].
          2f%               e# Compute the parity of each integer.
             50e*           e# Repeat each parity 50 times.
                            e# This creates the first rank of the board.
                 _W%        e# Create a reversed copy of the resulting array.
                    +       e# Concatenate the original with the reversed array.
                            e# This creates the first two ranks of the board.
                     4*     e# Repeat the resulting array four times.
                            e# This creates all eight ranks of the board.
                       ~    e# Dump all of its items (the pixels) on the stack.
                        ]   e# Wrap the entire stack in an array.
                         S* e# Join that array, separating them by spaces.

HTML mit utf-8 - 66b

<div style="font:100 50px/48px serif">▚▚▚▚<br>▚▚▚▚<br>▚▚▚▚<br>▚▚▚▚

▚ ist ein kurzer direkter utf für die Entität & # 9626;

Unicode-Zeichen "QUADRANT OBEN LINKS UND UNTEN RECHTS" (U + 259A)

albern ich war auf der suche nach einer 1 utf-8 char lösung - wäre ... 1b!

PHP, 166 158 155 Bytes

Funktioniert in PHP 7.0.2 (Short-Tags aktiviert) und Chrome 48.0.2564.97 m

<table><tr><? while(++$i<=8){while(++$j<=8){echo"<td style=background-color:".($i%2==0?($j%2==1?0:""):($j%2==0?0:"")).";padding:9></td>";}echo"<tr>";$j=0;}

PHP> = 5,4, 175 159 149 116 Bytes

<table><tr><? for(;@++$i<65;)echo'<td width=50 height=50 ',$i+@$m&1?:'bgcolor=0','>',$i%8<1?'<tr '.($m=@!$m).'>':'';

<table><tr><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><tr 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><tr ><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><tr 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><tr ><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><tr 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><tr ><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><tr 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><td width=50 height=50 bgcolor=0><td width=50 height=50 1><tr >

Anmerkungen

• 16 Bytes rasiert - Danke @insertusernamehere
• Rasiert 10 Bytes - Danke @ msh210
• 30 Bytes rasiert - Danke an Ismael Miguel

JavaScript, 150

Dies kann auf jeden Fall Golf gespielt werden. Es wird HTML erstellt.

for(i=0;i<8;)console.log(`<b style=margin-${['lef','righ'][i++%2]}t:50;width:50;height:50;display:inline-block;background:#000></b>`.repeat(4)+'<br>')

iKe , 24 Bytes

,(;cga;t=\:t:2!-20!!160)

Der Kern der Technik besteht darin, eine Liste von x-Koordinaten zu generieren, diese zu divmodieren und dann ein Gleichheitsprodukt zu verwenden, um eine geeignete Bitmap zu generieren. Zur Veranschaulichung kleinere Beispiele verwenden:

  !8
0 1 2 3 4 5 6 7

  -2!!8
0 0 1 1 2 2 3 3

  2!-2!!8
0 0 1 1 0 0 1 1

  t=\:t:2!-2!!8
(1 1 0 0 1 1 0 0
 1 1 0 0 1 1 0 0
 0 0 1 1 0 0 1 1
 0 0 1 1 0 0 1 1
 1 1 0 0 1 1 0 0
 1 1 0 0 1 1 0 0
 0 0 1 1 0 0 1 1
 0 0 1 1 0 0 1 1)

versuche es hier . Technisch funktioniert iKe auf einer logischen Leinwand mit 160 x 160 Pixeln. Im Vollbildmodus (der Standardeinstellung, wenn Sie einem gespeicherten Link folgen) wird dies jedoch um das Dreifache erhöht. Ich denke, dies folgt immer noch dem Grundgedanken der Frage, da das Programm eine viel größere Bitmap mit der gleichen Zeichenanzahl zusammenstellen könnte. es kommt nur auf eine willkürliche Anzeigebeschränkung an.

Aktualisieren:

iKe ist nicht in erster Linie für das Golfen gedacht, aber das Live-Codieren profitiert immer noch von der Kürze und den vernünftigen Standardeinstellungen. Als Ergebnis des Herumbastelns an diesem Problem habe ich beschlossen, die Verwendung einer Standardpalette zuzulassen, wenn keine bereitgestellt wird. Diese spezielle Lösung könnte nun ausgedrückt werden mit:

,(;;t=\:t:2!-20!!160)

Speichern von (nicht auswählbaren) 3 Bytes.

Ruby with Shoes, 97 Zeichen

Shoes.app(width:400){64.times{|i|stack(width:50,height:50){background [white,black][(i/8+i)%2]}}}

Beispielausgabe:

Lua + LÖVE, 138 113 112 106 Zeichen

function love.draw()for i=0,31 do
love.graphics.rectangle("fill",i%8*50,(i-i%8)/8*100+i%2*50,50,50)end
end

Beispielausgabe:

GIMP, 539 Bytes

gimp -i -b '(let* ((i (car (gimp-image-new 400 400 1))) (d (car (gimp-layer-new i 400 400 2 "b" 100 0)))) (gimp-image-insert-layer i d 0 -1) (define (t x y) (gimp-selection-translate i x y)) (define (x) (t 100 0)) (define (X) (t -100 0)) (define (y) (t 50 50)) (define (Y) (t -50 50)) (define (f) (gimp-edit-fill d 1)) (define (r) (f) (x) (f) (x) (f) (x) (f) (y)) (define (R) (f) (X) (f) (X) (f) (X) (f) (Y)) (gimp-image-select-rectangle i 2 0 0 50 50) (r) (R) (r) (R) (r) (R) (r) (R) (gimp-file-save 1 i d "c.png" "c.png") (gimp-quit 0))'

Ungolfed Scheme script-fu:

(let* ((i (car (gimp-image-new 400 400 GRAY)))
       (d (car (gimp-layer-new i 400 400 GRAY-IMAGE "b" 100 NORMAL-MODE))))

  (gimp-image-insert-layer i d 0 -1)
  (define (t x y) (gimp-selection-translate i x y))
  (define (x) (t 100 0))
  (define (X) (t -100 0))
  (define (y) (t 50 50))
  (define (Y) (t -50 50))
  (define (f) (gimp-edit-fill d BACKGROUND-FILL))
  (define (r) (f) (x) (f) (x) (f) (x) (f) (y))
  (define (R) (f) (X) (f) (X) (f) (X) (f) (Y))

  (gimp-image-select-rectangle i CHANNEL-OP-REPLACE 0 0 50 50)
  (r) (R) (r) (R) (r) (R) (r) (R)
  (gimp-file-save RUN-NONINTERACTIVE i d "c.png" "c.png")
  (gimp-quit 0))

Erstellen Sie im Stapelmodus ein leeres Bild, erstellen Sie eine rechteckige Auswahl von 50 x 50, füllen Sie es aus und bewegen Sie es dann wiederholt um das Bild, wobei Sie Quadrate ausfüllen. Dann speichern c.pngund beenden.

Ausgabe:

J, 33 31 Bytes

Ich habe einen Trick mit Binär verwendet.

   load'viewmat'
   viewmat 8 8$#:43605

... weil 43605 in binär 1010101001010101 ist (wir verwenden #:primitive, um es zu bekommen). Primitive $formt dieses Array von Binärziffern in eine Matrix, die mit den Dimensionen angegeben wird 8 8. Und viewmatist nur eine Systembibliothek.

Das Fenster ist in der Größe vollständig veränderbar.

Vielen Dank an @FrownyFrog für die Kürzung auf:

   load'viewmat'
   viewmat#:8$170 85

Excel VBA, 82 Bytes

Anonyme VBE- A1:H8Direktfensterfunktion , die keine Eingabe annimmt und ein Schachbrettmuster in den Bereich des ActiveSheet-Objekts ausgibt

Cells.RowHeight=48:[B1:B8,D1:D8,F1:F8,H1:H8].Interior.Color=0:[A2,A4,A6,A8].Delete

Diese Funktion erstellt zunächst 4 schwarze Spalten im Bereich B1:B8,D1:D8,F1:F8,H1:H8und versetzt dann die Färbung in Zeilen 2,4,6 and 8um eine Zelle nach links.

Beispielausgabe

Perl 5 - 80

Erzeugt eine .PBM-Datei:

print 'P1'.' 400'x2 .$".(((0 x50 .1 x50)x4 .$")x50 .((1 x50 .0 x50)x4 .$")x50)x4

PowerShell + GDI, 346 Byte

Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing
$f=New-Object Windows.Forms.Form
$f.width=$f.height=450
$g=$f.CreateGraphics()
$f.add_paint({0..7|%{$y=$_;0..7|%{$g.FillRectangle((New-Object Drawing.SolidBrush ("white","black")[($_+$y)%2]),(new-object Drawing.Rectangle ($_*50),($y*50),50,50))}}})
$f.showDialog()

_{(Zeilenumbrüche zählen wie Semikolon, daher werden Zeilenumbrüche zur besseren Lesbarkeit verwendet.)}

Im Gegensatz zu meiner anderen Antwort verwendet diese die .NET-Assemblys, um GDI + aufzurufen -Funktionsaufrufen. Interessanterweise ist es ungefähr doppelt so lang.

Die ersten beiden Zeilen laden die Assemblys System.Windows.Formsund System.Drawing. Das erste wird für das Literalfenster und die Zeichenfläche verwendet, das zweite für das Zeichenobjekt (in diesem Code ein Pinsel), mit dem die Grafiken auf der Zeichenfläche erstellt werden.

Wir erstellen dann unser Formular $fmit der nächsten Zeile und setzen sein widthund heightsein 450. Beachten Sie, dass dies nicht der 50*8Fall ist , da diese Zahlen dem Rand des Formularfensters entsprechen, einschließlich der Titelleiste, der Schaltfläche zum Schließen usw.

In der nächsten Zeile wird unsere Zeichenfläche erstellt, $gindem der leere Konstruktor aufgerufen wird. Dies entspricht standardmäßig der oberen linken Ecke des Nicht-Systembereichs des Formulars 0,0und nimmt nach rechts und unten zu, was für unsere Anforderungen perfekt ist.

Die nächste Zeile ist der eigentliche Aufruf, mit dem die Grafiken gezeichnet werden $f.add_paint({...}). Wir konstruieren die Grafikaufrufe, indem wir eine Double-for-Schleife von jeder äußeren Schleife ausführen 0..7und eine Hilfsvariable $ydurch diese führen. In jeder inneren Schleife weisen wir unsere Leinwand an .FillRectangle(...,...), unsere Quadrate zu zeichnen. Der erste Parameter erstellt ein neues SolidBrushmit einer Farbe, die davon abhängt, wo wir uns auf dem Board befinden. Andere Optionen können Schraffuren, Verläufe usw. sein. Der zweite Parameter ist ein neues RectangleObjekt, das an den angegebenen x- $_*50und $y*50Koordinaten beginnt und sich 50in jede Richtung erstreckt. Denken Sie daran, dass 0,0das oben links ist.

In der letzten Zeile wird nur die Ausgabe mit angezeigt .showDialog().

Beachten Sie, dass das Schließen des Popup-Formulars ein Objekt von weiterleitet, da wir ein Formularobjekt erstellen und PowerShell sich ausschließlich um die Pipeline handelt , da dies technisch der Benutzer getan hat. Da wir mit diesem Ergebnis nichts erfassen oder anderweitig etwas unternehmen, wird das Wort STDOUT angezeigt, wenn das Programm beendet wird, da es in der Pipeline verblieben ist.System.Enum.DialogResultCancelCancel

WÄHLEN. , 8844 8278 Bytes

(9,9,50)EXP.SELECT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.LOG.RIGHT.SELECT.LEFT.LEFT.LEFT.EXP.SELECT.EXP.RIGHT.SELECT.LOG.LEFT.SELECT.EXP.RIGHT.SELECT.RIGHT.EXP.SELECT.EXP.SELECT.EXP.LEFT.SELECT.RIGHT.LOG.LEFT.LEFT.SELECT.RIGHT.RIGHT.LOG.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.EXP.SELECT.EXP.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.RIGHT.EXP.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.LOG.RIGHT.SELECT.RIGHT.EXP.SELECT.EXP.LEFT.SELECT.RIGHT.LOG.LEFT.SELECT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.LOG.RIGHT.SELECT.LEFT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.EXP.RIGHT.RIGHT.SELECT.LEFT.LEFT.EXP.RIGHT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.LEFT.RIGHT.RIGHT.EXP.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.LOG.RIGHT.SELECT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.LEFT.EXP.LEFT.SELECT.RIGHT.RIGHT.RIGHT.EXP.SELECT.EXP.LEFT.SELECT.RIGHT.LOG.LEFT.SELECT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.LOG.RIGHT.SELECT.LEFT.EXP.LEFT.SELECT.RIGHT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.LEFT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.LEFT.LOOP.RIGHT.RIGHT.EXP.SELECT.EXP.LEFT.SELECT.RIGHT.LOG.LEFT.SELECT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.LOG.RIGHT.SELECT.LEFT.CONJ.RIGHT.EXP.LEFT.SELECT.RIGHT.EXP.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.LEFT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.LOG.RIGHT.SELECT.EXP.SELECT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.LEFT.LEFT.EXP.SELECT.RIGHT.LOG.LEFT.SELECT.EXP.RIGHT.SELECT.RIGHT.EXP.SELECT.EXP.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.LOG.RIGHT.SELECT.RIGHT.EXP.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.LOG.RIGHT.SELECT.LEFT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.LEFT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.LEFT.SELECT.RIGHT.RIGHT.RIGHT.EXP.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.LOG.RIGHT.SELECT.LEFT.LOOP.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.RIGHT.LOG.SELECT.LOG.RIGHT.SELECT.LEFT.LEFT.END.RIGHT.RIGHT.LOG.SELECT.LOG.RIGHT.SELECT.LEFT.EXP.LEFT.SELECT.RIGHT.LOOP.RIGHT.EXP.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.LEFT.RIGHT.RIGHT.RIGHT.END.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.RIGHT.EXP.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.LOG.RIGHT.SELECT.LEFT.EXP.LEFT.SELECT.RIGHT.LOOP.RIGHT.EXP.SELECT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.RIGHT.EXP.SELECT.EXP.LEFT.SELECT.RIGHT.LOG.LEFT.SELECT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.LOG.RIGHT.SELECT.LEFT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.EXP.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.EXP.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.LOG.RIGHT.SELECT.EXP.SELECT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.RIGHT.SELECT.LEFT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.LOG.RIGHT.SELECT.LEFT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.EXP.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.LEFT.LOG.RIGHT.SELECT.LEFT.PRINT.RIGHT.RIGHT.LOG.SELECT.LOG.RIGHT.SELECT.LEFT.LEFT.END.RIGHT.RIGHT.LOG.SELECT.LOG.RIGHT.SELECT.LEFT.EXP.LEFT.SELECT.RIGHT.LOOP.RIGHT.EXP.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.LEFT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.END.RIGHT.RIGHT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.LEFT.SELECT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.RIGHT.LOG.RIGHT.SELECT.EXP.LEFT.LEFT.SELECT.RIGHT.RIGHT.EXP.LEFT.SELECT.RIGHT.LOG.RIGHT.SELECT.LEFT.END.

Sicher, es ist lang, aber die ersten beiden Versionen, die ich für diese Aufgabe erstellt habe, waren doppelt so lang.

Ausgabe:

Wie es funktioniert:

Hier ist das Programm, mit dem es generiert wurde:

init(9,9,50)
makenum(8)
square()
dec()
loop("main",computei=True)
go(1)
makenum(8)
go(1)
copyfrom(-2)
intdiv(-1)
add(-5)           # n%8 blah blah blah blah n//8 k^(n//8) k^(n%8) (n//8+n%8)
go(1)
makeneg1()
exptarget(-1)
go(1)
ifnonpositive("drawtest")
go(1)
makenum(-4,-4)    # n%8 blah blah blah blah n//8 k^(n//8) k^(n%8) n//8+n%8 (-1)^(n//8+n%8) 4 1/2 I k^(-4I) -1 (-4-4I)
go(1)
multiply(-4,-11)   # n%8 blah blah blah blah n//8 k^(n//8) k^(n%8) n//8+n%8 (-1)^(n//8+n%8) 4 1/2 I k^(-4I) -1 -4-4I (nI//8)
add(-16)          # n%8 blah blah blah blah n//8 k^(n//8) k^(n%8) n//8+n%8 (-1)^(n//8+n%8) 4 1/2 I k^(-4I) -1 -4-4I nI//8 k^(nI//8) k^(n%8) (n%8+nI//8)
add(-4)           # n%8 blah blah blah blah n//8 (-1)^(n%8) 4 1/2 I k^(-4I) -1 -4-4I nI//8 k^(nI//8) k^(n%8) n%8+nI//8 k^(n%8+nI//8) k^(-4-4I) ((n%8-4)+I(n//8-4))
output()
endif("drawtest")
go(1)
endloop("main")
writetofile("chessboard4")

Mit anderen Worten, Schleife n von 0 bis 63, Zeichnen eines Quadrats bei (n% 8-4) + (n // 8-4) i, wenn (-1) ^ (n // 8 + n% 8) nicht ist positiv.

JavaScript (ES6), 147

for(i=0;++i<72;)document.write(`<div style="${i%9?'':(++i,'clear:both;')}float:left;width:50px;height:50px;background:#${i&1?'fff':'000'}"></div>`)

Python, 57 Bytes

c=50*"1"+50*"0"
print"P1 400 400 "+4*(200*c+200*c[::-1])

cist eine Linie von 50 weißen und 50 schwarzen Pixeln, 200*cist eine Reihe mit einem weißen in der Frontseite, 200*c[::-1]die Rückseite.

Ausgabe als PPM, Verwendung:

python golf_chess.py > chess.ppm