Giới thiệu

Đây là cách một bàn cờ trông như thế nào.

Bạn có thể thấy đó a1là một hình vuông tối . Tuy nhiên, b1là một hình vuông ánh sáng .

Nhiệm vụ

Thách thức là, đưa ra dark, lighthoặc both, xuất ra tất cả các ô vuông tối , sáng hoặc tất cả các hình vuông có dấu phân cách (như khoảng trắng hoặc dòng mới). Thứ tự của tất cả các hình vuông không quan trọng .

Các trường hợp thử nghiệm

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

Lưu ý: Tôi đã chỉnh sửa đầu ra nhưng điều này là không cần thiết .

Đây là môn đánh gôn , vì vậy bài nộp có số byte ít nhất sẽ thắng!

Pyth, 22 21 byte

-1 byte bởi @ Sp3000

fn%Chz3%sCMT2sM*<G8S8

Theo hàm %Chz3, darkbăm đến 1,light 0, và both2. Nếu chúng ta lấy tính chẵn lẻ của tổng số quỹ đạo của hình vuông cờ vua (nghĩa là a1-> [97, 33]-> (97 + 33)%2= 0, hình vuông tối sẽ về 0 và sáng thành 1 Điều này cho phép chúng ta lọc theo bất bình đẳng.

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.

Thử nó ở đây .

Tiện ích 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}là một bản mở rộng bash brace tạo ra tất cả các tọa độ cho một bảng 8x8, cộng với một cột phụ 9. Điều này rất quan trọng vì nó làm cho chiều dài hàng lẻ cho phép hiệu ứng bảng điều khiển.

Các printf định dạng đơn giản mỗi tọa độ, một trên mỗi dòng.

Biểu thức sed được xây dựng sau đó xóa tất cả các x9tọa độ và sau đó in chẵn hoặc lẻ hoặc cả hai dòng đầu vào, theo đầu vào tập lệnh.

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

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

Trả về một chuỗi các ô vuông được phân tách bằng dấu phẩy. Phiên bản tương thích cho 99 byte:

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

Hoạt động bằng cách liệt kê tất cả 64 tên vuông, sau đó phân tích chúng trong cơ sở 19 để xem chúng là modulo 2 sáng hay tối.

JavaScript (ES6), 82 87 98

Hàm ẩn danh trả về một chuỗi các ô vuông được phân tách bằng dấu cách.

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

KIỂM TRA

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

Mẻ, 192 byte

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

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

Hãy thử nó ở đây!

Vẫn dài hơn giải pháp Pyth khác, nhưng tôi không nghĩ mình có thể đánh bại điều này bằng thuật toán của mình.

Giải trình

Đầu tiên chúng ta tạo một danh sách tất cả các ô vuông trên bảng và gán nó vào Y. Sau đó, chúng tôi lọc danh sách này để chỉ còn lại các ô vuông sáng và gán danh sách này J. Sau đó, chúng tôi đánh giá đầu vào và in:

• Y nếu đầu vào là both
• J nếu đầu vào là light
• Y-J nếu đầu vào là dark

Xác định nếu một hình vuông là ánh sáng hoạt động như sau:

• Bản đồ các char để một số 1-8 (a-> 1, b> 2), kết quả trong 18choa8 , v.v.
• kiểm tra xem cả hai số đó là số lẻ hay số chẵn (x%2 == y%2 )
• Nếu có, hình vuông là ánh sáng, nếu không thì tối

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 byte

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

Tôi vẫn hơi bối rối liệu các chức năng có ổn cho câu hỏi hay không, vì thử thách đề cập đến "dải phân cách", nhưng vì có rất nhiều bài nộp chức năng khác mà tôi đã làm tương tự.

Tương tự như câu trả lời của Erwan nhưng với một lô cắn hơn Python 2-Ness.

(-2 byte nhờ @xnor)

PHP, 132 126 120 108 106 byte

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

Nó lặp qua các cols (0-7) và hàng (1-8) và kiểm tra xem tổng của cả hai là số lẻ / chẵn.

Đã thử nghiệm với PHP 5.6.4, chạy nó: php -d error_reporting=30709 -r '<CODE>' {dark|light|both}

Vitsy , 90 82 byte

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

Giải thích về dòng đầu tiên:

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

Giải thích về dòng thứ hai:

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.

Sẽ có các dòng mới theo dõi phần thưởng cho 'tối' và 'cả hai'. Yêu cầu chỉ có 'tối', 'cả' hoặc 'sáng' sẽ được nhập.

Hãy thử trực tuyến!

PowerShell v3 +, 142 129 byte

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

Lấy đầu vào $avà đặt hai biến nếu chúng ta xuất ra $dhòm hoặc$l ô vuông ight dựa trên chữ cái đầu tiên của đầu vào.

Sau đó, chúng tôi lặp lại a-hvà 1-8sử dụng cùng một mẹo như trên Xác định màu sắc của hình vuông cờ để phân tích xem đó là hình vuông sáng hay tối (đặt biến trợ giúp$q trong thử nghiệm đầu tiên) và thêm hình vuông đó vào đường ống nếu thích hợp. Sau khi thực hiện, các phần tử trên đường ống là đầu ra trên mỗi dòng.

Yêu cầu v3 hoặc mới hơn cho -intoán tử.

