Construa um tabuleiro de xadrez


23

Vi isso em um desafio de PHP. O objetivo é fazer um tabuleiro de xadrez com 64 quadrados (8 * 8) com a quantidade mínima de código. Simples o suficiente, eu criei o meu em PHP em 356 bytes (não é impressionante, eu sei) e gostaria de ver algumas outras abordagens. Isso pode ser feito no idioma de sua escolha, desde que você mantenha a baunilha, portanto, não importa. A menor contagem de bytes vence.

A saída deve ficar assim:

captura de tela

E meu código:

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

Ou legível:

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

Editar:

Desculpe, não fui muito específico no começo:

  • Os quadrados devem ter 50px * 50px, exceto para imagens vetoriais.
  • O formato ou tamanho da saída não é relevante nem precisa ser uma imagem.
  • Para fins de avaliação, a saída deve estar visível, como em um arquivo de imagem ou em uma captura de tela
  • Nenhuma biblioteca escrita após o lançamento do desafio

3
Bem-vindo ao PPCG, como está, esse desafio não tem nada a ver com PHP, então mudei suas tags. Além disso, acredito que sua implementação de referência pertence como resposta, não na sua pergunta. Como Stewie falou, você deve especificar o tamanho necessário para a saída da imagem, bem como itens específicos de cores e se uma imagem com perda é permitida.
FryAmTheEggman

2
Então, algumas mágicas ASCII não são permitidas? :( #
4996 Denker

4
Quão básico é básico? Qual é a definição de uma "importação"?
Maçaneta

6
Não precisa ser uma imagem, mas cada quadrado deve ter pelo menos 50 px? Isso me parece contraditório.
31416 Peter

4
As linguagens de programação aqui são muito diversas, incluindo algumas que são feitas especificamente para o golfe e têm muitas funções internas. Portanto, recomendo que a restrição a funções que não sejam de biblioteca seja removida e que essa pergunta siga o padrão (todas as importações contadas na contagem de bytes; nenhuma biblioteca escrita após o lançamento do desafio).
precisa saber é o seguinte

Respostas:


13

Oitava, 20 18 bytes

Obrigado a @Bruno por cortar 2 bytes.

imshow(invhilb(8))

Resultado:

insira a descrição da imagem aqui

Esta resposta usa uma técnica encontrada aqui . Ele também conta com o dimensionamento automático de imagens no Octave, dependendo do tamanho da janela da figura.


1
@AlexA. Também não estou inteiramente convencido de que os quadrados devem ter exatamente 50x50 pixels, pois a regra a seguir diz "Formato ou tamanho da saída não é relevante ...". As pessoas pediram esclarecimentos nos comentários, mas a pergunta não foi atualizada.
proveta de

Editou a pergunta. Testado o seu código e ele está trabalhando, por isso atualmente você tem o menor número de bytes :)
de Bruno

Também removeu a> 0 e ainda funciona de modo que você pode raspar 2 bytes não
de Bruno

@Bruno What? Isso é selvagem. Então, aparentemente, está fixando os valores da matriz (que são todos << 0 ou >> 1) para 0 e 1. Obrigado pela dica, eu vou atualizar! : D
copo

Parabéns pelo 2k!
NoOneIsHere

26

vim, 47 46 44 43

riscado 44 ainda é regular 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

Saídas no formato NetPPM (PBM):

saída


2
Eu amo que você possa concluir um desafio de saída gráfica com um editor de texto. Existem outros exemplos de PBMs do golf vim?
Ankh-morpork 04/02

1
@ dohaqatar7 Não sei, mas já fiz o TikZ com o vim antes, então os gráficos no vim são uma coisa certa.
Maçaneta

2
Uau, nunca pensei em experimentar o <C-p>vim sem ter começado a digitar uma palavra ... isso é realmente útil!
Desty

16

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}

Explicação: Um gradiente linear diagonal de 100x100px é criado com quatro paradas para que a maior parte do gradiente seja transparente, exceto por dois cantos triangulares de 50px. (Veja o trecho abaixo). A adição de um segundo gradiente com um deslocamento de 50x50px preenche as metades ausentes dos quadrados. Aumentar o tamanho do corpo permite que o padrão resultante se repita para preencher todo o tabuleiro de xadrez.


Solução pura. Deve funcionar também se você deixar cair o último } .
insertusernamehere

Você pode explicar o que está acontecendo aqui?
flawr

