Zbuduj szachownicę


23

Widziałem to w wyzwaniu PHP. Celem jest stworzenie szachownicy z 64 kwadratami (8 * 8) z minimalną ilością kodu. To proste: stworzyłem mój w PHP w 356 bajtach (nie imponujący, wiem) i chciałbym zobaczyć inne podejścia. Można to zrobić w wybranym przez siebie języku, pod warunkiem, że pozostanie się waniliowym, więc nie będzie importu. Wygrywa najmniejsza liczba bajtów.

Dane wyjściowe powinny wyglądać następująco:

screencap

I mój kod:

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

Lub czytelny:

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

Edytować:

Przepraszam, ale na początku nie byłem bardzo szczegółowy:

  • Kwadraty powinny mieć 50px * 50px, z wyjątkiem obrazów wektorowych.
  • Format wyjściowy lub rozmiar nie jest istotny, ani nie musi być obrazem.
  • Do celów oceny dane wyjściowe muszą być widoczne, na przykład w pliku obrazu lub na zrzucie ekranu
  • Brak bibliotek napisanych po opublikowaniu wyzwania

3
Witamy w PPCG, w obecnej formie to wyzwanie nie ma nic wspólnego z PHP, więc zmieniłem tagi. Ponadto uważam, że implementacja referencyjna należy do odpowiedzi, a nie do pytania. Jak wychował Stewie, powinieneś określić wymagany rozmiar obrazu wyjściowego, a także takie rzeczy, jak specyfikacja kolorów i czy dozwolony jest obraz stratny.
FryAmTheEggman

2
Więc niektóre magie ASCII są niedozwolone? :(
Denker

4
Jak podstawowy jest podstawowy? Jaka jest definicja „importu”?
Klamka

6
Nie musi to być obraz, ale każdy kwadrat musi mieć co najmniej 50 pikseli? Wydaje mi się to wewnętrznie sprzeczne.
Peter Taylor,

4
Języki programowania są tutaj bardzo różnorodne, w tym niektóre, które zostały stworzone specjalnie do gry w golfa i mają wiele wbudowanych funkcji. Dlatego zalecam usunięcie ograniczenia do funkcji niebibliotecznych, a zamiast tego to pytanie będzie zgodne z domyślnym (wszystkie importy są liczone w liczbie bajtów; nie ma bibliotek napisanych po wysłaniu wyzwania).
lirtosiast

Odpowiedzi:


13

Oktawa, 20 18 bajtów

Dzięki @Bruno za zgolenie 2 bajtów.

imshow(invhilb(8))

Wynik:

enter image description here

W tej odpowiedzi użyto techniki znalezionej tutaj . Opiera się również na automatycznym skalowaniu obrazów w oktawie w zależności od wielkości okna figury.


1
@AlexA. Nie jestem też do końca przekonany, że kwadraty muszą mieć dokładnie 50 x 50 pikseli, ponieważ następna reguła mówi „Format wyjściowy lub rozmiar nie ma znaczenia ...”. Ludzie prosili o wyjaśnienia w komentarzach, ale pytanie nie zostało zaktualizowane.
zlewka

Edytowałem pytanie. Przetestowałem Twój kod i działa, więc obecnie masz najniższą liczbę bajtów :)
Bruno

Usunąłem także> 0 i nadal działa, więc możesz ogolić tam 2 bajty
Bruno

@Bruno Co? To jest dzikie. Więc najwyraźniej zaciska wartości macierzy (wszystkie << 0 lub >> 1) do 0 i 1. Dzięki za wskazówkę, zaktualizuję! : D
zlewka

Gratulacje na 2k!
NoOneIsHere

26

vim, 47 46 44 43

przekreślone 44 jest nadal regularne 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

Dane wyjściowe w formacie NetPPM (PBM):

output


2
Uwielbiam to, że możesz wykonać graficzne wyzwanie wyjściowe za pomocą edytora tekstu. Czy są jakieś inne przykłady PBM z gry w golfa?
ankh-morpork

1
@ dohaqatar7 Nie wiem, ale wcześniej robiłem TikZ z vimem, więc grafika w vimie jest pewna.
Klamka

2
Wow, nigdy nie myślałem, żeby spróbować <C-p>w vimie, zanim nie zacząłem pisać słowa ... to naprawdę przydatne!
Desty

16

CSS, 244 bajty

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}

