Giriş

Satranç tahtası böyle gözüküyor.

Bunu görebilirsiniz a1bir olduğu karanlık kare. Ancak, b1bir olan hafif kare .

Görev

Meydan okuma, verilir dark, lightya da both, çıktı tüm karanlık , ışık veya tüm kareler bir ayırıcı ile (bir boşluk veya bir satır gibi). Tüm karelerin sırası önemli değil .

Test durumları

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

Not: Çıkışı seçtim ancak bu gerekli değil .

Bu kod-golf , bu yüzden en az sayıda bayt olan gönderim kazanıyor!

Pyth, 22 21 bayt

-1 byte @ Sp3000

fn%Chz3%sCMT2sM*<G8S8

Fonksiyonun altında %Chz3 , dark1 karmaları light0 ve both2'ye bir satranç karenin ords'ün toplamı (olduğunu, parite alırsak a1-> [97, 33]> - (97 + 33)%2= 01, karanlık kareler 0 gidin ve hafif Bu eşitsizliğe göre filtrelememize izin verir.

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.

Burada dene .

Bash + GNU Yardımcı Programları, 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'lik bir tahtanın tüm koordinatlarını ve ek bir sütunu üreten bash ayraç genişlemesidir 9. Bu önemlidir, çünkü tezahürat efekti sağlayan sıra uzunluğunu garipleştirir.

printfSadece her satıra bir koordinat formatlarını.

Dahili sed ifadesi daha sonra tüm x9koordinatları siler ve daha sonra kod girişine göre çift veya tek veya her iki giriş satırını yazdırır.

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

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

Virgülle ayrılmış bir kareler dizesi döndürür. 99 byte için uyumlu sürüm:

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

64 kare isminin hepsini sıralayarak çalışır, sonra açık veya koyu modulo 2 olup olmadıklarını görmek için 19 üssünde ayrıştırma ile çalışır.

JavaScript (ES6), 82 87 98

Boşluk döndüren adsız işlev, bir kareler dizesiyle ayrılmış.

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

ÖLÇEK

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

Toplu iş, 192 bayt

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

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

Burada dene!

Yine diğer Pyth çözümünden daha uzun, ancak algoritmamla bunu yenebileceğimi sanmıyorum.

açıklama

İlk önce tahtadaki tüm karelerin bir listesini çıkarır ve atarız Y. Sonra bu listeye filtre uygularız, böylece sadece hafif kareler kalır ve bu listeyi atar J. Bundan sonra girişi değerlendirir ve yazdırırız:

• Y eğer girdi ise both
• J eğer girdi ise light
• Y-J giriş olsaydı dark

Bir karenin ışık olup olmadığını belirlemek şu şekilde çalışır:

• 1-8 arasında bir sayı (a-> 1, b-> 2) için kömürü Harita, sonuçları 18için a8vs.
• Her iki sayının tek veya çift olup olmadığını kontrol edin ( x%2 == y%2)
• Eğer öyleyse, kare aydınlık, aksi takdirde karanlık

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 bayt

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

Zorluk bir "ayırıcıdan" bahsettiği için işlevlerin soru için uygun olup olmadıklarına hâlâ biraz kafam karıştı, ancak aynı şeyi yaptığım başka birçok fonksiyon önerisi olduğu için.

Erwan'ın cevabına benzer fakat çok daha fazla Python 2-ness ile.

(@Xnor sayesinde -2 bayt)

PHP, 132 126 120 108 106 bayt

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

Kolonlar (0-7) ve sıralar (1-8) arasından dolaşır ve her ikisinin toplamının tek / çift olup olmadığını kontrol eder.

PHP 5.6.4 ile test edilmiştir, çalıştırınız: php -d error_reporting=30709 -r '<CODE>' {dark|light|both}

Vitsy , 90 82 bayt

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

İlk satırın açıklaması:

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

İkinci satırın açıklaması:

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.

'Karanlık' ve 'her ikisi için' bonus izleyen yeni satırlar olacak. Sadece 'karanlık', 'her ikisi' veya 'ışık' girişi yapılmasını gerektirir.

Çevrimiçi deneyin!

PowerShell v3 +, 142 129 bayt

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

Giriş alır $a ve ilk harfini temel alarak $dark veya $lhafif kareler çıkarmamız için iki değişken ayarlar .

Sonra Bİz üzerinde döngü a-hve 1-8ve üzerinde aynı hile kullanır açık ya da koyu kare olup olmadığını ayrıştırmak için bir satranç karesinin rengini belirleme ile (yardımcı değişken değişkenini ayarlama)$q ilk testte) ve boru hattı uygun eğer o kareyi ekleyin. Yürütmeden sonra, boru hattındaki elemanlar her satıra bir tane çıkar.

İçin v3 veya daha yenisini gerektirir -inOperatör .

_{Düzenleme - switchEşitlik testi sırasını değiştirerek ve eşitleyerek 13 bayt kurtarıldı}

