Costruisci una scacchiera


23

L'ho visto in una sfida PHP. L'obiettivo è realizzare una scacchiera con 64 quadrati (8 * 8) con la quantità minima di codice. Abbastanza semplice, ho fatto il mio in PHP in 356 byte (non impressionante, lo so) e mi piacerebbe vedere altri approcci. Questo può essere fatto in una lingua a tua scelta, purché lo conservi alla vaniglia, quindi nessuna importazione. Vince il conteggio di byte più piccolo.

L'output dovrebbe essere simile al seguente:

screenshot

E il mio codice:

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

O leggibile:

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

Modificare:

Mi dispiace non ero molto preciso all'inizio:

  • I quadrati dovrebbero avere 50px * 50px ad eccezione delle immagini vettoriali.
  • Il formato o le dimensioni dell'output non sono rilevanti né devono essere un'immagine.
  • Ai fini della valutazione, l'output deve essere visibile, ad esempio in un file di immagine o in uno screenshot
  • Nessuna biblioteca scritta dopo la pubblicazione della sfida

3
Benvenuto in PPCG, così com'è, questa sfida non ha nulla a che fare con PHP, quindi ho cambiato i tuoi tag. Inoltre, credo che la tua implementazione di riferimento appartenga come una risposta, non nella tua domanda. Come ha suggerito Stewie, dovresti specificare la dimensione richiesta dell'output dell'immagine, così come elementi come i colori specifici e se è consentita un'immagine con perdita di dati.
FryAmTheEggman,

2
Quindi un po 'di magia ASCII non è consentita? :(
Denker,

4
Quanto è basilare? Qual è la definizione di "importazione"?
Maniglia della porta

6
Non deve essere un'immagine, ma ogni quadrato deve essere di almeno 50 px? Mi sembra contraddittorio.
Peter Taylor,

4
I linguaggi di programmazione qui sono molto diversi, compresi alcuni che sono fatti appositamente per il golf e hanno molte funzioni integrate. Pertanto, raccomando di rimuovere la restrizione alle funzioni non librerie e che questa domanda segua invece il valore predefinito (tutte le importazioni sono state conteggiate nel conteggio dei byte; nessuna libreria scritta dopo la pubblicazione della sfida).
lirtosiast,

Risposte:


13

Ottava, 20 18 byte

Grazie a @Bruno per la rasatura di 2 byte.

imshow(invhilb(8))

Risultato:

enter image description here

Questa risposta utilizza una tecnica trovata qui . Si basa anche sul ridimensionamento automatico delle immagini in Octave a seconda delle dimensioni della finestra della figura.


1
@AlexA. Inoltre, non sono del tutto convinto che i quadrati debbano essere esattamente 50x50 pixel, poiché la regola successiva dice "Il formato o le dimensioni dell'output non sono rilevanti ...". Le persone hanno chiesto chiarimenti nei commenti, ma la domanda non è stata aggiornata.
bicchiere

Modificato la domanda. Ho testato il tuo codice e funziona, quindi attualmente hai il conteggio di byte più basso :)
Bruno

Anche rimosso> 0 e funziona ancora in modo da poter radere 2 byte lì
Bruno

@Bruno Cosa? Questo è selvaggio. Quindi apparentemente sta bloccando i valori della matrice (che sono tutti << 0 o >> 1) a 0 e 1. Grazie per il suggerimento, aggiornerò! : D
becher,

Congratulazioni per 2k!
NoOneIsHere

26

vim, 47 46 44 43

barrato 44 è ancora regolare 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

Uscite in formato NetPPM (PBM):

output


2
Adoro che puoi completare una sfida di output grafico con un editor di testo. Ci sono altri esempi di PBM di golf vim?
Ankh-Morpork,

1
@ dohaqatar7 Non lo so, ma ho già fatto TikZ con vim, quindi la grafica in vim è una cosa certa.
Maniglia della porta

2
Wow, non avrei mai pensato di provare <C-p>in vim senza aver iniziato a digitare una parola ... è davvero utile!
Desty,