Objaśnienie: Utworzono gradient liniowy o przekątnej 100 x 100 pikseli z czterema ogranicznikami, dzięki czemu większość gradientu jest przezroczysta, z wyjątkiem dwóch trójkątnych narożników 50 pikseli. (Zobacz poniżej fragment). Dodanie drugiego gradientu z przesunięciem 50x50px wypełnia brakujące połówki kwadratów. Zwiększenie rozmiaru ciała pozwala następnie powtórzyć powstały wzór, aby wypełnić całą szachownicę.


Schludne rozwiązanie. Powinno również działać, jeśli upuścisz ostatni } .
inserttusernamehere

Czy możesz wyjaśnić, co się tutaj dzieje?
flawr

@flawr Dodałem drugi fragment pokazujący efekt częściowy, mam nadzieję, że to pomoże.
Neil

To jest doskonałe.
Nie to, że Charles

Czy naprawdę tego potrzebujesz html{background:#fff}? Domyślnie 99% przeglądarek ustawia tło na białe,
afaik

15

Mathematica, 34 bajty

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

Wyjście jest obrazem wektorowym i jest otoczone ramką.

Zamiast poprawnie ustawiać 32 prostokąty, możemy po prostu wygenerować macierz binarną i wykonać ArrayPlotdla nas pracę:

enter image description here


Miły! Dzięki za opublikowanie.
A Simmons,

Wygląda dobrze. Czy możesz mi wyjaśnić, gdzie definiujesz każdy kwadrat jako 50 pikseli? Czy jest też emulator online, w którym mogę go przetestować?
Bruno

@Bruno Wyjście jest grafiką wektorową, więc nie ma czegoś takiego jak rozmiary pikseli (obraz nie ma własnego rozmiaru - można go przeskalować i wyświetlić w dowolnym rozmiarze). Dlatego spytałem.
Martin Ender

4
Czekaj, GenerateChessBoardWithColorsAsParameters[ColorBlack, ColorWhite, 8, 8, 50, 50]nie działa? ;)
Conor O'Brien

3
@ CᴏɴᴏʀO'Bʀɪᴇɴ Tak, ale to 73 bajty.
Martin Ender

10

Mathematica, 81 72 55 bajtów

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

Input/Output

Obraz jest z oceny poprzedniej wersji, ale nadal wygląda tak samo.


8

Oktawa, 48 bajtów

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

Działa to dokładnie tak samo, jak moja odpowiedź Matlab , ale nie ma jej spiralw Octave. Zamiast tego używamy funkcji, której Matlab nie ma: możemy użyć przypisania tjuż jako wyrażenia, a później użyć tponownie w tym samym wyrażeniu.

(To jest przeskalowana wersja, nie chcę zaśmiecać tutaj odpowiedzi =)


1
Lewy górny róg powinien być biały, a nie czarny.
Klamka

2
Wyjście powinno być szachownicą, orientacja nie została określona.
flawr

2
Przepraszamy, Flawr, wyjściem powinna być szachownica. Szachownica ma zawsze postać „Królowa w swoim kolorze, biała po prawej stronie” (co oznacza, że ​​prawa ręka każdego gracza ma biały kwadratowy narożnik).
corsiKa

5
Następnie wyobraź sobie, że jeden gracz siedzi po prawej, jeden po lewej. Znowu: wyzwanie nie zostało określone, to tylko twoja interpretacja.
flawr

8

Pure Bash (bez zewnętrznych narzędzi), 133

Widziałem komentarz @ Doorknob jako trochę wyzwanie. Jest trochę długi, ale oto:

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)"
}

Dane wyjściowe są w formacie .txt Imagemagick . Zauważ, że to czysty Bash. Ani Imagemagick, ani żadne inne zewnętrzne narzędzia nie są generowane do generowania tego wyniku. Dane wyjściowe można jednak przekierować do pliku .txt i wyświetlić za pomocą displaynarzędzia ImageMagick :

enter image description here

Ten format obrazu jest fajny, ponieważ nie tylko jest to czysty tekst, to niewiele więcej niż lista wszystkich pikseli (x, y i wartość koloru), po jednym w wierszu. Dość arytmetycznie wyprowadzenie wszystkich wartości pikseli w jednej dużej pętli jest dość proste.


Poprzednia odpowiedź, 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]}"
}

Dane wyjściowe są w formacie tekstowego pliku obrazu X_PixMap , który można również wyświetlać za pomocą displaynarzędzia ImageMagick .

