Einführung

So sieht ein Schachbrett aus.

Sie können sehen, dass dies a1ein dunkles Quadrat ist. Ist b1jedoch ein helles Quadrat .

Die Aufgabe

Die Herausforderung ist, gegeben dark, lightoder der bothAusgang all dunkel , Licht oder alle Quadrate mit einem Separator (wie ein Leerzeichen oder einer neuen Zeile). Die Reihenfolge aller Quadrate spielt keine Rolle .

Testfälle

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

Hinweis: Ich habe die Ausgabe hübsch gemacht, dies ist jedoch nicht erforderlich .

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Pyth, 22 21 Bytes

-1 Byte von @ Sp3000

fn%Chz3%sCMT2sM*<G8S8

Unter der Funktion %Chz3, darkHashes bis 1, light0 und bothbis 2. Wenn wir die Parität der Summe der ords eines Schach Platz nehmen (das heißt, a1-> [97, 33]-> (97 + 33)%2= 0, dunkle Felder gehen auf 0 und Licht auf 1 Dies ermöglicht es uns, nach Ungleichungen zu filtern.

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.

Probieren Sie es hier aus .

Bash + GNU Utilities, 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}ist eine Bash-Klammer-Erweiterung, die alle Koordinaten für ein 8x8-Board sowie eine zusätzliche Spalte erzeugt 9. Dies ist wichtig, da dadurch die Zeilenlänge ungerade wird, was den Schachbretteffekt ermöglicht.

Das printfformatiert einfach jede Koordinate, eine pro Zeile.

Der erstellte sed-Ausdruck löscht dann alle x9Koordinaten und druckt je nach Skripteingabe entweder gerade oder ungerade oder beide Eingabezeilen.

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

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

Gibt eine durch Kommas getrennte Zeichenfolge von Quadraten zurück. Kompatible Version für 99 Bytes:

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

Zählen Sie alle 64 quadratischen Namen auf und analysieren Sie sie in Basis 19, um festzustellen, ob es sich um helle oder dunkle Modulo 2 handelt.

JavaScript (ES6), 82 87 98

Anonyme Funktion, die eine durch Leerzeichen getrennte Zeichenfolge von Quadraten zurückgibt.

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

PRÜFUNG

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

Batch, 192 Bytes

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

Pyth, 48 39 Bytes

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

Probieren Sie es hier aus!

Immer noch länger als die andere Pyth-Lösung, aber ich glaube nicht, dass ich das mit meinem Algorithmus übertreffen kann.

Erläuterung

Zuerst generieren wir eine Liste aller Felder auf der Tafel und weisen sie zu Y. Dann filtern wir diese Liste so, dass nur noch helle Quadrate übrig bleiben und weisen diese Liste zu J. Danach werten wir die Eingabe aus und drucken:

• Y wenn Eingabe war both
• J wenn Eingabe war light
• Y-J wenn die Eingabe war dark

Das Bestimmen, ob ein Quadrat hell ist, funktioniert wie folgt:

• Ordnen Sie das Zeichen einer Zahl von 1-8 zu (a-> 1, b-> 2), ergibt 18für a8usw.
• überprüfe ob beide Zahlen gerade oder ungerade sind ( x%2 == y%2)
• Wenn dies der Fall ist, ist das Quadrat hell, ansonsten ist es dunkel

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

Python 2, 73 71 70 Bytes

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

Ich bin immer noch ein bisschen verwirrt, ob Funktionen für die Frage in Ordnung sind, da in der Challenge ein "Separator" erwähnt wird, aber da es viele andere Funktionsübermittlungen gibt, habe ich dasselbe getan.

Ähnlich wie Erwans Antwort, aber mit viel mehr Python 2-ness.

(-2 Bytes dank @xnor)

PHP, 132 126 120 108 106 Bytes

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

Es durchläuft die Spalten (0-7) und Zeilen (1-8) und prüft, ob die Summe von beiden gerade / ungerade ist.

Getestet mit PHP 5.6.4, führen Sie es aus: php -d error_reporting=30709 -r '<CODE>' {dark|light|both}

Vitsy , 90 82 Bytes

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

Erklärung der ersten Zeile:

'`'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.

Erklärung der zweiten Zeile:

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.

Es wird Bonus-Zeilenumbrüche für 'dunkel' und 'beides' geben. Erfordert, dass nur "dunkel", "beide" oder "hell" eingegeben werden.

Probieren Sie es online!

PowerShell v3 +, 142 129 Bytes

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$_"}}}

Übernimmt die Eingabe $aund setzt zwei Variablen für die Ausgabe von Ark- $doder $lAchtquadraten basierend auf dem ersten Buchstaben der Eingabe.

Dann durchlaufen wir a-hund 1-8und verwenden denselben Trick wie bei. Bestimmen Sie die Farbe eines Schachfelds, um zu analysieren, ob es sich um ein helles oder dunkles Feld handelt (Hilfsvariable $qim ersten Test festlegen), und fügen Sie dieses Feld gegebenenfalls zur Pipeline hinzu. Nach der Ausführung werden die Elemente in der Pipeline einzeln pro Zeile ausgegeben.

Benötigt v3 oder neuer für den -inBetreiber.

_{Bearbeiten - Speichert 13 Bytes, indem die switchund die Reihenfolge der Gleichheitsprüfungen geändert werden}

Jolf, 48 Bytes

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

Für mich ist alles Griechisch ¯ \ _ (ツ) _ / ¯ Dies ist eine Übersetzung von edc65's exzellenter Antwort.

Ζ-ώ~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

Perl, 69 + 3 = 72 Bytes

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

