Construire un échiquier


23

J'ai vu cela dans un défi PHP. L'objectif est de faire un échiquier de 64 cases (8 * 8) avec le minimum de code. Assez simple, j'ai fait le mien en PHP en 356 octets (pas impressionnant, je sais) et j'aimerais voir d'autres approches. Cela peut être fait dans la langue de votre choix, tant que vous le gardez vanille, donc pas d'importations. Le plus petit nombre d'octets gagne.

La sortie devrait ressembler à ceci:

capture d'écran

Et mon code:

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

Ou lisible:

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

Modifier:

Désolé, je n'étais pas très précis au début:

  • Les carrés doivent avoir 50px * 50px sauf pour les images vectorielles.
  • Le format ou la taille de sortie n'est pas pertinent ni ne doit être une image.
  • À des fins d'évaluation, la sortie doit être visible, comme dans un fichier image ou une capture d'écran
  • Aucune bibliothèque écrite après la publication du défi

3
Bienvenue dans PPCG, tel qu'il est, ce défi n'a vraiment rien à voir avec PHP, j'ai donc changé vos balises. Aussi, je crois que votre implémentation de référence appartient comme une réponse, pas dans votre question. Comme l'a mentionné Stewie, vous devez spécifier la taille requise de la sortie d'image, ainsi que des éléments tels que les spécificités de couleur et si une image avec perte est autorisée.
FryAmTheEggman

2
Donc, la magie ASCII n'est pas autorisée? :(
Denker

4
Quelle est la base de base? Quelle est la définition d'une "importation"?
Poignée de porte

6
Il n'est pas nécessaire que ce soit une image mais chaque carré doit avoir au moins 50 pixels? Cela me semble contradictoire.
Peter Taylor

4
Les langages de programmation ici sont très divers, y compris certains qui sont spécialement conçus pour le golf et qui ont de nombreuses fonctions intégrées. Par conséquent, je recommande que la restriction aux fonctions non liées aux bibliothèques soit supprimée et que cette question suive la valeur par défaut (toutes les importations sont comptées en nombre d'octets; aucune bibliothèque écrite après la publication du défi).
lirtosiast

Réponses:


13

Octave, 20 18 octets

Merci à @Bruno d' avoir rasé 2 octets.

imshow(invhilb(8))

Résultat:

entrez la description de l'image ici

Cette réponse utilise une technique trouvée ici . Il repose également sur la mise à l'échelle automatique des images dans Octave en fonction de la taille de la fenêtre de la figure.


1
@AlexA. Je ne suis pas non plus entièrement convaincu que les carrés doivent être exactement 50x50 pixels, car la règle suivante dit "Le format ou la taille de sortie n'est pas pertinent ...". Des gens ont demandé des éclaircissements dans les commentaires, mais la question n'a pas été mise à jour.
bécher

Modifié la question. Vous avez testé votre code et cela fonctionne, vous avez donc actuellement le nombre d'octets le plus bas :)
Bruno

Également supprimé le> 0 et cela fonctionne toujours afin que vous puissiez y raser 2 octets
Bruno

@Bruno Quoi? C'est fou. C'est donc apparemment le serrage des valeurs de la matrice (qui sont toutes << 0 ou >> 1) à 0 et 1. Merci pour l'astuce, je vais mettre à jour! : D
bécher

Félicitations pour 2k!
NoOneIsHere

26

vim, 47 46 44 43

barré 44 est toujours régulier 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

Sorties au format NetPPM (PBM):

sortie


2
J'adore le fait que vous puissiez relever un défi de sortie graphique avec un éditeur de texte. Existe-t-il d'autres exemples de PBM provenant de golf vim?
ankh-morpork

1
@ dohaqatar7 Je ne sais pas, mais j'ai déjà fait TikZ avec vim, donc les graphiques dans vim sont sûrs.
Poignée de porte

2
Wow, je n'ai jamais pensé essayer <C-p>en vim sans avoir commencé à taper un mot ... c'est vraiment pratique!
Desty

16

CSS, 244 octets

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}

