Afficher tous les carrés blancs ou noirs d'un échiquier

29

introduction

Voici à quoi ressemble un échiquier.

entrez la description de l'image ici

Vous pouvez voir que a1c'est un carré sombre . Cependant, b1c'est un carré clair .

La tâche

Le défi est, étant donné dark, lightou both, sortie tout le noir , la lumière ou tous les carrés avec un séparateur (comme un espace ou un saut de ligne). L'ordre de tous les carrés n'a pas d'importance .

Cas de test

Input: dark
Output: a1 a3 a5 a7 b2 b4 b6 b8 
        c1 c3 c5 c7 d2 d4 d6 d8 
        e1 e3 e5 e7 f2 f4 f6 f8 
        g1 g3 g5 g7 h2 h4 h6 h8

Input: light
Output: a2 a4 a6 a8 b1 b3 b5 b7 
        c2 c4 c6 c8 d1 d3 d5 d7 
        e2 e4 e6 e8 f1 f3 f5 f7 
        g2 g4 g6 g8 h1 h3 h5 h7

Input: both
Output: a1 a2 a3 a4 a5 a6 a7 a8
        b1 b2 b3 b4 b5 b6 b7 b8
        c1 c2 c3 c4 c5 c6 c7 c8
        d1 d2 d3 d4 d5 d6 d7 d8
        e1 e2 e3 e4 e5 e6 e7 e8
        f1 f2 f3 f4 f5 f6 f7 f8
        g1 g2 g3 g4 g5 g6 g7 g8
        h1 h2 h3 h4 h5 h6 h7 h8

Remarque: j'ai amélioré la sortie mais ce n'est pas nécessaire .

C'est du , donc la soumission avec le moins d'octets gagne!

Adnan
la source
Donc, quelque chose comme a2a4a6...ça irait?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Il doit contenir un séparateur, comme un espace ou une nouvelle ligne, ce qui n'est pas valide.
Adnan
Peut-on produire une matrice 2d brute? C'est à dire[[a2,a4,a6,a8],[...]...]
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Oui, c'est autorisé
Adnan
Do light, darket bothdoivent être entrée comme Strings ou peuvent - ils être représentés par tout type de données?
WKS

Réponses:

15

Pyth, 22 21 octets

-1 octet par @ Sp3000

fn%Chz3%sCMT2sM*<G8S8