16

CSS, 244 byte

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}

Spiegazione: Viene creato un gradiente lineare diagonale 100x100px con quattro arresti in modo che la maggior parte del gradiente sia trasparente ad eccezione di due angoli triangolari da 50px. (Vedi snippet di seguito). L'aggiunta di un secondo gradiente con un offset di 50x50px riempie le metà mancanti dei quadrati. Aumentando le dimensioni del corpo, è possibile ripetere il motivo risultante per riempire l'intera scacchiera.


Soluzione pulita. Dovrebbe funzionare anche se si rilascia l'ultimo } .
inserire nomeutentequi

Puoi spiegare cosa sta succedendo qui?
Flawr

@flawr Ho aggiunto un secondo frammento che mostra l'effetto parziale, spero che sia di aiuto.
Neil,

Questo è perfetto.
Non che Charles il

Hai davvero bisogno del html{background:#fff}? Per impostazione predefinita, il 99% dei browser imposta lo sfondo su bianco, dopo
Downgoat

15

Mathematica, 34 byte

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

L'output è un'immagine vettoriale ed è racchiuso in una cornice.

Invece di posizionare correttamente 32 rettangoli, possiamo semplicemente generare una matrice binaria e farci ArrayPlotlavorare:

enter image description here


Bello! Grazie per averlo pubblicato.
A Simmons,

Sembra buono Puoi spiegarmi per favore dove definisci ogni quadrato come 50px? Inoltre, esiste un emulatore online in cui posso provarlo?
Bruno,

@Bruno L'output è una grafica vettoriale, quindi non ci sono dimensioni dei pixel (l'immagine non ha dimensioni intrinseche - può essere ridimensionata e visualizzata a qualsiasi dimensione). Ecco perché ho chiesto.
Martin Ender,

4
Aspetta, GenerateChessBoardWithColorsAsParameters[ColorBlack, ColorWhite, 8, 8, 50, 50]non funziona? ;)
Conor O'Brien il

3
@ CᴏɴᴏʀO'Bʀɪᴇɴ Lo fa, ma sono 73 byte.
Martin Ender,

10

Mathematica, 81 72 55 byte

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

Input Output

L'immagine è una valutazione di una versione precedente, ma sembra sempre la stessa.


8

Ottava, 48 byte

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

Funziona esattamente come la mia risposta a Matlab , ma spiralin Octave non c'è . Invece usiamo una funzione che Matlab non ha: possiamo usare l'assegnazione di tgià come espressione, e successivamente triutilizzarla nella stessa espressione.

(Questa è la versione riscalata, non voglio ingombrare le risposte qui =)


1
L'angolo in alto a sinistra dovrebbe essere bianco, non nero.
Maniglia della porta

2
L'output dovrebbe essere una scacchiera, l'orientamento non è stato specificato.
Flawr

2
Spiacente, flawr, l'output dovrebbe essere una scacchiera. Una scacchiera è sempre "Regina sul suo colore, bianca sulla destra" (il che significa che la mano destra di ogni giocatore ha un quadrato bianco ad angolo).
corsiKa

5
Quindi immagina un giocatore seduto a destra, uno a sinistra. Ancora: questo non è stato specificato dalla sfida, questa è solo la tua interpretazione.
Flawr

8

Pure Bash (senza utility esterne), 133

Ho visto il commento di @ Doorknob come una sfida. È un po 'lungo, ma qui va:

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

L'output è in formato .txt di Imagemagick . Nota che questo è puro Bash. Né Imagemagick né altre utilità esterne vengono generate per generare questo output. Tuttavia, l'output può essere reindirizzato a un file .txt e visualizzato con l' displayutilità ImageMagick :

inserisci qui la descrizione dell'immagine

Questo formato di immagine è bello perché non è solo testo puro, è poco più di un elenco di tutti i pixel (valore x, y e colore), uno per riga. È abbastanza semplice derivare aritmeticamente tutti i valori dei pixel in un unico grande ciclo.