Explication: Un dégradé linéaire diagonal de 100x100px est créé avec quatre arrêts de sorte que la plupart du dégradé est transparent à l'exception de deux coins triangulaires de 50px. (Voir l'extrait ci-dessous). L'ajout d'un deuxième dégradé avec un décalage de 50x50px remplit les moitiés manquantes des carrés. L'augmentation de la taille du corps permet ensuite au motif résultant de se répéter pour remplir tout l'échiquier.


Solution soignée. Cela devrait aussi fonctionner si vous laissez tomber le dernier } .
insertusernamehere

Pouvez-vous expliquer ce qui se passe ici?
flawr

@flawr J'ai ajouté un deuxième extrait montrant l'effet partiel, j'espère que cela aide.
Neil

C'est parfait.
Pas que Charles

En avez-vous vraiment besoin html{background:#fff}? Par défaut, 99% des navigateurs définissent l'arrière-plan sur blanc, afaik
Downgoat

15

Mathematica, 34 octets

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

La sortie est une image vectorielle et est entourée d'un cadre.

Au lieu de positionner correctement 32 rectangles, nous pouvons simplement générer une matrice binaire et ArrayPlottravailler pour nous:

entrez la description de l'image ici


Agréable! Merci de l'avoir posté.
Un Simmons

En regardant bien. Pouvez-vous s'il vous plaît m'expliquer où définissez-vous chaque carré comme 50px? Existe-t-il également un émulateur en ligne où je peux le tester?
Bruno

@Bruno La sortie est un graphique vectoriel, donc il n'y a pas de taille de pixel (l'image n'a pas de taille intrinsèque - elle peut être mise à l'échelle et affichée à n'importe quelle taille). C'est pourquoi j'ai demandé.
Martin Ender

4
Attendez, GenerateChessBoardWithColorsAsParameters[ColorBlack, ColorWhite, 8, 8, 50, 50]ça ne marche pas? ;)
Conor O'Brien

3
@ CᴏɴᴏʀO'Bʀɪᴇɴ Oui, mais c'est 73 octets.
Martin Ender

10

Mathematica, 81 72 55 octets

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

Entrée sortie

L'image est une évaluation d'une version précédente, mais reste toujours la même.


8

Octave, 48 octets

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

Cela fonctionne exactement de la même manière que ma réponse Matlab , mais il n'y spiralen a pas dans Octave. Au lieu de cela, nous utilisons une fonctionnalité que Matlab n'a pas: nous pouvons utiliser l'affectation de tdéjà comme expression, puis utiliser ultérieurementt nouveau dans la même expression.

(Ceci est la version redimensionnée, je ne veux pas encombrer les réponses ici =)


1
Le coin supérieur gauche doit être blanc et non noir.
Poignée de porte

2
La sortie doit être un damier, l'orientation n'a pas été spécifiée.
flawr

2
Désolé, flawr, la sortie devrait être un échiquier. Un échiquier est toujours "Reine de sa couleur, blanc à droite" (ce qui signifie que la main droite de chaque joueur a un carré blanc).
corsiKa

5
Imaginez ensuite un joueur assis à droite, un à gauche. Encore une fois: cela n'a pas été spécifié par le défi, c'est juste votre interprétation.
flawr

8

Pure Bash (pas d'utilitaires externes), 133

J'ai vu le commentaire de @ Doorknob comme un peu un défi. C'est un peu long, mais voici:

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 sortie est au format .txt d'Imagemagick . Notez que c'est du pur Bash. Ni Imagemagick ni aucun autre utilitaire externe ne sont générés pour générer cette sortie. Cependant, la sortie peut être redirigée vers un fichier .txt et affichée avec l' displayutilitaire ImageMagick :

entrez la description de l'image ici

Ce format d'image est agréable car non seulement il s'agit de texte pur, il n'est guère plus qu'une liste de tous les pixels (x, y et valeur de couleur), un par ligne. Il est assez simple de dériver arithmétiquement toutes les valeurs de pixels dans une grande boucle.


Réponse précédente, 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 sortie est au format de fichier image texte X_PixMap , qui peut également être visualisée avec ImageMagickdisplay utilitaire .

Notez que j'ai retiré autant du format XPM que possible, ce qui displayl'accepterait toujours. J'ai pu retirer tout le passe-partout à l'exception des "guillemets doubles autour de chaque ligne. Aucune idée des autres utilitaires - le cas échéant - qui accepteront cela.


6

Navigateur PowerShell + de votre choix, 149 143 octets

L'incapacité à utiliser les importations est vraiment difficile, car tous les appels GDI (c'est-à-dire les éléments que PowerShell utilise pour dessiner) sont enfouis derrière les importations dans .NET ...

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

