Construye un tablero de ajedrez


23

Lo vi en un desafío PHP. El objetivo es hacer un tablero de ajedrez con 64 cuadrados (8 * 8) con la mínima cantidad de código. Bastante simple, hice el mío en PHP en 356 bytes (no es impresionante, lo sé) y me gustaría ver algunos otros enfoques. Esto se puede hacer en un idioma de su elección, siempre y cuando lo mantenga vainilla, para que no se importen. El recuento de bytes más pequeño gana.

La salida debería verse así:

tapa de la pantalla

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

O legible:

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

Lo siento, no fui muy específico al principio:

  • Los cuadrados deben tener 50 px * 50 px, excepto las imágenes vectoriales.
  • El formato o tamaño de salida no es relevante ni debe ser una imagen.
  • Para fines de evaluación, la salida debe ser visible, como en un archivo de imagen o una captura de pantalla
  • No hay bibliotecas escritas después de la publicación del desafío.

3
Bienvenido a PPCG, tal como está, este desafío no tiene nada que ver con PHP, así que cambié sus etiquetas. Además, creo que su implementación de referencia pertenece como respuesta, no en su pregunta. Como mencionó Stewie, debe especificar el tamaño requerido de la salida de la imagen, así como cosas como detalles del color y si se permite una imagen con pérdida.
FryAmTheEggman

2
¿Entonces algo de magia ASCII no está permitida? :(
Denker

44
¿Qué tan básico es básico? ¿Cuál es la definición de una "importación"?
Pomo de la puerta

66
No necesita ser una imagen, pero cada cuadrado debe tener al menos 50 píxeles. Eso me parece contradictorio.
Peter Taylor

44
Los lenguajes de programación aquí son muy diversos, incluidos algunos que están hechos específicamente para jugar al golf y tienen muchas funciones integradas. Por lo tanto, recomiendo que se elimine la restricción a las funciones que no son de la biblioteca, y que esta pregunta siga la predeterminada (todas las importaciones se cuentan en bytes; no se escriben bibliotecas después de la publicación del desafío).
lirtosiast

Respuestas:


13

Octava, 20 18 bytes

Gracias a @Bruno por reducir 2 bytes.

imshow(invhilb(8))

Resultado:

ingrese la descripción de la imagen aquí

Esta respuesta utiliza una técnica encontrada aquí . También se basa en el escalado automático de imágenes en Octave dependiendo del tamaño de la ventana de la figura.


1
@AlexA. Tampoco estoy completamente convencido de que los cuadrados deben ser exactamente 50x50 píxeles, ya que la siguiente regla dice "El formato o el tamaño de salida no es relevante ...". La gente ha pedido aclaraciones en los comentarios, pero la pregunta no se ha actualizado.
vaso

Editado la pregunta. Probó su código y está funcionando, por lo que actualmente tiene el recuento de bytes más bajo :)
Bruno

También eliminé el> 0 y aún funciona, por lo que puedes afeitar 2 bytes allí
Bruno

@Bruno ¿Qué? Eso es salvaje Aparentemente, está ajustando los valores de la matriz (que son todos << 0 o >> 1) a 0 y 1. ¡Gracias por el consejo, lo actualizaré! : D
vaso

¡Felicidades por 2k!
NoOneIsHere

26

vim, 47 46 44 43

tachado 44 sigue siendo 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

Salidas en formato NetPPM (PBM):

salida


2
Me encanta que puedas completar un desafío de salida gráfica con un editor de texto. ¿Hay algún otro ejemplo de PBM de golf vim?
ankh-morpork

1
@ dohaqatar7 No lo sé, pero ya hice TikZ con vim, por lo que los gráficos en vim son una cosa segura.
Pomo de la puerta

2
Wow, nunca pensé en probar <C-p>en vim sin haber comenzado a escribir una palabra ... ¡eso es 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}

Explicación: Se crea un gradiente lineal diagonal de 100x100px con cuatro puntos para que la mayor parte del gradiente sea transparente, excepto por dos esquinas triangulares de 50px. (Ver el fragmento a continuación). Agregar un segundo gradiente con un desplazamiento de 50x50px completa las mitades que faltan de los cuadrados. Aumentar el tamaño del cuerpo permite que el patrón resultante se repita para llenar todo el tablero de ajedrez.


Solución ordenada Debería funcionar tan bien si deja caer el último } .
insertusernamehere

¿Puedes explicar lo que está pasando aquí?
defecto

@flawr He agregado un segundo fragmento que muestra el efecto parcial, espero que ayude.
Neil