@ flawr Adicionei um segundo trecho mostrando o efeito parcial, espero que ajude.
Neil

Isto é perfeito.
Não que Charles seja o dia

Você realmente precisa do html{background:#fff}? Por padrão, 99% dos navegadores definem o plano de fundo para branco, depois
Downgoat 5/16/16

15

Mathematica, 34 bytes

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

A saída é uma imagem vetorial e é cercada em um quadro.

Em vez de posicionar corretamente 32 retângulos, podemos apenas gerar uma matriz binária e ArrayPlottrabalhar para nós:

insira a descrição da imagem aqui


Agradável! Obrigado por publicá-lo.
A Simmons

Parece bom. Você pode me explicar onde você define cada quadrado como 50px? Além disso, existe um emulador online onde eu possa testá-lo?
de Bruno

@Bruno A saída é um gráfico vetorial, portanto não existem tamanhos de pixel (a imagem não tem tamanho intrínseco - pode ser dimensionada e exibida em qualquer tamanho). É por isso que eu pedi.
Martin Ender

4
Espera, GenerateChessBoardWithColorsAsParameters[ColorBlack, ColorWhite, 8, 8, 50, 50]não funciona? ;)
Conor O'Brien

3
@ CᴏɴᴏʀO'Bʀɪᴇɴ Sim, mas são 73 bytes.
Martin Ender

10

Mathematica, 81 72 55 bytes

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

Entrada / Saída

A imagem é da avaliação de uma versão anterior, mas ainda parece a mesma.


8

Oitava, 48 bytes

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

Isso funciona exatamente da mesma forma que minha resposta do Matlab , mas não existe spiralno Octave. Em vez disso, usamos um recurso que o Matlab não possui: Podemos usar a atribuição de tjá como uma expressão e, posteriormente, usar tnovamente na mesma expressão.

(Esta é a versão redimensionada, não quero bagunçar as respostas aqui =)


1
O canto superior esquerdo deve ser branco, não preto.
Maçaneta

2
A saída deve ser um tabuleiro de damas, a orientação não foi especificada.
flawr

2
Desculpe, falha, a saída deve ser um tabuleiro de xadrez. Um tabuleiro de xadrez é sempre "Rainha da sua cor, branca à direita" (ou seja, a mão direita de cada jogador tem um quadrado de canto branco).
CorsiKa

5
Então imagine um jogador sentado à direita e outro à esquerda. Novamente: isso não foi especificado pelo desafio, é apenas sua interpretação.
flawr

8

Pure Bash (sem utilitários externos), 133

Eu vi o comentário da @ Doorknob como um desafio. É um pouco longo, mas aqui vai:

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

A saída está no formato .txt do Imagemagick . Observe que isso é puro Bash. Nem o Imagemagick nem quaisquer outros utilitários externos são gerados para gerar essa saída. No entanto, a saída pode ser redirecionada para um arquivo .txt e visualizada com o displayutilitário ImageMagick :

insira a descrição da imagem aqui

Esse formato de imagem é bom porque não é apenas texto puro, é pouco mais do que uma lista de todos os pixels (x, ye valor da cor), um por linha. É uma questão bastante simples derivar todos os valores de pixel aritmeticamente em um grande loop.


Resposta anterior, 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]}"
}

A saída está no formato de arquivo de imagem de texto X_PixMap , que também pode ser visualizado com o displayutilitário ImageMagick .

Observe que tirei o máximo do formato XPM que consegui e que displayainda o aceitaria. Consegui tirar todo o clichê com exceção das "aspas duplas em torno de cada linha. Não faço ideia de que outros utilitários - se houver - aceitarão isso.


6

PowerShell + navegador de sua escolha, 149 143 bytes

A incapacidade de usar importações é realmente difícil, pois todas as chamadas GDI (ou seja, as coisas que o PowerShell usa para desenhar) estão ocultas atrás das importações no .NET ...

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

Editar - salvou seis bytes graças a @NotThatCharles

Isso usa dois for-loops de 1..8 para gerar uma grande seqüência de caracteres HTML, semelhante ao exemplo PHP fornecido, e enviá-la para o pipeline. Cada vez que calculamos se devemos acrescentar ;background:#000os fundos pretos, assumimos nossa posição atual no módulo 2 do quadro.