Modifier - économisé six octets grâce à @NotThatCharles

Cela utilise deux boucles for 1..8pour générer une chaîne HTML big-ol ', similaire à l'exemple PHP fourni, et la sortir sur le pipeline. Chaque fois, nous calculons s'il faut ajouter ;background:#000les fonds noirs en prenant notre position actuelle sur la carte modulo 2.

Pour l'utiliser, redirigez la sortie dans le fichier de votre choix (par exemple, avec quelque chose comme > chessboard.htm), puis lancez-le dans le navigateur de votre choix. Pour la capture d'écran ci-dessous, j'ai utilisé "c.htm" et Firefox.

Firefox


Celui-ci était inespéré mais je l'aime bien en quelque sorte :)
Bruno

whiteet blackpeut être #fffet #000... mais pourquoi s'embêter à spécifier du blanc?
Pas que Charles

essayez à la (";background:#000","")[($a+$_)%2]place.
Pas que Charles

@NotthatCharles Durr, a fait basculer mes bascules blanches et noires, donc il ne produisait que des carrés blancs. Corrigé pour 4 octets supplémentaires enregistrés.
AdmBorkBork

5

PHP + CSS + HTML, 136 octets

Amener la table à un niveau supérieur:

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

Il génère le code suivant:

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

Il s'appuie fortement sur la gentillesse des navigateurs et CSS.


Bonne solution. Je devais inclure php après <? et inclure $ i = 0 comme premier paramètre pour le faire fonctionner correctement, donnant un résultat final de 144 octets.
Bruno

1
@Bruno Si vous vous référez à l'avertissement qu'il donne, les avertissements ne sont pas pris en compte ici. Cependant, il y a mille milliards de façons de les désactiver. L'un d'eux est de remplacer ++$i<9par @++$i<9. De plus, pour que cela fonctionne sans <?php, il faut avoir la directive short_open_tags=On, qui est par défaut sur certains environnements. En savoir plus sur stackoverflow.com/a/2185331/2729937
Ismael Miguel

5

Gelée, 26 octets

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

Étant donné que Jelly ne prend pas en charge les images intégrées, nous imprimons une image PPM.

Essayez-le en ligne!(planche plus petite pour la vitesse, PPM brut)

Résultats

screenshot

Comment ça marche

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.

Version non concurrente (24 octets)

Le nouvel interprète Jelly antérieur à ce post ne s'est pas xcorrectement vectorisé . Avec la dernière version, 2 octets supplémentaires peuvent être enregistrés.

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

La seule différence est que cela x50donne une liste plate (avec chaque élément d'origine répété 50 fois), il Fn'est donc plus nécessaire.


1
Il semble que vous écriviez une réponse java et vous vous êtes endormi légèrement en tapant un ;...;)
Conor O'Brien

1
@ CᴏɴᴏʀO'Bʀɪᴇɴ Java? Vous devez être sur Java 10.0, Golfing Edition, car cela ne ressemble à aucun Java que j'ai vu ....
BalinKingOfMoria

5

MATL , 11 (27) octets

8:t!+Q2\TYG

Cela produit la figure suivante. Il n'a pas de taille intrinsèque; il est automatiquement mis à l'échelle en fonction de la taille de la fenêtre de la figure. Cela semble être permis par le défi.