Esto es perfecto.
No es que Charles

¿Realmente necesitas el html{background:#fff}? Por defecto, el 99% de los navegadores configuran el fondo en blanco, afaik
Downgoat

15

Mathematica, 34 bytes

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

La salida es una imagen vectorial y está rodeada por un marco.

En lugar de colocar correctamente 32 rectángulos, podemos generar una matriz binaria y hacer que ArrayPlotfuncione para nosotros:

ingrese la descripción de la imagen aquí


¡Agradable! Gracias por publicarlo.
Un Simmons

Luciendo bien. ¿Puede explicarme dónde define cada cuadrado como 50 px? Además, ¿hay un emulador en línea donde pueda probarlo?
Bruno

@Bruno La salida es un gráfico vectorial, por lo que no existen tamaños de píxeles (la imagen no tiene un tamaño intrínseco; se puede escalar y mostrar en cualquier tamaño). Por eso pregunté.
Martin Ender

44
Espera, GenerateChessBoardWithColorsAsParameters[ColorBlack, ColorWhite, 8, 8, 50, 50]¿no funciona? ;)
Conor O'Brien

3
@ CᴏɴᴏʀO'Bʀɪᴇɴ Sí, pero son 73 bytes.
Martin Ender

10

Mathematica, 81 72 55 bytes

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

De entrada y salida

La imagen es de la evaluación de una versión anterior, pero aún se ve igual.


8

Octava, 48 bytes

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

Esto funciona exactamente igual que mi respuesta de Matlab , pero no hay spiralen Octave. En su lugar, usamos una función que Matlab no tiene: podemos usar la asignación det ya como una expresión, y luego usar tnuevamente en la misma expresión.

(Esta es la versión reescalada, no quiero saturar las respuestas aquí =)


1
La esquina superior izquierda debe ser blanca, no negra.
Pomo de la puerta

2
La salida debe ser un tablero de ajedrez, no se especificó la orientación.
defecto

2
Lo sentimos, defecto, la salida debería ser un tablero de ajedrez. Un tablero de ajedrez siempre es "Reina en su color, blanco a la derecha" (lo que significa que la mano derecha de cada jugador tiene un cuadrado de esquina blanco).
corsiKa

55
Luego imagina a un jugador sentado a la derecha, uno a la izquierda. Nuevamente: esto no fue especificado por el desafío, esa es solo su interpretación.
defecto

8

Pure Bash (sin utilidades externas), 133

Vi el comentario de @ Doorknob como un pequeño desafío. Es un poco largo, pero aquí 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)"
}

La salida está en formato .txt de Imagemagick . Tenga en cuenta que esto es puro Bash. Ni Imagemagick ni ninguna otra utilidad externa se generan para generar esta salida. Sin embargo, la salida puede redirigirse a un archivo .txt y verse con la displayutilidad ImageMagick :

ingrese la descripción de la imagen aquí

Este formato de imagen es bueno porque no solo es texto puro, es poco más que una lista de todos los píxeles (x, y y valor de color), uno por línea. Es una cuestión bastante simple derivar todos los valores de píxeles aritméticamente en un gran bucle.


Respuesta 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]}"
}

La salida está en el formato de archivo de imagen de texto X_PixMap , que también se puede ver con la displayutilidad ImageMagick .

Tenga en cuenta que he sacado tanto del formato XPM como pude de tal manera que displayaún lo aceptaría. Pude sacar todas las repeticiones con la excepción de las "comillas dobles alrededor de cada línea. No tengo idea de qué otras utilidades, si es que las hay, aceptarán esto.


6

PowerShell + navegador de su elección, 149 143 bytes

La incapacidad para usar las importaciones es realmente difícil, ya que todas las llamadas GDI (es decir, las cosas que usa PowerShell para dibujar) están enterradas detrás de las importaciones en .NET ...

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

Editar: guardado seis bytes gracias a @NotThatCharles

Esto utiliza dos bucles for 1..8para generar una cadena HTML grande, similar al ejemplo de PHP proporcionado, y enviarla a la tubería. Cada vez que calculamos si agregará ;background:#000fondos negros tomando nuestra posición actual en el módulo 2 del tablero.

Para usar, redirija la salida al archivo de su elección (por ejemplo, con algo parecido > chessboard.htm) y luego inícielo en el navegador de su elección. Para la captura de pantalla a continuación, utilicé "c.htm" y Firefox.

Firefox


Este no fue inesperado, pero me gusta bastante de alguna manera :)
Bruno