Para usar, redirecione a saída para o arquivo de sua escolha (por exemplo, com algo parecido > chessboard.htm) e, em seguida, inicie-a no navegador de sua escolha. Para a captura de tela abaixo, usei "c.htm" e Firefox.

Raposa de fogo


Este foi unespected mas eu gosto bastante dele de alguma forma :)
de Bruno

whitee blackpode ser #fffe #000... mas por que se preocupar em especificar branco?
Não que Charles seja o dia

tente em (";background:#000","")[($a+$_)%2]vez disso.
Não que Charles seja o dia

@NotthatCharles Durr, tinha meu branco e preto com flip-flop, então ele só estava produzindo quadrados brancos. Corrigido para 4 bytes adicionais salvos.
AdmBorkBork #

5

PHP + CSS + HTML, 136 bytes

Levando a mesa a um nível mais alto:

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

Ele gera o seguinte código:

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

Ele depende muito da gentileza e do CSS dos navegadores.


Boa solução. Tho eu tive que incluir php depois de <? e inclua $ i = 0 como o primeiro parâmetro para fazê-lo funcionar corretamente, fornecendo um resultado final de 144 bytes.
de Bruno

1
@Bruno Se você se referir ao aviso dado, os avisos são desconsiderados aqui. No entanto, há um trilhão de maneiras de desativá-los. Um deles é substituir ++$i<9por @++$i<9. Além disso, para que ele funcione sem <?php, é necessário ter a diretiva short_open_tags=On, que é padrão em alguns ambientes. Leia mais em stackoverflow.com/a/2185331/2729937
Ismael Miguel

5

Geléia, 26 bytes

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

Como o Jelly não tem suporte para imagens incorporadas, imprimimos uma imagem PPM.

Experimente online!(placa menor para velocidade, PPM bruto)

Resultados

captura de tela

Como funciona

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.

Versão não concorrente (24 bytes)

O mais novo intérprete Jelly que antecede este post não foi vetorizado xcorretamente. Com a versão mais recente, 2 bytes adicionais podem ser salvos.

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

A única diferença é que x50produz uma lista simples (com todos os elementos originais repetidos 50 vezes), Fnão sendo mais necessário.


1
Parece que você estava escrevendo uma resposta java e adormeceu um pouco, enquanto digitando um ;...;)
Conor O'Brien

1
@ CᴏɴᴏʀO'Bʀɪᴇɴ Java? Você deve estar em Java 10,0, Golfe Edition, causa que não se parece com qualquer Java que eu vi ....
BalinKingOfMoria

5

MATL , 11 (27) bytes

8:t!+Q2\TYG

Isso produz a figura a seguir. Não possui um tamanho intrínseco; é dimensionado automaticamente, dependendo do tamanho da janela da figura. Isso parece ser permitido pelo desafio.

insira a descrição da imagem aqui

Explicação

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 o dimensionamento automático não for permitido:

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

produz a figura a seguir com quadrados de 50x50 pixels

Explicação

insira a descrição da imagem aqui

'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

Pitão, 28 26 bytes

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

Explicação

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

Equivalente em Python

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

Experimente aqui (apenas os valores das cores)

Saída:

Output


Bom trabalho na contagem de bytes, mas eu preciso de uma saída válida com quadrados visíveis :)
de Bruno

@Bruno Output adicionado! Eu instalei o PIL apenas para você: O (eu realmente não tinha testado isso antes) #
Blue

@muddyfish desculpe pelo problema e obrigado. A placa deve começar e terminar com um quadrado branco tho :)
de Bruno

4

Matlab, 47 (24) bytes

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

Isso funciona exatamente da mesma forma que a minha resposta do Oitava , mas pude usar spiralqual salvou um byte. spiral(n)cria uma nxnmatriz e a preenche em espiral com os primeiros n^2números inteiros.

Se vectorgraphics for permitido, poderíamos fazê-lo em 24 bytes:

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

(Esta é a versão redimensionada, não quero bagunçar as respostas aqui =)


4

FFmpeg, 78 82 100 bytes

Finalmente cheguei a limpar o quadro.

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

enter image description here


Mais velhos :

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

Sai com erro, mas depois de produzir a imagem abaixo.

enter image description here

(a placa coletou um pouco de poeira)


3

CJam, 27 bytes

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

Experimente online!(placa menor para velocidade, PPM bruto)

Resultados

screenshot

Como funciona

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

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

▚ é utf curto-direto para a entidade & # 9626;