Uwaga: Wyciągnąłem tyle z formatu XPM, ile mogłem, aby displaynadal go akceptować. Udało mi się wyjąć całą płytkę z wyjątkiem "podwójnych cudzysłowów wokół każdej linii. Nie mam pojęcia, jakie inne - jeśli w ogóle - narzędzia to zaakceptują.


6

Wybrana przeglądarka PowerShell +, 149 143 bajty

Brak możliwości użycia importu jest naprawdę trudny, ponieważ wszystkie wywołania GDI (tj. Rzeczy, które PowerShell używa do rysowania) są ukryte za importem w .NET ...

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

Edytuj - zapisano sześć bajtów dzięki @NotThatCharles

Używa dwóch pętli for 1..8do wygenerowania dużego łańcucha HTML, podobnego do podanego przykładu PHP, i przesłania go do potoku. Za każdym razem obliczamy, czy dołączyć ;background:#000do czarnego tła, biorąc naszą obecną pozycję na module modulo 2.

Aby użyć, przekieruj dane wyjściowe do wybranego pliku (np. Z czymś podobnym > chessboard.htm), a następnie uruchom go w wybranej przeglądarce. Poniższy zrzut ekranu użyłem „c.htm” i Firefoksa.

firefox


Ten był niezauważony, ale jakoś mi się podoba :)
Bruno

whitei blackmoże być #fffi #000... ale po co zawracać sobie głowę określaniem bieli?
Nie to, że Charles

spróbuj (";background:#000","")[($a+$_)%2]zamiast tego.
Nie, że Charles

@NotthatCharles Durr, miałem białe i czarne klapki, więc generowało tylko białe kwadraty. Poprawiono na dodatkowe 4 zapisane bajty.
AdmBorkBork

5

PHP + CSS + HTML, 136 bytes

Taking the table aproach to a higher level:

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

Generuje następujący kod:

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

W dużej mierze opiera się na uprzejmości przeglądarek i CSS.


Good solution. Tho I had to include php after <? and include $i=0 as the first for parameter to get it working properly, giving a final result of 144 bytes.
Bruno

1
@Bruno Jeśli odwołujesz się do ostrzeżenia, które daje, ostrzeżenia są tutaj ignorowane. Istnieją jednak tryliony sposobów ich wyłączenia. Jednym z nich jest zastąpienie ++$i<9z @++$i<9. Ponadto, aby działał bez niego <?php, należy mieć dyrektywę short_open_tags=On, która jest domyślna w niektórych środowiskach. Czytaj więcej na stackoverflow.com/a/2185331/2729937
Ismael Miguel

5

Galaretka, 26 bajtów

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

Ponieważ Jelly nie obsługuje wbudowanych obrazów, drukujemy obraz PPM.

Wypróbuj online! (smaller board for speed, raw PPM)

Wyniki

screenshot

Jak to działa

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.

Wersja niekonkurencyjna (24 bajty)

Najnowszy interpreter Jelly poprzedzający ten post nie został xpoprawnie wektoryzowany . W najnowszej wersji można zapisać 2 dodatkowe bajty.

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

The only difference is that x50 yields a flat list (with every original element repeated 50 times), so F is no longer necessary.


1
Wygląda na to, że pisałeś odpowiedź w języku java i zasnąłeś podczas pisania ;...;)
Conor O'Brien

1
@ CᴏɴᴏʀO'Bʀɪᴇɴ Java? Musisz być na Javie 10.0, Golfing Edition, bo to nie wygląda jak żadna Java, którą widziałem ....
BalinKingOfMoria

5

MATL , 11 (27) bajtów

8:t!+Q2\TYG

Daje to następujący rysunek. Nie ma wewnętrznego rozmiaru; jest automatycznie skalowany w zależności od wielkości okna figury. Wydaje się, że na to pozwala wyzwanie.

enter image description here

Wyjaśnienie

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

Jeśli automatyczne skalowanie nie jest dozwolone:

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

tworzy następujący rysunek z kwadratami 50 x 50 pikseli

Wyjaśnienie

enter image description here

'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

5

Pyth, 28 26 bajtów

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

Wyjaśnienie

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

Odpowiednik w języku Python

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

Try it here (just the colour values)

Output:

Output


Nice job on the byte count but I need a valid output with visible squares :)
Bruno

