소개

체스 판 모양입니다.

당신은 볼 수 a1A는 어두운 광장. 그러나 b1A는 빛 광장 .

작업

문제는, 주어진 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

참고 : 출력을 미리 확인했지만 이것이 필요하지 않습니다 .

이것은 code-golf 이므로 바이트 수가 가장 적은 제출이 승리합니다!

Pyth, 22 21 바이트

@ Sp3000에 의해 -1 바이트

fn%Chz3%sCMT2sM*<G8S8

기능에서 %Chz3, dark1 해시, light0, 그리고 both2. 우리는 체스 광장의 ords의 합 (즉, 패리티 걸릴 경우 a1-> [97, 33]> - (97 + 33)%2= 01, 어두운 사각형이 0로 이동하여 빛을 이를 통해 불평등으로 필터링 할 수 있습니다.

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.

여기에서 시도 하십시오 .

배쉬 + 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 보드에 대한 모든 좌표와 추가 열을 생성하는 bash 괄호 확장입니다 9. 이것은 체커 보드 효과를 허용하는 행 길이를 홀수로 만들기 때문에 중요합니다.

그만큼 printf단순히 각각 한 줄에 하나의 좌표 형식을 지원합니다.

빌드 된 sed 표현식은 모든 x9좌표 를 삭제 한 다음 스크립트 입력에 따라 짝수 또는 홀수 또는 두 입력 라인을 인쇄합니다.

자바 스크립트 (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인지 확인합니다.

자바 스크립트 (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

파이썬 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]

도전에 "분리기"가 언급되어 있기 때문에 함수가 문제인지에 대해서는 여전히 혼란 스럽지만 다른 기능 제출이 많기 때문에 동일한 작업을 수행했습니다.

유사 유안의 대답 만에 많은 더 파이썬 2 네스 비트.

(@xnor 덕분에 2 바이트)

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}

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.

'어두운'과 '둘 다'에 대한 보너스 후행 줄 바꿈이 있습니다. 'dark', 'both'또는 'light'만 입력해야합니다.

온라인으로 사용해보십시오!

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 하고 (첫 번째 테스트에서 ) 해당 사각형을 파이프 라인에 추가합니다. 실행 후 파이프 라인의 요소는 한 줄에 하나씩 출력됩니다.

-in연산자에 v3 이상이 필요합니다 .

_{편집- switch등식 테스트 순서를 제거하고 13 바이트를 절약했습니다.}

줄프, 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

펄, 69 + 3 = 72 바이트

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

로 실행하려면 perl -p3 바이트를 추가했습니다.

덜 골판지 버전 (베이비 카 운영자가 멋지게 포맷하기가 어렵 기 때문에 약간 다릅니다) :

$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이면 존재하지 않는 셀을 건너 뜁니다.

• 루프를 1 개만 사용하여 18 17 바이트를 절약 하고 버그를 수정했습니다.
• 어둡고 밝은 조건을 a와 결합하여 3 바이트 절약 xor
• 첫 번째 문자 대신 전체 입력과 비교하여 3 바이트 절약
• .125표현식에서 더 이상 빼지 않아도되므로 2 바이트 절약$x/9+69.9 char로 변환하기 전에 올바른 행 번호를 얻기 위해 됩니다.
• ~ß공간을 만들기 위해 사용하여 바이트를 저장했습니다.

자바 스크립트 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, 192180 바이트

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

하스켈 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]

이것이 하스켈 골프에서 처음 시도한 것입니다.

Michael Klein의 도움으로 100 자 미만으로 처리 할 수있었습니다!

Mathematica 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)%26 바이트를이기십시오

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 인 경우, 행과 열의 "홀수"가 동일하면 (즉, 둘 다 홀수이거나 둘 다 짝수이면) 정사각형은 항상 검은 색이됩니다. 행과 열이 항상 홀수가 다른 흰색 사각형의 경우에는 반대입니다.

그 후, 행과 열 루프를 결합하고 충분한 수준의 이해 불가능에 도달 할 때까지 연산자 우선 순위 테이블을 참조하면됩니다.