Вступ

Так виглядає шахова дошка.

Ви можете бачити, що a1це темний квадрат. Однак b1є світлий квадрат .

Завдання

Завдання полягає, враховуючи dark, lightабо both, вихід все темні , світло або всі квадрати з сепаратором (наприклад , пропуск або перекладом рядка). Порядок всіх квадратів значення не має .

Тестові справи

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

Примітка: я попередньо уточнив вихід, але це не обов'язково .

Це код-гольф , тому подання з найменшою кількістю байтів виграє!

Pyth, 22 21 байт

-1 байт від @ Sp3000

fn%Chz3%sCMT2sM*<G8S8

Під функцією %Chz3, darkхеші до 1, light0 і both2. Якщо ми візьмемо співвідношення суми ords шахової площі (тобто, a1-> [97, 33]-> (97 + 33)%2= 0, темні квадрати йдуть в 0, і світло на 1 . Це дозволяє нам фільтрувати по нерівності.

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.

Спробуйте тут .

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}є розширення дужки Баша , який виробляє всі координати для 8x8 плати, плюс додатковий стовпець 9. Це важливо, тому що це робить довжину рядка непарною, що дозволяє зробити ефект шахівниці.

printfПросто формати кожної координаті, по одному в кожному рядку.

Потім вбудований вираз sed видаляє всі x9координати, а потім друкує парні або непарні або обидві лінії введення, відповідно до вводу сценарію.

JavaScript (SpiderMonkey 30+), 90 85 83 82 байт

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

Повертає розділений комою рядок квадратів. Сумісна версія на 99 байт:

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

Працює, перелічуючи всі 64 назви квадратів, потім аналізуючи їх у базовій частині 19, щоб побачити, чи світлий або темний модуль 2.

JavaScript (ES6), 82 87 98

Анонімна функція, що повертає пробіл, розділений пробілом.

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

ТЕСТ

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

Пакетна, 192 байти

@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 байт

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

Спробуйте тут!

Ще довше, ніж інші рішення Pyth, але я не думаю, що я можу це перемогти за допомогою свого алгоритму.

Пояснення

Спочатку ми формуємо список усіх квадратів на дошці і присвоюємо йому Y. Потім ми фільтруємо цей список, щоб залишилися лише світлі квадрати, і присвоюємо цьому списку J. Після цього ми оцінюємо введення та друк:

• Y якщо введення було both
• J якщо введення було light
• Y-J якщо вхід був dark

Визначення світла квадрата працює таким чином:

• Зіставте діаграму на число від 1-8 (a-> 1, b-> 2), результати 18для a8тощо.
• перевірте, чи обидва ці числа непарні або парні ( x%2 == y%2)
• Якщо вони є, квадрат світлий, інакше його темний

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 байт

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

Я все ще трохи розгублений, чи добре функцій щодо питання, оскільки виклик згадує про "роздільник", але оскільки є багато інших подань функцій, я зробив те саме.

Подібний до відповіді Ервана, але з набагато більшою кількістю Python 2-ness.

(-2 байти завдяки @xnor)

PHP, 132 126 120 108 106 байт

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

Він проходить через проміжки (0-7) та рядки (1-8) і перевіряє, чи сума обох непарна / парна.

Перевірено з PHP 5.6.4, запустіть його: php -d error_reporting=30709 -r '<CODE>' {dark|light|both}

Віци , 90 82 байти

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

Пояснення першого рядка:

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

Пояснення другого рядка:

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.

Будуть нові бонусні рядки для "темних" та "обох". Потрібно, щоб були введені лише "темні", "обидва" або "світлі".

Спробуйте в Інтернеті!

PowerShell v3 +, 142 129 байт

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

Бере введення $aі встановлює дві змінні для того, якщо ми виводимо $dковчег або $lпрямі квадратів на основі першої літери введення.

Потім ми перебираємо a-hі 1-8і використовує той же трюк , як на Визначають колір шахової площі , щоб розібрати , чи є це світлий або темний квадрат (установка змінної хелперів $qв першому тесті) і додати , що квадрат в разі необхідності трубопроводу. Після виконання елементи на трубопроводі виводяться по одному на лінію.

Потрібна версія v3 або новіша для -inоператора.

_{Редагувати - збережено 13 байтів, усунувши switchі змінивши порядок тестування рівності}