Sous la fonction %Chz3, darkhache à 1, lightà 0 et bothà 2. Si nous prenons la parité de la somme des ords d'un carré d'échecs (c'est-à-dire a1-> [97, 33]-> (97 + 33)%2=0 , les carrés sombres vont à 0 et la lumière à 1 Cela nous permet de filtrer par inégalité.

fn%Chz3%sCMT2sM*<G8S8      implicit: z=input
               *           Cartesian product of
                <G8          first 8 letters in G (alphabet)
                   S8        with [1,...,8] implicitly stringified
             sM*<G8S8      ['a1','a2,...,'a8','b1'...'h8']
f          T               Filter that by gives truthy result to lambda T:
        sCMT                   The sum of the ords of the chars in T,
       %    2                  modulo 2
 n                            does not equal
   Chz                          ord of the first char in z,
  %   3                         modulo 3
                            Implicitly print the list.

Essayez-le ici .

lirtosiast
la source
21:fn%Chz3%sCMT2sM*<G8S8
Sp3000
@ Sp3000 Merci! Sachant que j'utilisais 6 octets pour l'adapter, j'aurais dû essayer différents hachages.
lirtosiast
13

Utilitaires Bash + GNU, 74

printf %s\\n {a..h}{1..9}|sed -n "`sed '/[db]/a1~2p
/t/a2~2p
c/9/d'<<<$1`"

{a..h}{1..9} est une extension d'accolade bash qui produit toutes les coordonnées d'une carte 8x8, plus une colonne supplémentaire 9 . Ceci est important car cela rend la longueur de ligne impaire, ce qui permet l'effet de damier.

le printf formate simplement chaque coordonnée, une par ligne.

L'expression sed construite supprime ensuite toutes les x9coordonnées, puis imprime les lignes d'entrée paires ou impaires ou les deux, selon l'entrée de script.

Traumatisme numérique
la source
11

JavaScript (SpiderMonkey 30+), 90 85 83 82 octets

x=>[for(d of"12345678")for(c of"abcdefgh")if(x>'l'^parseInt(c+=d,19)%2|x<'d')c]+''

Renvoie une chaîne de carrés séparés par des virgules. Version compatible pour 99 octets:

x=>([..."12345678"].map(d=>[..."abcdefgh"].map(c=>c+d).filter(s=>x>'l'^parseInt(s,19)%2|x<'d')))+''

Fonctionne en énumérant les 64 noms carrés, puis en les analysant dans la base 19 pour voir s'ils sont modulo 2 clair ou foncé.

Neil
la source
Bien. Ceci est ES7
edc65
@ edc65 Ah, je ne me souvenais pas. Je suppose que ma deuxième version est "seulement" ES6.
Neil
Maintenant ES6 bat ES7
edc65
@ edc65 Vous disiez?
Neil
4
@ edc65 Je suppose que nous ne pourrions pas accepter un tirage?
Neil
10

JavaScript (ES6), 82 87 98

Fonction anonyme renvoyant une chaîne de carrés séparés par des espaces.

i=>eval("for(o='',v=190;v<322;)v++%19<8&&i<'d'|v&1^i>'l'?o+=v.toString(19)+' ':o")

TESTER

f=i=>eval("for(o='',v=190;v<322;)v++%19<8&&i<'d'|v&1^i>'l'?o+=v.toString(19)+' ':o")

// less golfed

q=i=>{
  // loop over the range of number a0 (base 19) to h8 (base 19)
  for(o='',v=190;v<322;) 
  {
    if (v++ %19 < 8) // increment and execute the line below only if second digit in 1..8
      if (i<'d'|v&1^i>'l') // even == light, odd == dark, take both if input is 'both'
        o+=v.toString(19)+' '
  }
  return o
}

document.write('<hr>Both<br>'+f('both'))
document.write('<hr>Light<br>'+f('light'))
document.write('<hr>Dark<br>'+f('dark'))

edc65
la source
1
Wow ... c'est juste fou! Je me demande s'il est possible de raccourcir avec ES6 ...
ETHproductions
@ETHproductions oui c'est ça! J'ai un 86 prêt, mais j'essaie toujours de faire quelque chose de mieux (mon - en mouvement - la cible est Neil avec 85 ... pas de foutu 83)
edc65
7

Lot, 192 octets

@set s=a1 a3 a5 a7
@set t=b2 b4 b6 b8
@if not %1==light call:b
@set s=a2 a4 a6 a8
@set t=b1 b3 b5 b7
@if %1==dark exit/b
:b
@echo %s% %s:a=c% %s:a=e% %s:a=g% %t% %t:b=d% %t:b=f% %t:b=h%
Neil
la source
4

Pyth, 48 39 octets

K*<G8S8Jfq%xGhT2%seT2K?qhz\bK?qhz\lJ-KJ

Essayez-le ici!

Encore plus long que l'autre solution Pyth, mais je ne pense pas pouvoir battre cela avec mon algorithme.

Explication

D'abord, nous générons une liste de tous les carrés du tableau et nous l'affectons à Y. Ensuite, nous filtrons cette liste afin qu'il ne reste que des carrés légers et attribuons cette liste à J. Après cela, nous évaluons l'entrée et imprimons:

  • Y si l'entrée était both
  • J si l'entrée était light
  • Y-J si l'entrée était dark

Déterminer si un carré est léger fonctionne comme suit:

  • Mappez le caractère à un nombre compris entre 1 et 8 (a-> 1, b-> 2), indiquez 18for a8, etc.
  • vérifiez si ces deux nombres sont impairs ou pairs ( x%2 == y%2)
  • S'ils le sont, le carré est clair, sinon son sombre

K*<G8S8Jfq%xGhT2%seT2K?qhz\bK?qhz\lJ-KJ  # z=input

 *                                         # Cartesian product of
  <G8                                      # first 8 letters of the alphabet (a-h)
     S8                                    # 1-indexed range (1-8)
K                                          # K holds now all squares
       f             K                     # Filter K 
        q                                  # is equal
         %xGhT2                            # map [a-h] to a number [1-8] and take it modulo 2
               %seT2                       # Take modulo 2 from the row number
                      ?qhz\bK              # If input starts with 'b' print K
                             ?qhz\lJ       # If it starts with 'l' print J
                                    -KJ    # Otherwise print the difference of those 2
Denker
la source
Oh bon sang qui est plus court que le mien par un long shot.
Addison Crump
4

Python 2, 73 71 70 octets

lambda s:[chr(x/8+97)+`x%8+1`for x in range(64)if x+x/8&1^ord(s[0])%3]

Je suis toujours un peu confus si les fonctions sont correctes pour la question, car le défi mentionne un "séparateur", mais comme il y a beaucoup d'autres soumissions de fonctions, j'ai fait la même chose.

Similaire à la réponse d' Erwan mais avec beaucoup plus de Python 2-ness.

(-2 octets grâce à @xnor)

Sp3000
la source
lol, je ne teste même pas entre s=="dark"et s[0]=="d"mais pour ma défense dans mon premier essai, j'ai utilisé s,*_=set 4cmp
Erwan
1
Je pense qu'il devrait y avoir quelque chose de plus court comme ord(s[_])&_ou ord(s[_])/_.
xnor
@xnor En effet, il y a avec %:) Merci!
Sp3000
4

PHP, 132 126 120 108 106 106 octets

for($s=strtr($argv[1],bdl,210);$c<8;$c++)for($r=0;$r<8;)if((++$r+$c)%2==$s||$s>1)echo"abcdefgh"[$c]."$r ";

Il parcourt les colonnes (0-7) et les lignes (1-8) et vérifie si la somme des deux est impaire / paire.

Testé avec PHP 5.6.4, exécutez-le: php -d error_reporting=30709 -r '<CODE>' {dark|light|both}

killerbees19
la source
1
Bienvenue chez PPCG! C'est une bonne réponse, mais vous obtiendrez plus de votes si vous ajoutez une explication.
lirtosiast
Je pense que vous pouvez remplacer $s==2par $s-1. Si $ s = 2 et -1, c'est 1, ce qui est vrai et continuera
Martijn
Et je pense que ça $c=0peut être $c, ça donnera un tas d'avis, mais au moins pour l'obscurité ça marche très bien
Martijn
Merci, Martijn! J'ai aussi oublié de supprimer les accolades, -6 octets pour l'instant. Et je ne sais pas pourquoi, mais $s-1ça ne marche pas, mais ça devrait. Merci pour cette bonne idée! Je déboguerai plus tard.
killerbees19
Je suis nouveau sur ce site, mais des messages d'erreur à cause d'une $cvariable non définie ? Cela semble un peu étrange et invalide. Ou pas?
killerbees19
3

Vitsy , 90 82 octets

'`'8\[1+8\:]Yy1-\?8\['1'v8\[vD1+vr?]vX]i'h'-)[88*\[Z?aO]]i'r'-)[?1m]1m
84*\[Z??aO]