Risposta precedente, 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]}"
}

L'output è nel formato di file di immagine di testo X_PixMap , che può anche essere visualizzato con l' displayutilità ImageMagick .

Nota che ho preso il più possibile dal formato XPM in modo tale che displaylo accetterei comunque. Sono stato in grado di estrarre tutta la caldaia ad eccezione di" doppie virgolette attorno a ciascuna riga. Non ho idea di quali altri servizi, se presenti, lo accetteranno.


6

PowerShell + browser a scelta, 149 143 byte

L'incapacità di usare le importazioni è davvero dura, poiché tutte le chiamate GDI (ovvero le cose che PowerShell usa per disegnare) sono sepolte dietro le importazioni in .NET ...

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

Modifica: sei byte salvati grazie a @NotThatCharles

Questo utilizza due for-loop da 1..8per generare una stringa HTML di grandi dimensioni, simile all'esempio di PHP fornito, e inviarlo alla pipeline. Ogni volta calcoliamo se aggiungere ;background:#000per gli sfondi neri prendendo la nostra posizione corrente sul tabellone modulo 2.

Per utilizzarlo, reindirizza l'output nel file di tua scelta (ad esempio, con qualcosa di simile > chessboard.htm) e quindi avvialo nel browser di tua scelta. Per lo screenshot qui sotto, ho usato "c.htm" e Firefox.

firefox


Questo non era rispettato ma in qualche modo mi piace :)
Bruno

whitee blackpuò essere #fffe #000... ma perché preoccuparsi di specificare il bianco?
Non che Charles il

prova (";background:#000","")[($a+$_)%2]invece.
Non che Charles il

@NotthatCharles Durr, aveva le mie infradito bianche e nere, quindi produceva solo quadrati bianchi. Corretto per ulteriori 4 byte salvati.
AdmBorkBork,

5

PHP + CSS + HTML, 136 byte

Portare l'approccio al tavolo a un livello superiore:

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

Genera il seguente codice:

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

Si basa fortemente sulla gentilezza dei browser e sui CSS.


Buona soluzione Ho dovuto includere php dopo <? e includi $ i = 0 come primo parametro per farlo funzionare correttamente, dando un risultato finale di 144 byte.
Bruno,

1
@Bruno Se si fa riferimento all'avvertimento che fornisce, gli avvisi vengono ignorati qui. Tuttavia, ci sono miliardi di modi per disabilitarli. Uno di loro è da sostituire ++$i<9con @++$i<9. Inoltre, affinché funzioni senza <?php, è necessario disporre della direttiva short_open_tags=On, che è predefinita in alcuni ambienti. Maggiori informazioni su stackoverflow.com/a/2185331/2729937
Ismael Miguel

5

Gelatina, 26 byte

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

Poiché Jelly non supporta le immagini integrate, stampiamo un'immagine PPM.

Provalo online!(scheda più piccola per velocità, PPM grezzo)

risultati

immagine dello schermo

Come funziona

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.

Versione non competitiva (24 byte)

Il più recente interprete di Jelly che precede questo post non ha vettorializzato xcorrettamente. Con l'ultima versione, è possibile salvare 2 byte aggiuntivi.

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

L'unica differenza è che x50produce un elenco semplice (con ogni elemento originale ripetuto 50 volte), quindi Fnon è più necessario.


1
Sembra che tu stia scrivendo una risposta java e ti sei addormentato leggermente mentre scrivevi un ;...;)
Conor O'Brien

1
@ CᴏɴᴏʀO'Bʀɪᴇɴ Java? Devi essere su Java 10.0, Golfing Edition, perché non assomiglia a nessun Java che ho visto ....
BalinKingOfMoria

5

MATL , 11 (27) byte

8:t!+Q2\TYG

Questo produce la seguente figura. Non ha una dimensione intrinseca; viene ridimensionato automaticamente in base alle dimensioni della finestra della figura. Questo sembra essere consentito dalla sfida.