whitey blackpuede ser #fffy #000... pero ¿por qué molestarse en especificar blanco?
No es que Charles

intente en su (";background:#000","")[($a+$_)%2]lugar.
No es que Charles

@NotthatCharles Durr, tenía mi chancleta blanca y negra, por lo que solo mostraba cuadrados blancos. Corregido por 4 bytes adicionales guardados.
AdmBorkBork

5

PHP + CSS + HTML, 136 bytes

Tomando el enfoque de la mesa a un nivel superior:

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

Se basa en gran medida en la amabilidad y CSS de los navegadores.


Buena solución. Aunque tuve que incluir php después de <? e incluya $ i = 0 como el primer parámetro para que funcione correctamente, dando un resultado final de 144 bytes.
Bruno

1
@Bruno Si hace referencia a la advertencia que da, aquí no se tienen en cuenta las advertencias. Sin embargo, hay un billón de formas de desactivarlos. Uno de ellos es reemplazar ++$i<9con @++$i<9. Además, para que funcione sin <?php, uno debe tener la directiva short_open_tags=On, que es predeterminada en algunos entornos. Lea más en stackoverflow.com/a/2185331/2729937
Ismael Miguel

5

Jalea, 26 bytes

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

Como Jelly no tiene soporte para imágenes integradas, imprimimos una imagen PPM.

Pruébalo en línea!(placa más pequeña para velocidad, PPM sin procesar)

Resultados

captura de pantalla

Cómo 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.

Versión no competitiva (24 bytes)

El nuevo intérprete de Jelly que es anterior a esta publicación no se vectorizó xcorrectamente. Con la última versión, se pueden guardar 2 bytes adicionales.

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

La única diferencia es que x50produce una lista plana (con cada elemento original repetido 50 veces), por Flo que ya no es necesario.


1
Parece que estabas escribiendo una respuesta de Java y te quedaste dormido ligeramente mientras escribías un ;...;)
Conor O'Brien

1
@ CᴏɴᴏʀO'Bʀɪᴇɴ Java? Debe estar en Java 10.0, Golfing Edition, porque no se parece a ningún Java que haya visto ...
BalinKingOfMoria

5

MATL , 11 (27) bytes

8:t!+Q2\TYG

Esto produce la siguiente figura. No tiene un tamaño intrínseco; se escala automáticamente según el tamaño de la ventana de la figura. Esto parece estar permitido por el desafío.

ingrese la descripción de la imagen aquí

Explicación

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

Si el escalado automático no está permitido:

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

produce la siguiente figura con cuadrados de 50x50 píxeles

Explicación

ingrese la descripción de la imagen aquí

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

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

Explicación

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

Pruébelo aquí (solo los valores de color)

Salida:

Salida


Buen trabajo en el conteo de bytes, pero necesito una salida válida con cuadrados visibles :)
Bruno

¡Salida de @Bruno añadida! Instalé PIL solo para ti: O (en realidad no lo había probado antes)
Azul

@muddyfish perdón por las molestias y gracias. El tablero debe comenzar y terminar con un cuadrado blanco aunque :)
Bruno

4

Matlab, 47 (24) bytes

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

Esto funciona exactamente igual que mi respuesta Octave , pero pude usar el spiralque guardó un byte. spiral(n)hace una nxnmatriz y la llena en espiral con la primeran^2 enteros.

Si se permiten los vectores, podríamos hacerlo en 24 bytes:

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

(Esta es la versión reescalada, no quiero saturar las respuestas aquí =)


4

FFmpeg, 78 82 100 bytes

Finalmente pude limpiar el tablero.

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

ingrese la descripción de la imagen aquí


Mayores :

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

Saldrá con error, pero después de producir la imagen a continuación.

ingrese la descripción de la imagen aquí

(el tablero ha recogido algo de polvo)


3

CJam, 27 bytes

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

Pruébalo en línea!(placa más pequeña para velocidad, PPM sin procesar)

Resultados

captura de pantalla

Cómo 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 con utf-8 - 66b

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

▚ es utf directo-corto para la entidad & # 9626;

Carácter Unicode 'CUADRANTE SUPERIOR IZQUIERDO E INFERIOR DERECHO' (U + 259A)

tonto, estaba buscando una solución de 1 utf-8 char-habría sido ... 1b!


2
Parece que el tamaño de fuente está mal.
Qwertiy

1
En su lugar, debe usarlo para que el cuadrado superior izquierdo sea blanco como en un tablero de ajedrez estándar. Además, use en <pre>lugar de <div>para que pueda usar nuevas líneas en lugar de <br>.
Neil