enter image description here

Explication

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 la mise à l'échelle automatique n'est pas autorisée:

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

produit la figure suivante avec des carrés de 50x50 pixels

Explication

enter image description here

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

5

Pyth, 28 26 octets

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

Explication

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

Équivalent Python

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

Essayez-le ici (juste les valeurs de couleur)

Sortie:

Output


Beau travail sur le nombre d'octets mais j'ai besoin d'une sortie valide avec des carrés visibles :)
Bruno

Sortie @Bruno ajoutée! J'ai installé PIL juste pour vous: O (je ne l'avais pas testé auparavant)
Blue

@muddyfish désolé pour les ennuis et merci. Le tableau doit commencer par et se terminer par un carré blanc mais :)
Bruno

4

Matlab, 47 (24) octets

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

Cela fonctionne exactement de la même manière que ma réponse Octave , mais j'ai pu utiliser spiralce qui a sauvé un octet. spiral(n)fait une nxnmatrice et la remplit en spirale avec le premiern^2 entiers.

Si les graphiques vectoriels sont autorisés, nous pourrions le faire en 24 octets:

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

(Ceci est la version redimensionnée, je ne veux pas encombrer les réponses ici =)


4

FFmpeg, 78 82 100 octets

J'ai enfin pu nettoyer la planche.

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

enter image description here


Plus vieux :

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

Quittera avec erreur, mais après avoir produit l'image ci-dessous.

enter image description here

(le conseil a ramassé de la poussière)


3

CJam, 27 octets

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

Essayez-le en ligne! (planche plus petite pour la vitesse, PPM brut)

Résultats

screenshot

Comment ça marche

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

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

▚ est utf court-direct pour l'entité & # 9626;

Caractère Unicode 'QUADRANT SUPÉRIEUR GAUCHE ET INFÉRIEUR DROIT' (U + 259A)

idiot, je cherchais une solution de 1 utf-8 chars - aurait été ... 1b!


2
Il semble que la taille de la police soit incorrecte.
Qwertiy

1
Vous devez utiliser à la place de sorte que le carré en haut à gauche soit blanc comme sur un échiquier standard. Utilisez également <pre>au lieu de <div>pour utiliser des sauts de ligne à la place de <br>.
Neil

Votre nombre d'octets semble incorrect, il devrait être de 98 octets, car il compte pour 3 octets en utilisant le codage UTF-8. À l'avenir, vous pouvez utiliser ce pour vérifier votre UTF-8 Nombre d' octets
Taylor Scott

2

PHP, 166 158 155 octets

Fonctionne en PHP 7.0.2 (raccourcis activés) et 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;}

Vous pouvez utiliser la propriété bgcolor=0pour générer l'arrière-plan noir. Cela devrait raser une tonne d'octets! Et au lieu de $v%2==0, utilisez $v&1, qui devrait raser quelques octets.
Ismael Miguel

2

PHP> = 5.4, 175 159 149 116 octets

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

Remarques

  • Rasé 16 octets - Merci @insertusernamehere
  • Rasé 10 octets - Merci @ msh210
  • Rasé 30 octets - Merci @Ismael Miguel

1
Cela peut probablement être joué encore plus, mais c'est <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;}}
parti

Bien que je n'aie pas supprimé les affectations initiales (Works, bizarrerie personnelle ne me laissera pas le faire), merci pour cela
Shaun H

1
Selon même la version stricte de HTML 4, vous pouvez ignorer la balise de fin pour TR.
msh210

1
Remplacez ++$i<65par @++$i<65, car vous êtes préoccupé par les avertissements. Cela signifie que vous pouvez réduire $m=$i=0à juste $m=0, vous économisant 2 octets. Au lieu de cela echo 'a'.'b'.'c';, vous pouvez le faire echo 'a','b','c';. Cela signifie que vous echopouvez echo'<td style="width:50px;height:50px;background:#',($i+$m)%2?'':'000','">';économiser plus de 2 octets. De plus, les attributs HTML ne nécessitent pas de guillemets. Retirez-les et sabrez 2 octets. De plus, il y a un bgcolorattribut beaucoup plus court , qui réduit plus d'octets! Vous pouvez utiliser un print()dans le forpour économiser encore plus d'octets!
Ismael Miguel