inserisci qui la descrizione dell'immagine

Spiegazione

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

Se il ridimensionamento automatico non è consentito:

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

produce la figura seguente con quadrati di 50x50 pixel

Spiegazione

inserisci qui la descrizione dell'immagine

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

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

Spiegazione

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 equivalente

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

Provalo qui (solo i valori di colore)

Produzione:

Produzione


Bel lavoro sul conteggio dei byte ma ho bisogno di un output valido con quadrati visibili :)
Bruno

Aggiunta uscita @Bruno! Ho installato PIL solo per te: O (non l'avevo mai testato prima)
Blue

@muddyfish scusa per il disturbo e grazie. La tavola deve iniziare con e finire con un quadrato bianco però :)
Bruno

4

Matlab, 47 (24) byte

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

Funziona esattamente come la mia risposta di Octave , ma sono stato in grado di utilizzare il spiralquale ha salvato un byte. spiral(n)crea una nxnmatrice e la riempie a spirale con i primi n^2numeri interi.

Se la grafica vettoriale è consentita, potremmo farlo in 24 byte:

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

(Questa è la versione riscalata, non voglio ingombrare le risposte qui =)


4

FFmpeg, 78 82 100 byte

Finalmente sono riuscito a pulire la tavola.

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

inserisci qui la descrizione dell'immagine


Più vecchio :

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

Uscirà con errore, ma dopo aver prodotto l'immagine qui sotto.

inserisci qui la descrizione dell'immagine

(la tavola ha raccolto un po 'di polvere)


3

CJam, 27 byte

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

Provalo online! (scheda più piccola per velocità, PPM grezzo)

risultati

immagine dello schermo

Come funziona

"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 con utf-8 - 66b

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

▚ è un utf diretto per l'entità & # 9626;

Carattere Unicode 'QUADRANT SUPERIORE SINISTRA E INFERIORE DESTRO' (U + 259A)

sciocco, stavo cercando una soluzione 1 utf-8-sarebbe stata ... 1b!


2
Sembra che la dimensione del carattere sia errata.
Qwertiy,

1
Dovresti usare invece in modo che il quadrato in alto a sinistra sia bianco come su una scacchiera standard. Inoltre, utilizzare <pre>invece di in <div>modo da poter utilizzare newline anziché <br>.
Neil,

Il numero di byte sembra essere errato, dovrebbe essere di 98 byte, poiché conta 3 byte usando la codifica UTF-8. In futuro, è possibile utilizzare questo per controllare l'UTF-8 byte Count
Taylor Scott

2

PHP, 166 158 155 byte

Funziona in PHP 7.0.2 (short tag abilitati) e 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;}

È possibile utilizzare la proprietà bgcolor=0per generare lo sfondo nero. Ciò dovrebbe radere via una tonnellata di byte! E invece di $v%2==0usare $v&1, che dovrebbe radere qualche byte.
Ismael Miguel,

2

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

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

Gli appunti

  • Rasato 16 byte - Grazie @inserireusernamehere
  • Rasato 10 byte - Grazie @ msh210
  • Rasato 30 byte - Grazie @Ismael Miguel

1
Probabilmente questo può essere giocato a golf ancora di più, ma qui si va ( 152 byte ):<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

Anche se non ho rimosso i compiti iniziali (Funziona, la stranezza personale non me lo permette), Grazie per questo
Shaun H

1
Secondo anche la versione rigorosa di HTML 4, puoi saltare il tag end per TR.
msh210,

1
Sostituisci ++$i<65con @++$i<65, poiché sei preoccupato per gli avvisi. Ciò significa che è possibile ridurre $m=$i=0a solo $m=0, risparmiando 2 byte. Invece di echo 'a'.'b'.'c';, puoi farlo echo 'a','b','c';. Ciò significa che echopuoi echo'<td style="width:50px;height:50px;background:#',($i+$m)%2?'':'000','">';risparmiare più di 2 byte. Inoltre, gli attributi HTML non richiedono virgolette. Rimuoverli e sabre 2 byte. Inoltre, c'è un bgcolorattributo molto più breve , che riduce più byte! È possibile utilizzare a print()in forper salvare ancora più byte!
Ismael Miguel,