Джолф, 48 байт

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

Для мене це все грецько ¯ \ _ (ツ) _ / ¯ Це переклад відмінної відповіді 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

Perl, 69 + 3 = 72 байти

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

Для запуску perl -p, для чого я додав 3 байти.

Версія з меншим розміром для гольфу (дещо інша, оскільки оператор babycart утрудняє гарне форматування):

$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

Використовується версія для гольфу "@{[]}"; коментована версія використовує @a=...; "@"так, що коментований код все ще можна виконати.

C ++, 132 байти

Вводить командний рядок. Використовує вказівник / модульний вуду для умови друку.

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

Ява, 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);}}

Гей, це не найдовша відповідь :)

Введення приймається як аргумент командного рядка.

PHP, 99 82 79 76 74 73 байт

Використовує кодування ISO 8859-1.

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

Виконати так ( -dдодано лише для естетики):

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

Це працює так: змінна $xзбільшується від 1 до 71, числа відповідають осередкам, як показано нижче.

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

Тому $x modulo 9дає номер стовпця і $x / 9дає номер рядка, який я перетворюю на букву, використовуючи chr. Код $z<c|$z>k^$x&1видається trueдля введення both( $z<c) та у випадку lightабо darkлише для парних чи непарних комірок відповідно ( $z>k ^ $x&1). Результат цього виразу визначає, друкуватимуться чи ні координати комірок. Нарешті, якщо це $x modulo 9призводить до того 0, я пропускаю цю неіснуючу клітинку.

• Збережено 18 17 байт (виправлено помилку), маючи лише 1 цикл, перетворивши число на знак, а не навпаки
• Збережено 3 байти, поєднавши умову темного та світлого з а xor
• Збережено 3 байти порівнянням з повним введенням замість першого знака
• Збережено 2 байти, тому що більше не потрібно віднімати .125у виразі, $x/9+69.9щоб отримати правильний номер рядка перед перетворенням у таблицю
• Збережено байт за допомогою ~ßпробілу

JavaScript ES6, 187 160 159 байт

Я, мабуть, пропускаю щось болісно очевидне. Ну добре. Не потребує вирівнювання масиву допомагає.

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

Повертає 2D масив.

Спробуйте тут:

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>

Рубі, 85

Я думаю, що існують коротші способи цього, але це дуже мило .upto.

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

R, 129 94 байт

Я знав, що можу краще генерувати дошку :). По суті, це будує перевернуту дошку, фільтруючи посилання на сітку там, де відтінок не відповідає вхідному. Вихід розділений пробілом.

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

Безумовно

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

Тест

> 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 байт

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

Без гольфу

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

V вигляд генерує координати кожного квадрата. Якщо сума координат рівна, то квадрат чорний, інакше білий.

Іржа, 263 259 244 байт

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

Розгорнута форма:

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 байт

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

Спробуйте в Інтернеті!

CJam, 29

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

Просто швидке та брудне рішення: p
Спробуйте це в Інтернеті

Пояснення:

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 байт

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

Це моя перша спроба в гольф Хаскелл.

За деякої допомоги Майкла Кляйна нам вдалося отримати його за 100 символів!

Математика 133 байт

Спосіб 1 : 108 байт. Це створює дошку як таблицю, з мітками в кожній комірці і повертає світлі або темні діагоналі або смуги, як потрібно.

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

Спосіб 2 : 133 байти. Створює масив і вибирає за парним характером суму номера рядка + номер стовпця кожної комірки.

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 байт

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

Пітон (3,5), 106 100 96 92 байт

використовуйте трюк MegaTom, (i+j)%2щоб виграти 6 байт

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

Спробуйте це на repl.it

Результати

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

Попередня версія

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 байт

На основі хитрості 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);}}}

C (gcc) , 112 байт

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

Спробуйте в Інтернеті!

Якщо a == 1, то квадрат завжди буде чорним, якщо "непарність" рядка та стовпця однакова, тобто обидва непарні або обидва парні. Протилежне до білих квадратів, де рядки та стовпці завжди будуть відрізнятися непарністю.

Після цього, лише питання поєднання циклів рядків і стовпців, а також консультація з таблицею пріоритетності оператора до досягнення достатнього рівня незрозумілості.