Su recuento de bytes parece ser incorrecto, debe ser de 98 bytes, ya que cuenta para 3 bytes con la codificación UTF-8. En el futuro, puede usar esto para verificar su conteo de bytes UTF-8
Taylor Scott

2

PHP, 166 158 155 bytes

Funciona en PHP 7.0.2 (etiquetas cortas habilitadas) y 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;}

Puede usar la propiedad bgcolor=0para generar el fondo negro. ¡Eso debería ahorrar una tonelada de bytes! Y en lugar de $v%2==0usar $v&1, lo que debería reducir algunos 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 >

Notas

  • Afeitado 16 bytes - Gracias @insertusernamehere
  • Afeitado 10 bytes - Gracias @ msh210
  • Afeitado 30 bytes - Gracias @Ismael Miguel

1
Probablemente esto se pueda jugar aún más, pero aquí tienes ( 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

Si bien no eliminé las tareas iniciales (funciona, la peculiaridad personal no me deja hacerlo), gracias por esto
Shaun H

1
Según incluso la versión estricta de HTML 4, puede omitir la etiqueta final TR.
msh210

1
Reemplace ++$i<65con @++$i<65, ya que está preocupado por las advertencias. Esto significa que puede reducir $m=$i=0a solo $m=0, ahorrándole 2 bytes. En lugar de echo 'a'.'b'.'c';, puedes hacerlo echo 'a','b','c';. Esto significa que echopuede estar echo'<td style="width:50px;height:50px;background:#',($i+$m)%2?'':'000','">';ahorrándole más 2 bytes. Además, los atributos HTML no requieren comillas. Elimínalos y sabe 2 bytes. Además, hay un bgcoloratributo mucho más corto , que reduce más bytes. ¡Puede usar a print()en el forpara guardar aún más bytes!
Ismael Miguel

1
Para ahorrar aún más, he reemplazado ($i+$m)%2 con $i+@$m&1, lo que me permitió eliminar eso $m=0. Adelante, he podido eliminar tu ify reemplazarlo con una operación tormentosa. Para ahorrar aún más , eliminé tu styley agregué las propiedades widthy height. Para profundizar aún más en el lado hacky, pensé que Chrome 48.0.2564.103 m usa negro si el color de fondo es 0, usando la propiedad bgcolor. ¡Eso me permitió reducir más! ¡Más reducciones es mejor!
Ismael Miguel

1

JavaScript, 150

Esto definitivamente se puede jugar al 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
Huh, nunca supe sobre las cadenas de plantillas en JavaScript. Guay.
Cheezey

1

iKe , 24 bytes

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

tablero

El núcleo de la técnica es generar una lista de coordenadas x, dividirlas y luego tomar un producto cruzado de igualdad para generar un mapa de bits apropiado. Usando ejemplos más pequeños con fines 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)

pruébalo aquí . Técnicamente, iKe funciona en un lienzo lógico de 160x160 píxeles, pero en modo de pantalla completa (el valor predeterminado cuando se sigue un enlace guardado) esto se amplía en 3x. Creo que esto sigue el espíritu de la pregunta, ya que el programa podría ensamblar un mapa de bits mucho más grande con el mismo número de caracteres; simplemente se reduce a una limitación de visualización arbitraria.

Actualizar:

iKe no está diseñado principalmente para el golf, pero la codificación en vivo aún se beneficia de la brevedad y los valores predeterminados sanos. Como resultado de jugar con este problema, he decidido permitirle usar una paleta predeterminada si no se proporciona ninguna. Esta solución particular ahora podría expresarse con:

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

Ahorro (no elegible) 3 bytes.


1

Rubí con zapatos, 97 caracteres

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

Salida de muestra:

Tablero de ajedrez dibujado por Ruby con zapatos


Debe comenzar y terminar con blanco. De lo contrario, buen trabajo :)
Bruno

Ups Gracias @ Bruno. Fijo.
manatwork

Genial, votado :)
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

Salida de muestra:

Tablero de ajedrez dibujado por Lua + LÖVE


Grr! Lua 5.3 tiene //un operador de división de enteros, pero aparentemente todavía no hay un LÖVE construido con un LuaJIT con él. ☹
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 no Golf 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))

En el modo por lotes, cree una imagen en blanco, cree una selección rectangular de 50x50, llénela y luego muévala repetidamente alrededor de la imagen, rellenando cuadrados. Luego guarde c.pngy salga.

Salida:

tablero de ajedrez png