Caractere Unicode 'QUADRANTE SUPERIOR ESQUERDO E INFERIOR' (U + 259A)

bobo me, estava procurando uma solução de 1 utf-8 char - teria sido ... 1b!


2
Parece que o tamanho da fonte está errado.
6306 Qwertiy

1
Você deve usar para que o quadrado superior esquerdo fique branco como em um tabuleiro de xadrez padrão. Além disso, use em <pre>vez de <div>para que você possa usar novas linhas em vez de <br>.
Neil

Seu número de bytes parece errado, deve ter 98 bytes, pois conta com 3 bytes usando a codificação UTF-8. No futuro, você poderá usar isso para verificar o seu UTF-8 Byte Count
Taylor Scott

2

PHP, 166 158 155 bytes

Funciona no PHP 7.0.2 (tags curtas ativadas) e no 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;}

Você pode usar a propriedade bgcolor=0para gerar o plano de fundo preto. Isso deve economizar uma tonelada de bytes! E, em vez de $v%2==0, use $v&1, o que deve economizar alguns bytes.
Ismael Miguel

2

PHP> = 5.4, 175 159 149 116 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 >

Notas

  • Raspado 16 bytes - Obrigado @insertusernamehere
  • Raspado 10 bytes - Obrigado @ msh210
  • Raspou 30 bytes - Obrigado @Ismael Miguel

1
Provavelmente isso pode ser jogado ainda mais, mas aqui está ( 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

Enquanto eu não remover as atribuições iniciais (Works, capricho pessoal não me permite fazê-lo), Obrigado por este
Shaun H

1
De acordo com a versão estrita do HTML 4, você pode pular a tag final para TR.
Msh210

1
Substitua ++$i<65por @++$i<65, pois você está preocupado com os avisos. Isso significa que você pode reduzir $m=$i=0para apenas $m=0, economizando 2 bytes. Em vez de echo 'a'.'b'.'c';, você pode fazer echo 'a','b','c';. Isso significa que você echopode echo'<td style="width:50px;height:50px;background:#',($i+$m)%2?'':'000','">';economizar mais 2 bytes. Além disso, os atributos HTML não requerem aspas. Remova-os e saiba 2 bytes. Além disso, há um bgcoloratributo muito mais curto , que reduz mais bytes! Você pode usar print()a forpara salvar ainda mais bytes!
Ismael Miguel

1
Para economizar ainda mais, substitui ($i+$m)%2por $i+@$m&1, o que me permitiu remover isso $m=0. Adiante, consegui remover o seu ife substituí-lo por uma operação trenária. Para economizar ainda mais , removi o seu stylee adicionamos as propriedades widthe height. Para obter ainda mais para o lado hacky, eu descobri que o Chrome 48.0.2564.103 m usa preto se a cor de fundo é 0, usando a propriedade bgcolor. Isso me permitiu reduzir ainda mais! Mais reduções é melhor!
Ismael Miguel

1

JavaScript, 150

Definitivamente, isso pode ser jogado no golfe. Cria 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
Nunca soube sobre strings de modelo em JavaScript. Legal.
Cheezey

1

iKe , 24 bytes

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

board

O núcleo da técnica é gerar uma lista de coordenadas x, divmodá-las e, em seguida, obter um produto cruzado de igualdade para gerar um bitmap apropriado. Usando exemplos menores para fins ilustrativos:

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

tente aqui . Tecnicamente, o iKe funciona em uma tela lógica de 160 x 160 pixels, mas no modo de tela cheia (o padrão ao seguir um link salvo), isso é aumentado em 3x. Eu acho que isso ainda está seguindo o espírito da pergunta, pois o programa poderia montar um bitmap muito maior com a mesma contagem de caracteres; tudo se resume a uma limitação de exibição arbitrária.

Atualizar:

O iKe não foi projetado principalmente para golfe, mas a codificação ao vivo ainda se beneficia de concisão e padrões saudáveis. Como resultado de mexer com esse problema, decidi permitir que ele use uma paleta padrão, se nenhuma for fornecida. Agora, essa solução específica pode ser expressa com:

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

Salvando (inelegível) 3 bytes.


1

Rubi com sapatos, 97 caracteres

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

Saída de amostra:

Chessboard drawn by Ruby with Shoes


Deve começar e terminar com branco. Caso contrário bom trabalho :)
de Bruno

Opa Obrigado @Bruno. Fixo.
Manatwork

