บทนำ

นี่คือลักษณะของกระดานหมากรุก

คุณจะเห็นว่า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

หมายเหตุ:ผมได้ prettified การส่งออก แต่นี้ไม่จำเป็น

นี่คือโค้ดกอล์ฟดังนั้นการส่งที่มีจำนวนไบต์น้อยที่สุดจะชนะ!

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 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}เป็นการขยายตัวของ bash brace ที่สร้างพิกัดทั้งหมดสำหรับบอร์ด 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]

ฉันยังสับสนอยู่เล็กน้อยว่าฟังก์ชั่นใช้ได้สำหรับคำถามหรือไม่เนื่องจากความท้าทายกล่าวถึง "ตัวคั่น" แต่เนื่องจากมีการส่งฟังก์ชั่นอื่น ๆ อีกมากมายที่ฉันได้ทำเช่นเดียวกัน

คล้ายกับคำตอบ Erwan ของแต่มีจำนวนมากขึ้นอีกนิดงูหลาม 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 ";

มันวนลูปผ่าน cols (0-7) และแถว (1-8) และตรวจสอบว่าผลรวมของทั้งคู่เป็นเลขคี่ / คู่

ทดสอบกับ PHP 5.6.4 แล้วเรียกใช้: php -d error_reporting=30709 -r '<CODE>' {dark|light|both}

Vitsy , 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และตั้งค่าตัวแปรสองตัวหากเราจะส่งออก$dark หรือ$light squares ตามตัวอักษรตัวแรกของอินพุต

จากนั้นห่วงเรามากกว่าa-hและ1-8และใช้เคล็ดลับเช่นเดียวกับในกำหนดสีของตารางหมากรุกที่จะแยกไม่ว่าจะเป็น (ตัวแปรผู้ช่วยการตั้งค่าแสงหรือมืดตาราง$qในการทดสอบครั้งแรก) และเพิ่มตารางที่ท่อถ้าเหมาะสม หลังจากการดำเนินการองค์ประกอบในไปป์ไลน์จะถูกส่งออกหนึ่งรายการต่อบรรทัด

ต้องการ v3 หรือใหม่กว่าสำหรับ -inผู้ปฏิบัติงาน

_{แก้ไข - บันทึกไว้ 13 ไบต์โดยการกำจัดswitchและโดยการเปลี่ยนลำดับการทดสอบความเท่าเทียมกัน}

Jolf, 48 ไบต์

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

มันคือกรีกทั้งหมดสำหรับฉัน¯ \ _ (ツ) _ / ¯นี่คือ transpiling ของคำตอบที่ยอดเยี่ยมของ 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

รุ่น golfed ใช้"@{[]}"; เวอร์ชันที่มีการแสดงความคิดเห็นใช้@a=...; "@"เพื่อให้รหัสความคิดเห็นยังคงสามารถเรียกใช้งานได้

C ++, 132 ไบต์

รับอินพุตตามบรรทัดรับคำสั่ง ใช้ตัวชี้ / โมดูโล voodoo สำหรับเงื่อนไขการพิมพ์

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

เฮ้มันไม่ใช่คำตอบที่ยาวที่สุด :)

อินพุตถูกใช้เป็นอาร์กิวเมนต์บรรทัดคำสั่ง

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

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

ทดสอบ

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

นี่เป็นความพยายามครั้งแรกของฉันในการเล่นกอล์ฟ Haskell

ด้วยความช่วยเหลือจาก Michael Klein เราสามารถจัดการให้อยู่ภายใต้ 100 chars!

Mathematica 133 bytes

วิธีที่ 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])

Python (3.5), 106 100 96 92 bytes

use the trick of MegaTom (i+j)%2 to win 6 bytes

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

Try it on repl.it

Results

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

Previous 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

Based on MegaTom's 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;}

Try it online!

If a == 1, then a square will always be black if the "oddness" of row and column is the same, i.e. both are odd or both are even. The opposite is true for white squares, where row and column will always differ in oddness.

After that, it's just a matter of combining row and column loops, as well as consulting a table of operator precedence until a sufficient level of incomprehensibility has been reached.