1
Per risparmiare ancora di più, ho sostituito ($i+$m)%2con $i+@$m&1, che mi ha permesso di rimuoverlo $m=0. In seguito, sono stato in grado di rimuovere il tuo ife l'ho sostituito con un'operazione trenaria. Per risparmiare ancora di più , ho rimosso il tuo stylee aggiunto le proprietà widthe height. Per ottenere ancora di più dal lato confuso, ho pensato che Chrome 48.0.2564.103 m usa il nero se il colore di sfondo è 0, usando la proprietà bgcolor. Ciò mi ha permesso di ridurre sempre di più! Più riduzioni è meglio!
Ismael Miguel,

1

JavaScript, 150

Questo può sicuramente essere giocato a golf. Crea 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
Eh, non ho mai saputo delle stringhe di template in JavaScript. Freddo.
Cheezey,

1

iKe , 24 byte

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

tavola

Il nucleo della tecnica è generare un elenco di coordinate x, divmod e quindi prendere un prodotto incrociato di uguaglianza per generare una bitmap appropriata. Utilizzando esempi più piccoli a scopo illustrativo:

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

provalo qui . Tecnicamente iKe funziona su un canvas logico da 160x160 pixel, ma in modalità a schermo intero (impostazione predefinita quando si segue un collegamento salvato) viene ingrandito di 3x. Penso che questo segua ancora lo spirito della domanda, poiché il programma potrebbe assemblare una bitmap molto più grande con lo stesso numero di caratteri; si riduce a una limitazione di visualizzazione arbitraria.

Aggiornare:

iKe non è progettato principalmente per il golf, ma il livecoding beneficia ancora della brevità e delle impostazioni predefinite. Come risultato di armeggiare con questo problema, ho deciso di consentirgli di utilizzare una tavolozza predefinita se non ne viene fornita nessuna. Questa particolare soluzione potrebbe ora essere espressa con:

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

Salvataggio (non idoneo) 3 byte.


1

Rubino con scarpe, 97 caratteri

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

Uscita campione:

Scacchiera disegnata da Ruby con scarpe


Dovrebbe iniziare e finire con il bianco. Altrimenti buon lavoro :)
Bruno,

Ops. Grazie @Bruno. Fisso.
arte

Grande, votato :)
Bruno

1

Lua + LÖVE, 138 113 112 106 caratteri

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

Uscita campione:

Scacchiera disegnata da Lua + LÖVE


Grr! Lua 5.3 ha un //operatore di divisione intera, ma a quanto pare non esiste ancora un LÖVE costruito con un LuaJIT che lo caratterizza. ☹
arte

1

GIMP, 539 byte

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 modalità batch, creare un'immagine vuota, creare una selezione rettangolare 50x50, riempirla, quindi spostarla ripetutamente attorno all'immagine, riempiendo i quadrati. Quindi salva su c.pnged esci.

Produzione:

scacchiera png


1

J, 33 31 byte

Ho usato un trucco con il binario.

   load'viewmat'
   viewmat 8 8$#:43605