@Bruno Output added! I installed PIL just for you :O (I hadn't actually tested it before)
Blue

@muddyfish sorry for the trouble and thanks. The board must start with and end with a white square tho :)
Bruno

4

Matlab, 47 (24) bytes

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

This works exactly the same as my Octave answer, but I was able to use spiral which saved one byte. spiral(n) makes an nxn matrix and fills it spiraling with the first n^2 integers.

If vectorgraphics are allowed, we could do it in 24 bytes:

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

(This is the rescaled version, I do not want to clutter the answers here=)


4

FFmpeg, 78 82 100 bytes

Finally got around to cleaning the board.

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

enter image description here


Older:

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

Will exit with error, but after producing image below.

enter image description here

(board's collected some dust)


3

CJam, 27 bytes

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

Try it online! (smaller board for speed, raw PPM)

Results

screenshot

How it works

"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.

3

HTML with utf-8 - 66b

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

▚ is short-direct utf for entity &# 9626 ;

Unicode Character 'QUADRANT UPPER LEFT AND LOWER RIGHT' (U+259A)

silly me, was looking for a 1 utf-8 char solution -would have been... 1b!


2
Seems like fontsize is wrong.
Qwertiy

1
You should use instead so that the top-left square is white like on a standard chessboard. Also, use <pre> instead of <div> so that you can use newlines instead of <br>.
Neil

Your bytecount appears to be wrong, it should be 98 bytes, as counts for 3 bytes using UTF-8 encoding. In the future, you can use this to check your UTF-8 Byte Count
Taylor Scott

2

PHP, 166 158 155 bytes

Works in PHP 7.0.2 (short-tags enabled) and 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;}

You can use the property bgcolor=0 to generate the black background. That should shave off a ton of bytes! And instead of $v%2==0, use $v&1, which should shave a few bytes.
Ismael Miguel

2

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 >

Notes

  • Shaved 16 bytes - Thanks @insertusernamehere
  • Shaved 10 bytes - Thanks @msh210
  • Shaved 30 bytes - Thanks @Ismael Miguel

1
Probably this can be golfed even more, but here you go (152 bytes): <table><tr><?php for(;++$i<65;){echo'<td style="width:50px;height:50px;background:#'.(($i+$m)%2?'000':'').'"></td>';if($i%8<1){echo"</tr><tr>";$m=!$m;}}
insertusernamehere

While i didn't remove the initial assignments(Works, personal quirk won't let me do it), Thank for this
Shaun H

1
According to even the strict version of HTML 4, you can skip the end tag for TR.
msh210

1
Replace ++$i<65 with @++$i<65, since you are worried about the warnings. This means that you can reduce $m=$i=0 to just $m=0, saving you 2 bytes. Instead of echo 'a'.'b'.'c';, you can do echo 'a','b','c';. This means that your echo can be echo'<td style="width:50px;height:50px;background:#',($i+$m)%2?'':'000','">'; saving you more 2 bytes. Also, HTML attributes don't require quotes. Remove them and sabe 2 bytes. Also, there's a much shorter bgcolor attribute, that reduces more bytes! You can use a print() in the for to save even more bytes!
Ismael Miguel

1
To save even more, I've replaced ($i+$m)%2 with $i+@$m&1, which allowed me to remove that $m=0. Ahead, I've been able to remove your if, and replaced it with a trenary operation. To save even more, I've removed your style and added the properties width and height. To get even more into the hacky side, I've figured that Chrome 48.0.2564.103 m uses black if the background color is 0, using the property bgcolor. That allowed me to ever reduce more! More reductions is better!
Ismael Miguel

1

JavaScript, 150

This can definitely be golfed. It creates HTML.

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

1
Huh, I never knew about template strings in JavaScript. Cool.
Cheezey

1

iKe, 24 bytes

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

board

The core of the technique is to generate a list of x coordinates, divmod them and then take an equality cross-product to generate an appropriate bitmap. Using smaller examples for illustrative purposes:

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

try it here. Technically iKe works on a logical 160x160 pixel canvas, but in full-screen mode (the default when following a saved link) this is upscaled by 3x. I think this is still following the spirit of the question, as the program could assemble a much larger bitmap with the same character count; it just comes down to an arbitrary display limitation.

Update:

iKe isn't primarily designed for golf, but livecoding still benefits from brevity and sane defaults. As a result of tinkering with this problem, I've decided to permit it to use a default palette if none is provided. This particular solution could now be expressed with:

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