1
Pour économiser encore plus, je l'ai remplacé ($i+$m)%2par $i+@$m&1, ce qui m'a permis de supprimer cela $m=0. Devant, j'ai pu retirer le vôtre ifet le remplacer par une opération trénaire. Pour économiser encore plus , j'ai supprimé votre styleet ajouté les propriétés widthet height. Pour aller encore plus loin dans le côté hacky, j'ai pensé que Chrome 48.0.2564.103 m utilise du noir si la couleur d'arrière-plan est 0, en utilisant la propriété bgcolor. Cela m'a permis de réduire toujours plus! Plus de réductions, c'est mieux!
Ismael Miguel

1

JavaScript, 150

Cela peut certainement être joué au golf. Il crée du 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, je ne connaissais pas les chaînes de modèles en JavaScript. Cool.
Cheezey

1

iKe , 24 octets

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

planche

Le cœur de la technique consiste à générer une liste de coordonnées x, à les diviser et à prendre ensuite un produit croisé d'égalité pour générer un bitmap approprié. Utilisation d'exemples plus petits à des fins d'illustration:

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

essayez-le ici . Techniquement, iKe fonctionne sur un canevas logique de 160 x 160 pixels, mais en mode plein écran (par défaut lorsque vous suivez un lien enregistré), celui-ci est augmenté de 3 fois. Je pense que cela suit toujours l'esprit de la question, car le programme pourrait assembler un bitmap beaucoup plus grand avec le même nombre de caractères; cela revient à une limitation d'affichage arbitraire.

Mise à jour:

iKe n'est pas principalement conçu pour le golf, mais le codage en direct bénéficie toujours de la brièveté et des valeurs par défaut saines. À la suite de bricolage avec ce problème, j'ai décidé de lui permettre d'utiliser une palette par défaut si aucune n'est fournie. Cette solution particulière pourrait désormais s'exprimer avec:

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

Enregistrement (non éligible) de 3 octets.


1

Rubis avec des chaussures, 97 caractères

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

Exemple de sortie:

Échiquier dessiné par Ruby avec des chaussures


Devrait commencer et se terminer par du blanc. Sinon, bon travail :)
Bruno

Oops. Merci @Bruno. Fixé.
manatwork

Super, a voté :)
Bruno

1

Lua + LÖVE, 138 113 112 106 caractères

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

Exemple de sortie:

Échiquier dessiné par Lua + LÖVE


Grr! Lua 5.3 a un //opérateur de division entier, mais apparemment il n'y a toujours pas de LÖVE construit avec un LuaJIT le mettant en vedette. ☹
manatwork

1

GIMP, 539 octets

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

Script-fu Schéma non golfé:

(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 mode batch, créez une image vierge, créez une sélection rectangulaire 50x50, remplissez-la, puis déplacez-la à plusieurs reprises autour de l'image, en remplissant des carrés. Ensuite, enregistrez c.pnget quittez.

Sortie:

échiquier png


1

J, 33 31 octets

J'ai utilisé un truc avec binaire.

   load'viewmat'
   viewmat 8 8$#:43605

... parce que 43605 en binaire est 1010101001010101 (nous utilisons une #:primitive pour l'obtenir). Primitive $façonne ce tableau de chiffres binaires en une matrice spécifiée avec les dimensions 8 8. Et ce viewmatn'est qu'une bibliothèque système.
entrez la description de l'image ici
La fenêtre est entièrement redimensionnable.

Merci à @FrownyFrog de l'avoir raccourci pour:

   load'viewmat'
   viewmat#:8$170 85

viewmat 8$#:170 85est 1 octet plus court
FrownyFrog

1
viewmat#:8$170 85
FrownyFrog

1

Excel VBA, 82 octets

Fonction de fenêtre immédiate VBE anonyme qui ne prend aucune entrée et génère un damier sur la plage A1:H8 de l'objet ActiveSheet

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

Cette fonction fonctionne en créant d'abord 4 colonnes noires dans la plage B1:B8,D1:D8,F1:F8,H1:H8 , puis en décalant la coloration des lignes 2,4,6 and 8vers la gauche d'une cellule.

Exemple de sortie

Damier


0

Perl 5 - 80

Génère un fichier .PBM:

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

0

PowerShell + GDI, 346 octets

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

(les nouvelles lignes comptent comme les points-virgules, donc les nouvelles lignes pour la lisibilité)

Contrairement à mon autre réponse , celle-ci utilise les assemblys .NET pour appeler GDI + appels de fonction . Fait intéressant, c'est environ le double de la longueur.

Les deux premières lignes chargent le System.Windows.FormsetSystem.Drawing assemblages . Le premier est utilisé pour la fenêtre littérale et le canevas sur celui-ci, le second est utilisé pour l'objet de dessin (dans ce code, un pinceau) qui crée les graphiques sur le canevas.

Nous créons ensuite notre formulaire $favec la ligne suivante et définissons son widthet heightêtre 450. Notez que ce n'est pas50*8 , car ces chiffres correspondent au bord de bordure à bordure de la fenêtre des formulaires, y compris la barre de titre, le bouton de fermeture, etc.

La ligne suivante crée notre canevas $gen appelant le constructeur vide. Par défaut, la partie supérieure gauche de la zone non système du formulaire est égale à0,0 et augmente vers la droite et vers le bas, parfait pour nos besoins.

La ligne suivante est l'appel réel qui dessine les graphiques, avec $f.add_paint({...}). Nous construisons les appels graphiques en double-for en boucle à partir 0..7et en transportant une variable d'assistance à $ytravers chaque boucle externe. A chaque boucle intérieure, nous demandons à notre toile .FillRectangle(...,...)de dessiner nos carrés. Le premier paramètre construit un nouveau SolidBrushavec une couleur basée sur où nous en sommes au tableau. D' autres options ici pourrait être une trappe, un gradient, etc. Le second paramètre est un nouvel Rectangleobjet à partir des x spécifiées $_*50et les $y*50coordonnées et l' extension pour 50chaque direction. N'oubliez pas que 0,0c'est en haut à gauche.

La dernière ligne affiche simplement la sortie avec .showDialog(). Formulaires PowerShell

Notez que puisque nous créons un objet de formulaire et que PowerShell concerne le pipeline, la fermeture du formulaire contextuel passera le long d'un System.Enum.DialogResultobjet de Cancel, car c'est techniquement ce que l'utilisateur a fait. Puisque nous ne capturons pas ou ne faisons rien avec ce résultat, le mot Cancelsera affiché sur STDOUT à la fin du programme, car il a été laissé sur le pipeline.


0

SÉLECTIONNER. , 8844 8278 octets

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

Bien sûr, c'est long, mais les deux premières versions que j'ai générées pour cette tâche étaient deux fois plus longues.

Sortie:

capture d'écran

Comment ça marche:

Voici le programme utilisé pour le générer:

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 d'autres termes, boucle n de 0 à 63, dessinant un carré à (n% 8-4) + (n // 8-4) i si (-1) ^ (n // 8 + n% 8) n'est pas positif.


Ce n'est pas vraiment du golf: p?
Bruno

Je ne peux pas être certain que c'est le programme le plus court qui fait la tâche, non. Cependant, je suis assez certain que la différence entre cela et la meilleure solution possible dans cette langue est insignifiante par rapport à la durée totale du programme. J'ai une autre idée en tête qui peut ou non être plus courte. Je vais l'essayer très bientôt.
quintopie

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 octets

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

cest une ligne de 50 pixels blancs et 50 pixels noirs, 200*cest une ligne avec un blanc à l'avant, 200*c[::-1]l'inverse.

Sortie en PPM, utilisation:

python golf_chess.py > chess.ppm
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.