1

J 33 31 bytes

Usé un truco con binario.

   load'viewmat'
   viewmat 8 8$#:43605

... porque 43605 en binario es 1010101001010101 (usamos #:primitivo para obtenerlo). Primitivo $da forma a esta matriz de dígitos binarios en una matriz especificada con las dimensiones 8 8. Y viewmates solo una biblioteca del sistema.
ingrese la descripción de la imagen aquí
La ventana es completamente redimensionable.

Gracias a @FrownyFrog por acortarlo a:

   load'viewmat'
   viewmat#:8$170 85

viewmat 8$#:170 85es 1 byte más corto
FrownyFrog

1
viewmat#:8$170 85
FrownyFrog

1

Excel VBA, 82 bytes

Función de ventana inmediata anónima VBE que no toma entrada y genera un tablero de ajedrez al rango A1:H8en el objeto ActiveSheet

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

Esta función funciona creando primero 4 columnas negras en el rango B1:B8,D1:D8,F1:F8,H1:H8y luego compensando el color en filas 2,4,6 and 8a la izquierda por una celda.

Salida de muestra

Tablero de damas


0

Perl 5 - 80

Genera un archivo .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()

(las nuevas líneas cuentan igual que el punto y coma, por lo que las nuevas líneas son legibles)

A diferencia de mi otra respuesta , esta usa los ensamblados .NET para llamar a GDI + funciones . Curiosamente, es aproximadamente el doble de largo.

Las dos primeras líneas cargan los ensamblajes System.Windows.Formsy System.Drawing. El primero se usa para la ventana literal y el lienzo sobre el mismo, el segundo se usa para el objeto de dibujo (en este código, un pincel) que crea los gráficos en el lienzo.

Luego creamos nuestro formulario $fcon la siguiente línea, y establecemos su widthy heightser 450. Tenga en cuenta que esto no es50*8 , ya que estos números corresponden al borde de borde a borde de la ventana de formularios, incluida la barra de título, el botón de cierre, etc.

La siguiente línea crea nuestro lienzo $gllamando al constructor vacío. Este valor predeterminado es que la esquina superior izquierda del área no del sistema del formulario sea igual a0,0 y aumenta a la derecha y hacia abajo, perfecto para nuestras necesidades.

La siguiente línea es la llamada real que dibuja los gráficos, con $f.add_paint({...}). Construimos las llamadas de gráficos mediante un bucle doble para 0..7y llevando una variable auxiliar a $ytravés de cada bucle externo. En cada bucle interno, le decimos a nuestro lienzo .FillRectangle(...,...)que dibuje nuestros cuadrados. El primer parámetro construye un nuevo SolidBrushcon un color basado en dónde estamos en el tablero. Otras opciones de aquí podrían ser una escotilla, un gradiente, etc. El segundo parámetro es un nuevo Rectangleobjeto a partir de las x especificados $_*50y $y*50las coordenadas y que se extiende por 50en cada dirección. Recuerda que 0,0es la esquina superior izquierda.

La línea final solo muestra la salida con .showDialog(). Formularios de PowerShell

Tenga en cuenta que dado que estamos creando un objeto de formulario , y PowerShell tiene que ver con la tubería, cerrar el formulario emergente pasará un System.Enum.DialogResultobjeto de Cancel, ya que eso es técnicamente lo que hizo el usuario. Dado que no estamos capturando ni haciendo nada con ese resultado, la palabra Cancelse mostrará a STDOUT cuando finalice el programa, ya que se dejó en la tubería.


0

SELECCIONAR. , 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 es largo, pero las dos primeras versiones que generé para esta tarea fueron dos veces más largas.

Salida:

captura de pantalla

Cómo funciona:

Aquí está el programa utilizado para 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")

En otras palabras, repita n de 0 a 63, dibujando un cuadrado en (n% 8-4) + (n // 8-4) i si (-1) ^ (n // 8 + n% 8) no es positivo.


Eso no es realmente golf, ¿verdad?
Bruno

No puedo estar seguro de que es el programa más corto que hace la tarea, no. Sin embargo, estoy bastante seguro de que la diferencia entre esta y la mejor solución posible en este idioma es insignificante en comparación con la duración total del programa. Tengo una idea más en mente que puede o no ser más corta. Lo intentaré pronto.
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])

ces una línea de 50 píxeles blancos y 50 negros, 200*ces una fila con un blanco en el frente, 200*c[::-1]el reverso.

Salida como PPM, uso:

python golf_chess.py > chess.ppm
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.