Grande, upvoted :)
de Bruno

1

Lua + LÖVE, 138 113 112 106 caracteres

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

Saída de amostra:

Chessboard drawn by Lua + LÖVE


Grr! Lua 5.3 possui um //operador de divisão inteira, mas aparentemente ainda não existe um LÖVE construído com um LuaJIT apresentando-o. ☹
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))'

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

No modo de lote, crie uma imagem em branco, crie uma seleção retangular de 50x50, preencha-a e mova-a repetidamente pela imagem, preenchendo quadrados. Salve c.pnge saia.

Saída:

chessboard png


1

J, 33 31 bytes

Eu usei um truque com binário.

   load'viewmat'
   viewmat 8 8$#:43605

... porque 43605 no binário é 1010101001010101 (usamos #:primitivo para obtê-lo). Primitivo $forma essa matriz de dígitos binários em uma matriz especificada com as dimensões 8 8. E viewmaté apenas uma biblioteca do sistema.
enter image description here
A janela é totalmente redimensionável.

Obrigado a @FrownyFrog por reduzi-lo para:

   load'viewmat'
   viewmat#:8$170 85

viewmat 8$#:170 85é 1 byte mais curto
FrownyFrog 9/17

1
viewmat#:8$170 85
precisa saber é o seguinte

1

Excel VBA, 82 bytes

Função de janela imediata VBE anônima que não recebe entrada e gera um tabuleiro de damas para o intervalo A1:H8no objeto ActiveSheet

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

Essa função funciona criando primeiro 4 colunas pretas no intervalo B1:B8,D1:D8,F1:F8,H1:H8e depois compensando a coloração nas linhas 2,4,6 and 8à esquerda por uma célula.

Saída de amostra

CheckerBoard


0

Perl 5-80

Gera um arquivo .PBM:

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

(novas linhas contam o mesmo que ponto e vírgula, portanto, novas linhas para facilitar a leitura)

Ao contrário da minha outra resposta , esta usa os assemblies .NET para chamar GDI + chamadas de função . Curiosamente, é cerca de duas vezes o comprimento.

As duas primeiras linhas carregam os conjuntos System.Windows.Formse System.Drawing. O primeiro é usado para a janela literal e a tela nela, o segundo é usado para o objeto de desenho (neste código, um pincel) que cria os gráficos na tela.

Em seguida, criamos nosso formulário $fcom a próxima linha e definimos seu widthe heightpara ser 450. Observe que não 50*8, pois esses números correspondem à borda da borda da janela de formulários, incluindo a barra de título, o botão Fechar etc.

A próxima linha cria nossa tela $gchamando o construtor vazio. Por padrão, a parte superior esquerda da área não sistêmica do formulário é igual 0,0e aumenta para a direita e para baixo, perfeita para nossas necessidades.

A próxima linha é a chamada real que desenha os gráficos, com $f.add_paint({...}). Construímos as chamadas gráficas dando um loop duplo para 0..7e carregando uma variável auxiliar $yatravés de cada loop externo. Cada loop interno, dizemos à nossa tela .FillRectangle(...,...)para desenhar nossos quadrados. O primeiro parâmetro constrói um novo SolidBrushcom uma cor com base em onde estamos no quadro. Outras opções aqui podem ser uma hachura, um gradiente etc. O segundo parâmetro é um novo Rectangleobjeto que começa no x especificado $_*50e $y*50coordena e se estende para 50cada direção. Lembre-se de que 0,0é o canto superior esquerdo.

A linha final apenas exibe a saída com .showDialog(). PowerShell Forms

Observe que, uma vez que estamos criando um objeto de formulário , e o PowerShell tem tudo a ver com o pipeline, o fechamento do formulário pop-up passará um System.Enum.DialogResultobjeto Cancel, pois é tecnicamente o que o usuário fez. Como não estamos capturando ou fazendo algo com esse resultado, a palavra Cancelserá exibida para STDOUT quando o programa for concluído, como foi deixado no 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.

Claro que é longo, mas as duas primeiras versões que geramos para esta tarefa tinham o dobro do tempo.

Saída:

screenshot

Como funciona:

Aqui está o programa usado para gerá-lo:

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

Em outras palavras, o loop n de 0 a 63, desenhando um quadrado em (n% 8-4) + (n // 8-4) i se (-1) ^ (n // 8 + n% 8) não for positivo.


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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.