Zu laufen mit perl -p, für das ich 3 Bytes addiert habe.

Weniger Golf-Version (etwas anders, da der Babycart-Betreiber das Formatieren schwierig macht):

$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

Die Golfversion verwendet "@{[]}"; In der kommentierten Version wird verwendet @a=...; "@", dass der kommentierte Code weiterhin ausgeführt werden kann.

C ++, 132 Bytes

Übernimmt die Eingabe über die Befehlszeile. Verwendet Pointer / Modulo Voodoo als Druckbedingung.

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

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

Hey, das ist nicht die längste Antwort :)

Die Eingabe wird als Befehlszeilenargument verwendet.

PHP, 99 82 79 76 74 73 Bytes

Verwendet ISO 8859-1-Codierung.

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

Laufen Sie wie folgt ( -dnur aus ästhetischen Gründen hinzugefügt):

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

Das funktioniert so: Die Variable $xwird von 1 auf 71 erhöht, die Zahlen entsprechen den Zellen wie unten gezeigt.

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

Daher $x modulo 9ergibt sich die Spaltennummer und $x / 9liefert die Zeilennummer, die ich in einem Brief konvertieren Verwendung chr. Der Code $z<c|$z>k^$x&1ergibt truefür input both( $z<c) und bei lightoder darknur für die geraden bzw. ungeraden Zellen ( $z>k ^ $x&1). Das Ergebnis dieses Ausdrucks bestimmt, ob die Zellenkoordinaten dann gedruckt werden. Wenn sich schließlich $x modulo 9ergibt 0, überspringe ich diese nicht vorhandene Zelle.

• Es wurden 18 bis 17 Bytes (ein Fehler wurde behoben) eingespart, indem nur eine Schleife vorhanden war, wobei die Zahl in ein Zeichen umgewandelt wurde, anstatt umgekehrt
• 3 Bytes gespart durch Kombination der Bedingung für Dunkel und Hell mit a xor
• Spart 3 Bytes durch Vergleich mit der vollständigen Eingabe anstelle des ersten Zeichens
• 2 Byte gespart, da .125der Ausdruck nicht mehr subtrahiert werden muss $x/9+69.9, um die richtige Zeilennummer zu erhalten, bevor er in ein Zeichen konvertiert wird
• Ein Byte mit gespeichert ~ß, um ein Leerzeichen zu ergeben

JavaScript ES6, 187 160 159 Bytes

Mir fehlt wahrscheinlich etwas schmerzlich Offensichtliches. Naja. Es hilft, wenn Sie das Array nicht reduzieren müssen.

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`:[])])

Gibt ein 2D-Array zurück.

Probieren Sie es hier aus:

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`:[])])

U=x=>o.innerHTML=JSON.stringify(l(i.value));
i.onchange=U;U();

*{font-family:Consolas,monospace;}

<select id=i><option value="light">light</option><option value="dark">dark</option><option value="both">both</option></select><div id=o></div>

Rubin, 85

Ich denke, es gibt kürzere Wege, aber das ist eine nette Verwendung von .upto.

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

R 129 94 Bytes

Ich wusste ich könnte das Board besser generieren :). Im Wesentlichen wird so eine invertierte Karte erstellt, bei der Gitterreferenzen herausgefiltert werden, bei denen der Schatten nicht mit der Eingabe übereinstimmt. Die Ausgabe ist durch Leerzeichen getrennt.

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

Ungolfed

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

Prüfung

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

Oracle SQL 11.2, 192 180 Bytes

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

Nicht golfen

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

Die v-Ansicht generiert die Koordinaten jedes Quadrats. Wenn die Summe der Koordinaten gerade ist, ist das Quadrat schwarz, sonst ist es weiß.

Rust, 263 259 244 Bytes

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

Erweiterte Form:

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

MATL , 31 Bytes

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

Probieren Sie es online!

CJam, 29

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

Nur eine schnelle und schmutzige Lösung: p
Probieren Sie es online aus

Erläuterung:

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

Haskell, 133 116 105 100 98 91 Bytes

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

Dies ist mein erster Versuch, Haskell Golf zu spielen.

Mit etwas Hilfe von Michael Klein haben wir es geschafft, es unter 100 Zeichen zu bekommen!

Mathematica 133 Bytes

Methode 1 : 108 Bytes. Dadurch wird die Karte als Tabelle mit Beschriftungen in jeder Zelle erstellt und je nach Bedarf werden helle oder dunkle Diagonalen oder Bänder zurückgegeben.

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

Methode 2 : 133 Bytes. Erstellt ein Array und wählt entsprechend der geraden und ungeraden Summe aus Zeilennummer und Spaltennummer jeder Zelle aus.

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

JS, 197 Bytes

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

Python (3.5), 106 100 96 92 Bytes

Verwenden Sie den Trick von MegaTom (i+j)%2, um 6 Bytes zu gewinnen

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

Probieren Sie es auf repl.it

Ergebnisse

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

Vorherige Version

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]

C ++, 119 Bytes

Basierend auf MegaToms Trick.

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

C (gcc) , 112 Bytes

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

Probieren Sie es online!

Wenn a == 1 ist, ist ein Quadrat immer schwarz, wenn die "Ungerade" von Zeile und Spalte gleich ist, dh beide sind ungerade oder beide sind gerade. Das Gegenteil ist bei weißen Quadraten der Fall, bei denen sich Zeile und Spalte immer in ihrer Seltsamkeit unterscheiden.

Danach müssen nur noch Zeilen- und Spaltenschleifen kombiniert und eine Tabelle mit der Rangfolge der Operatoren herangezogen werden, bis ein ausreichendes Maß an Unverständlichkeit erreicht ist.