Saving (an ineligible) 3 bytes.


1

Ruby with Shoes, 97 characters

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

Sample output:

Chessboard drawn by Ruby with Shoes


Should start and end with white. Otherwise good job :)
Bruno

Oops. Thanks @Bruno. Fixed.
manatwork

Great, upvoted :)
Bruno

1

Lua + LÖVE, 138 113 112 106 characters

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

Sample output:

Chessboard drawn by Lua + LÖVE


Grr! Lua 5.3 has // integer division operator, but apparently there is still no LÖVE built with a LuaJIT featuring it. ☹
manatwork

1

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

In batch mode, create a blank image, create a 50x50 rectangular selection, fill it, and then repeatedly move it around the image, filling in squares. Then save to c.png and exit.

Output:

chessboard png


1

J, 3331 bytes

I used a trick with binary.

   load'viewmat'
   viewmat 8 8$#:43605

... because 43605 in binary is 1010101001010101 (we use #: primitive to get it). Primitive $ shapes this array of binary digits into a matrix specified with the dimensions 8 8. And viewmat is just a system library.
enter image description here
The window is fully resizable.

Thanks to @FrownyFrog for shortening it to:

   load'viewmat'
   viewmat#:8$170 85

viewmat 8$#:170 85 is 1 byte shorter
FrownyFrog

1
viewmat#:8$170 85
FrownyFrog

1

Excel VBA, 82 Bytes

Anonymous VBE immediate window function that takes no input and outputs a checkerboard to the range A1:H8 on the ActiveSheet object

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

This function works by first creating 4 black columns in the range B1:B8,D1:D8,F1:F8,H1:H8 and then offsetting the coloring in rows 2,4,6 and 8 to the left by one cell.

Sample Output

CheckerBoard


0

Perl 5 - 80

Generates a .PBM file:

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

0

PowerShell + GDI, 346 bytes

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

(newlines count same as semicolon, so newlines for readability)

As opposed to my other answer, this one uses the .NET assemblies to call GDI+ function calls. Interestingly, it's about twice the length.

The first two lines load the System.Windows.Forms and System.Drawing assemblies. The first is used for the literal window and the canvas thereon, the second is used for the drawing object (in this code, a brush) that create the graphics on the canvas.

We then create our form $f with the next line, and set its width and height to be 450. Note that this isn't 50*8, since these numbers correspond to the border-to-border edge of the forms window, including titlebar, the close button, etc.

The next line creates our canvas $g by calling the empty constructor. This defaults to the upper-left of the non-system area of the form being equal to 0,0 and increasing to the right and downward, perfect for our needs.

The next line is the actual call that draws the graphics, with $f.add_paint({...}). We construct the graphics calls by double-for looping from 0..7 and carrying a helper variable $y through each outer loop. Each inner loop, we tell our canvas to .FillRectangle(...,...) to draw our squares. The first parameter constructs a new SolidBrush with a color based on where we're at on the board. Other options here could be a hatch, a gradient, etc. The second parameter is a new Rectangle object starting at the specified x $_*50 and $y*50 coordinates and extending for 50 in each direction. Remember that 0,0 is the top-left.

The final line just displays the output with .showDialog(). PowerShell Forms

Note that since we're creating a form object, and PowerShell is all about the pipeline, closing the pop-up form will pass along a System.Enum.DialogResult object of Cancel, since that's technically what the user did. Since we're not capturing or otherwise doing anything with that result, the word Cancel will be displayed to STDOUT when the program concludes, as it was left on the pipeline.


0

SELECT., 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.

Sure it's long, but the first two versions I generated for this task were twice as long.

Output:

screenshot

How it Works:

Here's the program used to generate it:

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

In other words, loop n from 0 to 63, drawing a square at (n%8-4) + (n//8-4)i if (-1)^(n//8 + n%8) is not positive.


Thats not really golf is it :p?
Bruno

I cannot be certain it's the shortest program that does the task, no. However, I am fairly certain that the difference between this and the best possible solution in this language is insignificant compared to the total length of the program. I have one more idea in mind that may or may not be shorter. I'll try it out sometime soon.
quintopia

0

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


0

Python, 57 bytes

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

c is a line of 50 white and 50 black pixels, 200*c is a row with a white in the front, 200*c[::-1] the reverse.

Output as PPM, usage:

python golf_chess.py > chess.ppm
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.