_{Chỉnh sửa - Đã lưu 13 byte bằng cách loại bỏ switchvà bằng cách thay đổi thứ tự kiểm tra đẳng thức}

Jolf, 48 byte

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

Đó là tất cả tiếng Hy Lạp đối với tôi \ _ () _ / Đây là bản dịch của câu trả lời xuất sắc của 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 byte

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

Để được chạy với perl -p, tôi đã thêm 3 byte.

Phiên bản ít chơi gôn hơn (hơi khác biệt, vì nhà điều hành babycart khiến việc định dạng độc đáo trở nên khó khăn):

$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

Các phiên bản golf sử dụng "@{[]}"; phiên bản nhận xét sử dụng @a=...; "@"để mã nhận xét vẫn có thể chạy được.

C ++, 132 byte

Đưa đầu vào bằng dòng lệnh. Sử dụng con trỏ / modulo voodoo cho điều kiện in.

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

Này, đó không phải là câu trả lời dài nhất :)

Đầu vào được lấy làm đối số dòng lệnh.

PHP, 99 82 79 76 74 73 byte

Sử dụng mã hóa ISO 8859-1.

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

Chạy như thế này (chỉ -dthêm tính thẩm mỹ):

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

Nó hoạt động như thế này: biến $xđược tăng từ 1 đến 71, các số tương ứng với các ô như hình bên dưới.

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

Do đó, $x modulo 9mang lại số cột và $x / 9mang lại số hàng mà tôi chuyển đổi thành một chữ cái bằng cách sử dụng chr. Mã $z<c|$z>k^$x&1mang lại truecho đầu vào both( $z<c) và trong trường hợp lighthoặc darkchỉ cho các ô chẵn hoặc lẻ tương ứng ( $z>k ^ $x&1). Kết quả của biểu thức này xác định liệu tọa độ ô có được in hay không. Cuối cùng, nếu $x modulo 9kết quả 0, tôi bỏ qua ô không tồn tại đó.

• Đã lưu 18 17 byte (đã sửa lỗi) bằng cách chỉ có 1 vòng lặp, chuyển đổi số thành char thay vì cách khác
• Đã lưu 3 byte bằng cách kết hợp điều kiện tối và sáng với xor
• Đã lưu 3 byte bằng cách so sánh với đầu vào đầy đủ thay vì char đầu tiên
• Đã lưu 2 byte vì không còn cần phải trừ .125trong biểu thức$x/9+69.9 để có được số hàng chính xác trước khi chuyển đổi thành char
• Đã lưu một byte bằng cách sử dụng ~ßđể tạo khoảng trống

JavaScript ES6, 187 160 159 byte

Có lẽ tôi đang thiếu một cái gì đó rất rõ ràng. Ồ tốt Không phải làm phẳng các mảng giúp.

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

Trả về một mảng 2D.

Hãy thử nó ở đây:

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>

Hồng ngọc, 85

Tôi nghĩ rằng có những cách ngắn hơn về điều này, nhưng đây là một cách sử dụng dễ thương .upto.

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

R, 129 94 byte

Tôi biết tôi có thể tạo ra bảng tốt hơn :). Về cơ bản, điều này xây dựng một bảng đảo ngược, lọc ra các tham chiếu lưới trong đó bóng râm không khớp với đầu vào. Đầu ra là không gian ngăn cách.

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

Bị đánh cắp

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

Kiểm tra

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

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

Không chơi gôn

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

Khung nhìn v tạo tọa độ của mỗi hình vuông. Nếu tổng tọa độ là chẵn thì hình vuông có màu đen, nếu không thì nó có màu trắng.

Rust, 263 259 244 byte

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

Hình thức mở rộng:

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 byte

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

Hãy thử trực tuyến!

CJam, 29

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

Chỉ là một giải pháp nhanh chóng và bẩn thỉu: p
Hãy thử trực tuyến

Giải trình:

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 byte

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

Đây là nỗ lực đầu tiên của tôi khi chơi golf Haskell.

Với sự giúp đỡ của Michael Klein, chúng tôi đã có được dưới 100 ký tự!

Toán học 133 byte

Phương pháp 1 : 108 byte. Điều này xây dựng bảng như một bảng, với các nhãn trong mỗi ô và trả về các đường chéo hoặc dải sáng hoặc tối theo yêu cầu.

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

Phương pháp 2 : 133 byte. Tạo một mảng và chọn theo tính chất chẵn của tổng của số hàng + số cột của mỗi ô.

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 byte

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

Con trăn (3.5), 106 100 96 92 byte

sử dụng thủ thuật của MegaTom (i+j)%2để giành được 6 byte

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

Hãy thử nó trên repl.it

Các kết quả

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

Phiên bản trước

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 byte

Dựa trên thủ thuật của 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 byte

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

Hãy thử trực tuyến!

Nếu a == 1, thì hình vuông sẽ luôn có màu đen nếu "độ lẻ" của hàng và cột là như nhau, tức là cả hai đều lẻ hoặc cả hai đều chẵn. Điều ngược lại là đúng với hình vuông màu trắng, trong đó hàng và cột sẽ luôn khác nhau về độ lẻ.

Sau đó, đó chỉ là vấn đề kết hợp các vòng lặp hàng và cột, cũng như tham khảo bảng ưu tiên của nhà điều hành cho đến khi đạt được mức độ khó hiểu đủ.