... perché 43605 in binario è 1010101001010101 (usiamo la #:primitiva per ottenerlo). Primitive $modella questa matrice di cifre binarie in una matrice specificata con le dimensioni8 8 . Ed viewmatè solo una libreria di sistema.
inserisci qui la descrizione dell'immagine
La finestra è completamente ridimensionabile.

Grazie a @FrownyFrog per averlo abbreviato in:

   load'viewmat'
   viewmat#:8$170 85

viewmat 8$#:170 85è più corto di 1 byte
FrownyFrog

1
viewmat#:8$170 85
FrownyFrog,

1

Excel VBA, 82 byte

Funzione di finestra immediata VBE anonima che non accetta input e genera una scacchiera nell'intervallo A1:H8sull'oggetto ActiveSheet

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

Questa funzione funziona creando prima 4 colonne nere nell'intervallo B1:B8,D1:D8,F1:F8,H1:H8e quindi compensando la colorazione nelle righe 2,4,6 and 8a sinistra di una cella.

Uscita campione

CheckerBoard


0

Perl 5 - 80

Genera un file .PBM:

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

0

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

(le nuove righe contano come punti e virgola, quindi le nuove righe per la leggibilità)

A differenza dell'altra mia risposta , questa utilizza gli assembly .NET per chiamare GDI + chiamate di funzione . È interessante notare che è circa il doppio della lunghezza.

Le prime due righe caricano gli assembly System.Windows.Formse System.Drawing. Il primo viene utilizzato per la finestra letterale e la tela su di essa, il secondo viene utilizzato per l'oggetto di disegno (in questo codice, un pennello) che crea la grafica sulla tela.

Quindi creiamo il nostro modulo $fcon la riga successiva e ne impostiamo widthe heightlo diventeremo 450. Nota che non lo è 50*8, poiché questi numeri corrispondono al bordo da bordo a bordo della finestra dei moduli, tra cui barra del titolo, pulsante di chiusura, ecc.

La riga successiva crea la nostra tela $gchiamando il costruttore vuoto. L'impostazione predefinita è in alto a sinistra dell'area non di sistema del modulo pari a0,0 e aumenta a destra e verso il basso, perfetto per le nostre esigenze.

La riga successiva è la chiamata effettiva che disegna la grafica, con $f.add_paint({...}). Costruiamo le chiamate grafiche facendo doppio loop per 0..7e trasportando una variabile helper $yattraverso ciascun loop esterno. Ad ogni anello interno, diciamo alla nostra tela .FillRectangle(...,...)di disegnare i nostri quadrati. Il primo parametro crea un nuovo SolidBrushcon un colore basato su dove ci troviamo sul tabellone. Altre opzioni qui potrebbero essere un tratteggio, un gradiente, ecc. Il secondo parametro è un nuovo Rectangleoggetto che inizia alla x specificata $_*50e alle $y*50coordinate e si estende per 50ogni direzione. Ricorda che 0,0è in alto a sinistra.

L'ultima riga mostra solo l'output con .showDialog(). Moduli PowerShell

Si noti che poiché stiamo creando un oggetto modulo e PowerShell riguarda la pipeline, la chiusura del modulo pop-up passerà lungo un System.Enum.DialogResultoggetto di Cancel, dal momento che tecnicamente è ciò che l'utente ha fatto. Dal momento che non stiamo acquisendo o altrimenti facendo qualcosa con quel risultato, la parola Cancelverrà mostrata a STDOUT al termine del programma, poiché è stata lasciata sulla pipeline.


0

SELEZIONARE. , 8844 8278 byte

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

Certo, è lungo, ma le prime due versioni che ho generato per questo compito sono state il doppio.

Produzione:

immagine dello schermo

Come funziona:

Ecco il programma utilizzato per generarlo:

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 altre parole, il ciclo n da 0 a 63, disegnando un quadrato in (n% 8-4) + (n // 8-4) i se (-1) ^ (n // 8 + n% 8) non è positivo.


Quello non è davvero golf è: p?
Bruno,

Non posso essere certo che sia il programma più breve a svolgere il compito, no. Tuttavia, sono abbastanza certo che la differenza tra questa e la migliore soluzione possibile in questa lingua sia insignificante rispetto alla lunghezza totale del programma. Ho in mente un'altra idea che potrebbe essere o meno breve. Lo proverò presto.
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 byte

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

c è una linea di 50 pixel bianchi e 50 pixel neri, 200*c è una riga con un bianco nella parte anteriore, 200*c[::-1]il contrario.

Output come PPM, utilizzo:

python golf_chess.py > chess.ppm
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.