Jolf, 48 bayt

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

Hepsi bana göre Yunanca ¯ \ _ (ツ) _ / ¯ Bu edc65'in mükemmel cevabının bir kopyası.

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

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

Çalıştırılmak üzere perl -p3 bayt ekledim.

Daha az golf oyunu (babycart operatörü güzelce biçimlendirmeyi zorlaştırdığı için biraz farklı):

$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

Golf versiyonunu kullanır "@{[]}"; yorumlanan sürüm @a=...; "@", yorumlanan kodun hala çalıştırılabilir olması için kullanılır.

C ++, 132 bayt

Komut satırı ile giriş yapar. Baskı koşulu için işaretçi / modulo vudu kullanır.

#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, bu en uzun cevap değil :)

Giriş, bir komut satırı argümanı olarak alınır.

PHP, 99 82 79 76 74 73 bayt

ISO 8859-1 kodlamasını kullanır.

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

Bu şekilde koş ( -dyalnızca estetik için eklendi):

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

Bunun gibi çalışır: değişken $x1 ila 71 arasında artar, sayılar aşağıda gösterildiği gibi hücrelere karşılık gelir.

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

Bu nedenle, $x modulo 9sütun sayısını $x / 9verir ve kullanarak bir harfe dönüştürdüğüm satır numarasını verir chr. Kod $z<c|$z>k^$x&1verimleri truegirişi için both( $z<c) ve söz konusu lightveya darksadece çift ya da tek hücreleri için sırasıyla ( $z>k ^ $x&1). Bu ifadenin sonucu, hücre koordinatlarının sonra yazdırılıp yazdırılmayacağını belirler. Son olarak, $x modulo 9sonuçlanırsa 0, bu olmayan hücreyi atlarım.

• Kayıtlı 18Sadece 1 döngüye sahip 17 bayt (bir hata düzeltildi), sayıyı tersi yönde bir karaktere dönüştürdü.
• Karanlık ve aydınlık şartlarını bir araya getirerek 3 bayt kurtardı. xor
• İlk karakter yerine tam girdiyle karşılaştırılarak 3 bayt kaydedildi
• 2 bayt kaydedildi, çünkü artık çıkartmanız gerekmiyor .125 ifadede$x/9+69.9 bir karaktere dönüştürmeden önce doğru satır numarasını almak için
• ~ßBoşluk bırakmak için kullanarak bir bayt kaydedildi

JavaScript ES6, 187 160 159 bayt

Muhtemelen acı veren bariz bir şeyi özlüyorum. Oh iyi. Diziyi düzleştirmek zorunda kalmamak yardımcı olur.

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

2B dizi döndürür.

Burada dene:

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>

Ruby, 85

Bu konuda daha kısa yollar olduğunu düşünüyorum, ancak bu şirin bir kullanım .upto.

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

R, 129 94 bayt

Tahtayı daha iyi üretebileceğimi biliyordum :). Temelde bu, gölgenin girdiyle uyuşmadığı ızgara referanslarını filtreleyen ters bir tahta oluşturur. Çıktı boşlukla ayrılmış.

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

Ölçek

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

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

Un-golfed

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 görünümü, her karenin koordinatlarını oluşturur. Koordinatların toplamı o zaman bile kare siyahsa, başka beyazdır.

Rust, 263 259 244 Bayt

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

Genişletilmiş biçim:

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 bayt

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

Çevrimiçi deneyin!

CJam, 29

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

Sadece hızlı ve kirli bir çözüm: p
Çevrimiçi deneyin

Açıklama:

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 bayt

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

Bu benim Haskell'de golf oynamaya ilk girişimdi.

Michael Klein'ın yardımıyla, 100 karakterin altında elde etmeyi başardık!

Mathematica 133 bayt

Yöntem 1 : 108 bayt. Bu, tahtayı her hücrede etiketlerle birlikte bir masa olarak inşa eder ve gerektiği şekilde açık veya koyu çaprazları veya bantları döndürür.

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

Yöntem 2 : 133 bayt. Bir dizi oluşturur ve her bir hücrenin satır numarası + sütun numarasının toplamının tuhaf yapısına göre seçer.

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 bayt

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 bayt

(i+j)%26 bayt kazanmak için MegaTom hilesini kullan

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 denemek

Sonuçlar

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

Önceki versiyon

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 Bayt

MegaTom'un numarasına göre.

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

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

Çevrimiçi deneyin!

A == 1 ise, satır ve sütunun “tuhaflığı” aynı ise, yani her ikisi de tek veya her ikisi de eşitse, bir kare daima siyah olacaktır. Tam tersi, satır ve sütunun her zaman tuhaflık bakımından farklı olacağı beyaz kareler için geçerlidir.

Ondan sonra, sadece satır ve sütun halkalarını birleştirmek ve aynı zamanda yeterli bir anlaşılmazlık seviyesine ulaşana kadar bir operatör önceliği tablosuna başvurmak söz konusudur.