Explication de la première ligne:

'`'8\[1+8\:]Yy1-\?8\['1'v8\[vD1+vr?]vX]i'h'-)[88*\[Z?aO]]i'r'-)[?1m]i'g'-)[1m]
'`'                     Push ` to the stack. (this is 1 less than a in ASCII)
   8\[     ]            Do the stuff in brackets 8 times.
      1+                Add one on every recursion (this gets a, b, c, d...)
        8\:             Clone the stack 8 times. (This gets 8 of each a, b, c...)
Y                       Remove the current stack.
 y1-\?                  Go one stack to the left (I really need to builtin this)
8\[                 ]   Do the stuff in brackets 8 times.
   '1'                  Push character literal 1 to the stack.
      v                 Save it as a temporary variable.
       8\[       ]      Do the stuff in brackets 8 times.
          v             Push the temporary variable to the stack.
           D            Duplicate the top item of the stack.
            1+          Add one to it (this gives us 1, 2, 3, 4...)
              v         Capture the top item of the stack as a temporary variable.
               r        Reverse the stack.
                ?       Go a stack to the right.
                  vX    Clear the temporary variable slot.
i'h')[          ]       If the last character of the input is 'h', do the stuff in brackets
      88*\[    ]        Do the stuff in brackets 64 times.
           Z            Output everything in the stack as a character.
            ?           Rotate right a stack.
             aO         Output a newline.
i'r')[?1m]              If the penultimate character of the input is 'r', rotate over a 
                        stack, then execute the first index of lines of code.
1m                      Execute the first index of lines of code.

Explication de la deuxième ligne:

84*\[Z??aO]
84*\[     ]   Do the stuff in brackets 32 times.
     Z        Output everything in the stack as a char.
      ??      Rotate two stacks over.
        aO    Output a newline.

Il y aura des nouvelles lignes de fin de bonus pour «sombre» et «les deux». Nécessite que seuls «sombre», «les deux» ou «clair» soient entrés.

Essayez-le en ligne!

Addison Crump
la source
3

PowerShell v3 +, 142 129 octets

param($a)$d=$a[0]-in('d','b');$l=$a[0]-in('l','b')
97..104|%{$i=[char]$_;1..8|%{if((($q=($_+$i)%2)-eq$l)-or($q+1-eq$d)){"$i$_"}}}

Prend entrée $a et définit deux variables pour si nous devons produire des carrés d' $darche ou d' $light en fonction de la première lettre de l'entrée.

Ensuite, nous bouclons a-het1-8 et utilise la même astuce que sur déterminer la couleur d'un carré d'échecs pour analyser , que ce soit un carré clair ou sombre (réglage variable d'aide $qdans le premier test) et ajouter cette place au pipeline le cas échéant. Après l'exécution, les éléments du pipeline sont sortis un par ligne.

Nécessite la version 3 ou plus récente pour l' -inopérateur.

Édition - 13 octets enregistrés en éliminant switchet en modifiant l'ordre de test d'égalité

AdmBorkBork
la source
3

Jolf, 48 octets

Ζ-ώ~1tΜ fΜZAQ8ΨΖ+ζ|<%ζγwώt8ώ6d|<i'd!x%H2>i'ldbHγ

Tout est grec pour moi ¯ \ _ (ツ) _ / ¯ Ceci est une transcription de l'excellente réponse d'edc65.

Ζ-ώ~1t
Ζ        set ζ to 
  ώ~1     100 * 2
 -   t    minus 10 (=190)

ΜZAQ8ΨΖ+ζ|<%ζγwώt8+2t
 ZAQ8                 A zero array of length Q8 (8*8 = 64)
Μ    Ψ                map that
      Ζ+ζ             ζ += 
           %ζγwώt       ζ % (γ = 19)
          <      8      < 8
         |        ώ6  || 12

Μ f■above thing■d|<i'd!x%H2>i'ldbHγ
 _f■above thing■d                    filter the above thing
                 |<i'd!x%H2>i'l      removing all the bad stuff (i<'d'|v%2^i>'l')
Μ                              dbHγ  map each character to base 19
Conor O'Brien
la source
3

Perl, 69 + 3 = 72 octets

$b=/b/;$i=/l/;$_="@{[grep{$i=!$i||$b}map{$l=$_;map{$l.$_}1..8}a..h]}"

Pour être exécuté avec perl -p , pour lequel j'ai ajouté 3 octets.

Version moins golfée (légèrement différente, car l'opérateur de la baby-car rend le formatage difficile):

$b=/b/;                       # flag for input containing b
$i=/l/;                       # start $i as true if input contains 'l'

@a = grep {
    $i = !$i||$b                # alternate unless $b is true
} map {
    $l = $_;                    # save letter
    map {
        $l.$_                   # join letter and number
    } 1..8                      # generate number sequence
} a..h;                         # generate letter sequence

# golfed version uses babycart operator around array expr to save one byte
$_ = "@a"                       # write array, separated

La version golfée utilise "@{[]}"; la version commentée utilise @a=...; "@"pour que le code commenté soit toujours exécutable.

David Morris
la source
map$l.$_,1..8-1
choroba
et la même astuce pour grep: grep$i=!$i||$b,mapencore -1
choroba
3

C ++, 132 octets

Prend entrée par ligne de commande. Utilise pointeur / modulo vaudou pour la condition d'impression.

#include<stdio.h>
int main(int i,char**v){for(int n=0;n<64;n++)if((n+(i=n/8))%2-*v[1]%3){putchar(i+97);putchar(n%8+49);putchar(32);}}
MegaTom
la source
Je ne pense pas que la nboucle soit nécessaire. Je pense que imbriqué pour les boucles iet jcouper quelques octets. L' (i+j)%2approche est vraiment intelligente. Je n'y avais pas pensé.
WKS
Je remarque juste que (i//8+i%8)%2c'est la même chose que (i//8+i)%2vous pouvez gagner quelques octets si vous supprimez la définition dej=n%8
Erwan
3

Java, 143

class H{public static void main(String[]a){for(char
c=96;++c<'i';)for(int
i=0;++i<9;)if((i+c)%2!=a[0].charAt(0)%3)System.out.println(c+""+i);}}

Hé, ce n'est pas la réponse la plus longue :)

L'entrée est considérée comme un argument de ligne de commande.

aditsu
la source
3

PHP, 99 82 79 76 74 73 octets

Utilise le codage ISO 8859-1.

for($z=$argv[1];++$x<72;)$x%9&&$z<c|$z>k^$x&1&&print~ß.chr($x/9+97).$x%9;

Courez comme ceci ( -dajouté pour l'esthétique uniquement):

php -d error_reporting=30709 -r 'for($z=$argv[1];++$x<72;)$x%9&&$z<c|$z>k^$x&1&&print~ß.chr($x/9+97).$x%9; echo"\n";' dark

Cela fonctionne comme ceci: la variable $xest incrémentée de 1 à 71, les nombres correspondent aux cellules comme indiqué ci-dessous.

r\c 1  2  3  4  5  6  7  8  [invalid column]
A   1  2  3  4  5  6  7  8  9
B  10 11 12 13 14 15 16 17 18
C  19 20 21 22 23 24 25 26 27
D  28 29 30 31 32 33 34 35 36
E  37 38 39 40 41 42 43 44 45
F  46 47 48 49 50 51 52 53 54
G  55 56 57 58 59 60 61 62 63
H  64 65 66 67 68 69 70 71 72

Par conséquent, $x modulo 9donne le numéro de colonne et $x / 9donne le numéro de ligne, que je convertis en une lettre en utilisant chr. Le code $z<c|$z>k^$x&1donne truepour input both( $z<c) et dans le cas lightou darkuniquement pour les cellules paires ou impaires respectivement ( $z>k ^ $x&1). Le résultat de cette expression détermine si les coordonnées de cellule seront ensuite imprimées. Enfin, si cela $x modulo 9aboutit 0, je saute cette cellule inexistante.

  • Enregistré 18 17 octets (corrigé un bug) en n'ayant qu'une seule boucle, convertissant le nombre en un caractère au lieu de l'inverse
  • Économisé 3 octets en combinant la condition d'obscurité et de lumière avec un xor
  • Enregistré 3 octets en comparant avec l'entrée complète au lieu du premier caractère
  • Enregistré 2 octets car il n'est plus nécessaire de soustraire .125dans l'expression$x/9+69.9 pour obtenir le numéro de ligne correct avant de le convertir en un caractère
  • Enregistrement d'un octet en utilisant pour générer un espace
aross
la source
2

JavaScript ES6, 187 160 159 octets

Je manque probablement quelque chose de douloureusement évident. Tant pis. Ne pas avoir à aplatir le tableau aide.

l=s=>(E=[2,4,6,8],O=[1,3,5,7],h=(z=s[0]=="d")?O:E,d=z?E:O,[...h.map(t=>[..."aceg"].map(e=>e+t)),...(d.map(t=>[..."bdfh"].map(e=>e+t))),...(s[0]=="b"?l`d`:[])])

Renvoie un tableau 2D.


Essayez-le ici:

Conor O'Brien
la source
2

Rubis, 85

Je pense qu'il existe des moyens plus courts à ce sujet, mais c'est une utilisation mignonne de .upto.

gets;'a1'.upto('h8'){|e|puts e if e[/[1-8]/]&&(~/b/||((e.ord%2!=e[1].ord%2)^! ~/l/))}
Pas que Charles
la source
2

R, 129 94 octets

Je savais que je pouvais mieux générer la carte :). Essentiellement, cela construit une carte inversée, filtrant les références de grille où l'ombre ne correspond pas à l'entrée. La sortie est séparée par des espaces.

a=which(array(c('light','dark'),c(9,9))[-9,-9]!=scan(,''),T);cat(paste0(letters[a[,1]],a[,2]))

Non golfé

a=which(                           # Get the indexes of
  array(c('light','dark'),c(9,9))  # an array of light dark
    [-9,-9]                        # except for the ninth row and column
      !=scan(,'')                  # where the value doesn't equal the input
    ,T                             # return array index not vector
  );
cat(paste0(letters[a[,1]],a[,2]))  # using letters for col

Tester

> a=which(array(c('light','dark'),c(9,9))[-9,-9]!=scan(,''),T);cat(paste0(letters[a[,1]],a[,2]))
1: dark
2: 
Read 1 item
a1 c1 e1 g1 b2 d2 f2 h2 a3 c3 e3 g3 b4 d4 f4 h4 a5 c5 e5 g5 b6 d6 f6 h6 a7 c7 e7 g7 b8 d8 f8 h8
> a=which(array(c('light','dark'),c(9,9))[-9,-9]!=scan(,''),T);cat(paste0(letters[a[,1]],a[,2]))
1: light
2: 
Read 1 item
b1 d1 f1 h1 a2 c2 e2 g2 b3 d3 f3 h3 a4 c4 e4 g4 b5 d5 f5 h5 a6 c6 e6 g6 b7 d7 f7 h7 a8 c8 e8 g8
> a=which(array(c('light','dark'),c(9,9))[-9,-9]!=scan(,''),T);cat(paste0(letters[a[,1]],a[,2]))
1: both
2: 
Read 1 item
a1 b1 c1 d1 e1 f1 g1 h1 a2 b2 c2 d2 e2 f2 g2 h2 a3 b3 c3 d3 e3 f3 g3 h3 a4 b4 c4 d4 e4 f4 g4 h4 a5 b5 c5 d5 e5 f5 g5 h5 a6 b6 c6 d6 e6 f6 g6 h6 a7 b7 c7 d7 e7 f7 g7 h7 a8 b8 c8 d8 e8 f8 g8 h8
>
MickyT
la source
2

Oracle SQL 11.2, 192 180 octets

SELECT CHR(64+x),DECODE(y,0,8,y)FROM(SELECT CEIL(LEVEL/8)x,MOD(LEVEL,8)y FROM DUAL CONNECT BY LEVEL<=64)WHERE(:1='dark'AND MOD(x+y,2)=0)OR(:1='light'AND MOD(x+y,2)=1)OR(:1='both');

Non golfé

WITH v AS
(
  SELECT CEIL(LEVEL/8)x, DECODE(MOD(LEVEL,8),0,8,MOD(LEVEL,8))y  
  FROM DUAL CONNECT BY LEVEL<=64
)
SELECT CHR(64+x),y
FROM   v
WHERE  (:1='dark' AND MOD(x+y,2)=0)OR(:1='light' AND MOD(x+y,2)=1)OR(:1='both');

La vue v génère les coordonnées de chaque carré. Si la somme des coordonnées est paire, le carré est noir, sinon il est blanc.

Jeto
la source
2

Rouille, 263 259 244 octets

use std::char;use std::env;fn main(){let n=env::args().nth(1).unwrap();for i in 0..8{for j in 0..8{if n=="both"||(n=="dark"&&(i+j)%2==0)||(n== "light"&&(i+j)%2!=0){println!("{}{}",char::from_u32(i+97).unwrap(),char::from_u32(j+49).unwrap())}}}}

Forme développée:

fn main() {
    let input = env::args().nth(1).unwrap();
    for i in 0..8{
            for j in 0..8{
                if input == "both"
                || (input == "dark" && (i+j)%2==0)
                || (input == "light" && (i+j)%2!=0){
                    println!("{}{}",char::from_u32(i+97).unwrap(),char::from_u32(j+49).unwrap());
            }
        }
    }
}
WKS
la source
1
Plutôt que de coder en dur votre entrée, n'est-il pas possible de la lire depuis le terminal ou la ligne de commande ou comme paramètre de fonction?
Neil
2

MATL , 31 octets

1)t3\8:t!++w4\~?H\]2#f2Y2!w)wVh

Essayez-le en ligne!

Luis Mendo
la source
Celui-ci ne semble pas donner les bons carrés. "sombre" donne x1, x3, x5, x7 pour chaque lettre x, mais cela correspond à 4 colonnes, pas aux carrés noirs.
Esteemator
@Esteemator Désolé, mon erreur. Corrigé
Luis Mendo
2

CJam, 29

qci3%:X;8Ym*{~+2%X-},"a1 "f.+

Juste une solution rapide et sale: p
Essayez-le en ligne

Explication:

q           read the input
ci          convert to (first) character then to integer
3%          modulo 3; results for d(ark), l(ight) and b(oth) are 1, 0, 2
:X;         store in X and pop
8Ym*        generate all pairs (Y=2) of numbers from 0 to 7
{…},        filter using the condition block
  ~         dump the current pair on the stack
  +2%       calculate the sum modulo 2
  X-        subtract X; if the result is not 0, the pair is kept
"a1 "f.+    vectorized-add "a1 " to each remaining pair
             this means the character 'a' is added to the first number,
             the character '1' is added to the second number,
             and then the space character is appended
            the contents of the stack are automatically printed at the end
aditsu
la source
2

Haskell, 133 116 105 100 98 91 octets

f r=[["abcdefgh"!!x,"12345678"!!y]|x<-l,y<-l,odd(x+y)||r<"l",even(x+y)||r!!0/='d']
l=[0..7]

C'est ma première tentative de jouer au golf à Haskell.

Avec l'aide de Michael Klein, nous avons réussi à obtenir moins de 100 caractères!

joeytwiddle
la source
1
Que diriez - vous c>0pour c==1et c<1pour c==0? Enregistre deux octets.
Michael Klein
Fantastique, nous l'avons sous 100! Merci Michael.
joeytwiddle
1
De rien. J'ai été un peu aspiré et je suis descendu à 86 octets en refactorisant un peu:f r=[[[a,b]|a<-['a'..'h'],b<-['1'..'8']]!!i|i<-[0..63],even i||r<"l",odd i||r!!0/='d']
Michael Klein
1
C'est très bien, une approche repensée. Bien que je suis désolé de dire que bizarre et même ine nous donne pas de rayures diagonales. Certains résolvent cela avec i+i`div`8(comme x+y). D' autres commencent par ['1'..'9']et [0..71]puis ne retenir que les i`mod`9<8résultats plus tard, pour 96 octets. Cependant, cet hybride de nos deux approches fait bien à 91 octets:l=[0..7];f r=[["abcdefgh"!!x,"12345678"!!y]|x<-l,y<-l,odd(x+y)||r<"l",even(x+y)||r!!0/='d']
joeytwiddle
Ah, bien c'est encore un peu mieux
Michael Klein
1

Mathematica 133 octets

Méthode 1 : 108 octets. Cela construit le tableau sous forme de tableau, avec des étiquettes dans chaque cellule, et renvoie des diagonales ou des bandes claires ou sombres selon les besoins.

Table[Table[{i,j},{i,{h,g,f,e,d,c,b,a}},{j,Range@8}]~Diagonal~k,{k,If[#=="light",-6,-7],7,If[#=="both",1,2]}]&

%["light"]   (*where % repeats the preceding line *)

{{{b, 1}, {a, 2}}, {{d, 1}, {c, 2}, {b, 3}, {a, 4}}, {{f, 1}, {e , 2}, {d, 3}, {c, 4}, {b, 5}, {a, 6}}, {{h, 1}, {g, 2}, {f, 3}, {e , 4}, {d, 5}, {c, 6}, {b, 7}, {a, 8}}, {{h, 3}, {g, 4}, {f, 5}, {e , 6}, {d, 7}, {c, 8}}, {{h, 5}, {g, 6}, {f, 7}, {e, 8}}, {{h, 7}, {g, 8}}}


Méthode 2 : 133 octets. Crée un tableau et sélectionne en fonction de la nature paire-impaire de la somme du numéro de ligne + numéro de colonne de chaque cellule.

Position[Array[Boole@OddQ[#+#2] &,{8,8}],Switch[#,"dark",0,"light",1,"both",0|1]]/.
{j_,k_}:>{j/.Thread[Range@8->{a,b,c,d,e,f,g,h}],k}&

DavidC
la source
1

JS, 197 octets

b=[];d=[];l=[];for(i=1;i<9;i++){for(j=1;j<9;j++){a=String.fromCharCode(96+i*1)+j;b.push(a);if((i+j)%2<1){d.push(a)}else{l.push(a)}}}m=[0,"both",b,"dark",d,"light",l];alert(m[m.indexOf(prompt())+1])
Nautile
la source
1

Python (3.5), 106 100 96 92 octets

utilisez l'astuce de MegaTom (i+j)%2pour gagner 6 octets

f=lambda s:[chr(97+i//8)+str(1+i%8)for i in range(64)if s[0]=='b'or(i//8+i)%2==(s[0]=='l')]

Essayez-le sur repl.it

Résultats

>>> f('light')
['a2', 'a4', 'a6', 'a8', 'b1', 'b3', 'b5', 'b7', 'c2', 'c4', 'c6', 'c8', 'd1', 'd3', 'd5', 'd7', 'e2', 'e4', 'e6', 'e8', 'f1', 'f3', 'f5', 'f7', 'g2', 'g4', 'g6', 'g8', 'h1', 'h3', 'h5', 'h7']
>>> f('dark')
['a1', 'a3', 'a5', 'a7', 'b2', 'b4', 'b6', 'b8', 'c1', 'c3', 'c5', 'c7', 'd2', 'd4', 'd6', 'd8', 'e1', 'e3', 'e5', 'e7', 'f2', 'f4', 'f6', 'f8', 'g1', 'g3', 'g5', 'g7', 'h2', 'h4', 'h6', 'h8']
>>> f('both')
['a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'd1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8', 'e1', 'e2', 'e3', 'e4', 'e5', 'e6', 'e7', 'e8', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'g1', 'g2', 'g3', 'g4', 'g5', 'g6', 'g7', 'g8', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'h7', 'h8']

La version précédente

f=lambda s:[i for i in[i+j for i in'abcdefgh'for j in'123456780'][s[0]=='l'::2-(s[0]=='b')]if'0'not in i]
Erwan
la source
1

C ++, 119 octets

Basé sur l'astuce de MegaTom.

#include <stdio.h>
int main(int n,char**v){for(n=0;n<64;++n){if((n+n/8)%2-**(v+1)%3){printf("%c%c ",n/8+97,n%8+49);}}}
Johan du Toit
la source
0

C (gcc) , 112 octets

f(char*s){for(int m=*s^'d'?*s^'l'?3:2:1,l=64,x;l--;m&1&!x|(m&2&&x)&&printf("%c%d ",l%8+97,l/8+1))x=l%8%2^l/8%2;}

Essayez-le en ligne!

Si a == 1, alors un carré sera toujours noir si la "bizarrerie" de la ligne et de la colonne est la même, c'est-à-dire que les deux sont impairs ou les deux sont pairs. L'inverse est vrai pour les carrés blancs, où la ligne et la colonne diffèrent toujours en bizarrerie.

Après cela, il suffit de combiner des boucles de lignes et de colonnes, ainsi que de consulter un tableau de priorité des opérateurs jusqu'à ce qu'un niveau d'incompréhensibilité suffisant soit atteint.

gastropner
la source