Wyjmij wszystkie białe lub czarne kwadraty szachownicy

29

Wprowadzenie

Tak wygląda szachownica.

wprowadź opis zdjęcia tutaj

Widać, że a1to ciemny kwadrat. Jednakże, b1jest lekki kwadratowy .

Zadanie

Wyzwanie to, biorąc pod uwagę dark, lightczy bothwyjście wszystkie ciemny , światło lub wszystkie kwadraty z separatorem (jak spacji lub nową linią). Kolejność wszystkich kwadratów nie ma znaczenia .

Przypadki testowe

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

Uwaga: Upiększyłem wynik, ale nie jest to konieczne .

To jest , więc wygrywanie z najmniejszą ilością bajtów wygrywa!

Adnan
źródło
Coś takiego a2a4a6...byłoby w porządku?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Musi zawierać separator, taki jak biały znak lub znak nowej linii, więc jest nieprawidłowy.
Adnan
Czy możemy wygenerować surową matrycę 2D? To znaczy[[a2,a4,a6,a8],[...]...]
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Tak, to jest dozwolone
Adnan
Czy light, darki bothmuszą być wprowadzane jako StringS lub mogą być reprezentowane przez dowolny typ danych?
WKS

Odpowiedzi:

15

Pyth, 22 21 bajtów

-1 bajt @ Sp3000

fn%Chz3%sCMT2sM*<G8S8

Zgodnie z funkcją %Chz3, darkskróty do 1, lightdo 0 i bothdo 2. Jeśli weźmiemy parzystość sumy rzędów szachowego kwadratu (to znaczy a1-> [97, 33]-> (97 + 33)%2= 0, ciemne kwadraty idą do 0, a jasne do 1 To pozwala nam filtrować według nierówności.

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.

Wypróbuj tutaj .

lirtosiast
źródło
21:fn%Chz3%sCMT2sM*<G8S8
Sp3000,
@ Sp3000 Thanks! Wiedząc, że użyłem 6 bajtów, aby go dopasować, powinienem był spróbować różnych skrótów.
lirtosiast
13

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}jest rozszerzeniem nawiasów klamrowych, które wytwarza wszystkie współrzędne dla tablicy 8x8 plus dodatkową kolumnę 9. Jest to ważne, ponieważ powoduje, że długość wiersza jest nieparzysta, co pozwala na efekt szachownicy.

Po printfprostu formatuje każdą współrzędną, po jednej w wierszu.

Wbudowane wyrażenie sed usuwa następnie wszystkie x9współrzędne, a następnie drukuje parzyste, nieparzyste lub oba wiersze wejściowe, zgodnie z danymi wejściowymi skryptu.

Cyfrowa trauma
źródło
11

JavaScript (SpiderMonkey 30+), 90 85 83 82 bajtów

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

Zwraca ciąg kwadratów oddzielony przecinkami. Wersja kompatybilna dla 99 bajtów:

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

Działa poprzez wyliczenie wszystkich 64 kwadratowych nazw, a następnie parsowanie ich w bazie 19, aby sprawdzić, czy są one jasne, czy ciemne modulo 2.

Neil
źródło
Dobry. To jest
ES7
@ edc65 Ach, nie pamiętam. Rozumiem, że moja druga wersja to „tylko” ES6.
Neil
Teraz ES6 pokonuje
ES7
@ edc65 Mówiłeś?
Neil
4
@ edc65 Nie sądzę, że moglibyśmy zgodzić się na losowanie?
Neil
10

JavaScript (ES6), 82 87 98

Anonimowa funkcja zwracająca ciąg kwadratów oddzielony spacjami.

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

TEST

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

edc65
źródło
1
Wow ... to po prostu szalone! Zastanawiam się, czy da się skrócić ES6 ...
ETHproductions
@ETHproductions tak to jest! Mam gotowy 86, ale wciąż staram się zrobić coś lepszego (moim - ruchomym - celem jest Neil z 85 ... no cholera 83)
edc65
7

Partia, 192 bajty

@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%
Neil
źródło
4

Pyth, 48 39 bajtów

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

Wypróbuj tutaj!

Nadal dłuższe niż inne rozwiązanie Pyth, ale nie sądzę, żebym mógł to pokonać moim algorytmem.

Wyjaśnienie

Najpierw generujemy listę wszystkich kwadratów na planszy i przypisujemy ją do Y. Następnie filtrujemy tę listę, aby pozostały tylko jasne kwadraty i przypisujemy tę listę do J. Następnie oceniamy dane wejściowe i drukujemy:

  • Y jeśli wejście było both
  • J jeśli wejście było light
  • Y-J jeśli dane wejściowe były dark

Ustalenie, czy kwadrat jest światłem, działa w następujący sposób:

  • Odwzoruj znak na liczbę od 1 do 8 (a-> 1, b-> 2), wyniki 18dla a8itd.
  • sprawdź, czy obie te liczby są nieparzyste, czy parzyste ( x%2 == y%2)
  • Jeśli tak, kwadrat jest jasny, w przeciwnym razie jest ciemny

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
Denker
źródło
O rany, które są krótsze niż moje, z dystansu.
Addison Crump
4

Python 2, 73 71 70 bajtów

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

Nadal jestem trochę zdezorientowany, czy funkcje są w porządku dla pytania, ponieważ wyzwanie wspomina o „separatorze”, ale ponieważ jest wiele innych zgłoszeń funkcji, zrobiłem to samo.

Podobne do odpowiedzi Erwana, ale z dużo większą ilością Python 2-ness.

(-2 bajty dzięki @xnor)

Sp3000
źródło
lol nawet nie testować pomiędzy s=="dark"i s[0]=="d"ale dla mojej obronie w moim naprawdę spróbuj najpierw użyłem s,*_=si 4cmp
Erwan
1
Czuję, że powinno być coś krótszego jak ord(s[_])&_lub ord(s[_])/_.
xnor
@ xnor Rzeczywiście, jest z %:) Dzięki!
Sp3000,
4

PHP, 132 126 120 108 106 bajtów

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

Pętla przechodzi przez kolumny (0-7) i wiersze (1-8) i sprawdza, czy suma obu jest nieparzysta / parzysta.

Testowany z PHP 5.6.4, uruchom go: php -d error_reporting=30709 -r '<CODE>' {dark|light|both}

killerbees19
źródło
1
Witamy w PPCG! To dobra odpowiedź, ale otrzymasz więcej głosów, jeśli dodasz wyjaśnienie.
lirtosiast
Myślę, że można zastąpić $s==2z $s-1. Jeśli $ s = 2, a -1, to 1, co jest zgodne z prawdą i będzie kontynuowane
Martijn
I myślę, że $c=0może być $c, to będzie dać kilka ogłoszeń, ale przynajmniej w ciemności to działa dobrze
Martijn
Dziękuję Martijn! Zapomniałem też usunąć nawiasy klamrowe, na razie -6 bajtów. I nie wiem dlaczego, ale $s-1nie działa, ale powinno. Dzięki za świetny pomysł! Debuguję to później.
killerbees19
Jestem nowy w tej witrynie, ale komunikaty o błędach z powodu niezdefiniowanej $czmiennej? Brzmi to trochę dziwnie i nieważnie. Albo nie?
killerbees19
3

Vitsy , 90 82 bajtów

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

Objaśnienie pierwszego wiersza:

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

Objaśnienie drugiej linii:

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.

Będą premiery nowych linii dla „ciemnych” i „obu”. Wymaga wprowadzenia tylko „ciemności”, „obu” lub „jasności”.

Wypróbuj online!

Addison Crump
źródło
3

PowerShell v3 +, 142 129 bajtów

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

Pobiera dane wejściowe $ai ustawia dwie zmienne, jeśli mamy wyprowadzać kwadraty $dArka lub $lIght na podstawie pierwszej litery wejścia.

Następnie zapętlamy się a-hi 1-8używamy tej samej sztuczki, co w przypadku Określ kolor kwadratu szachowego, aby przeanalizować, czy jest to jasny czy ciemny kwadrat (ustawienie zmiennej pomocniczej $qw pierwszym teście) i w razie potrzeby dodaj ten kwadrat do potoku. Po wykonaniu elementy w potoku są wyprowadzane po jednym w wierszu.

Wymaga od -inoperatora wersji 3 lub nowszej .

Edytuj - Zapisano 13 bajtów, eliminując switchi zmieniając kolejność testowania równości

AdmBorkBork
źródło
3

Jolf, 48 bajtów

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

To dla mnie wszystko greckie ¯ \ _ (ツ) _ / ¯ To jest przełożenie doskonałej odpowiedzi 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
Conor O'Brien
źródło
3

Perl, 69 + 3 = 72 bajty

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

Do uruchomienia perl -p, do którego dodałem 3 bajty.

Wersja mniej golfowa (nieco inna, ponieważ operator babycart utrudnia ładne formatowanie):

$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

Gra w golfa wykorzystuje "@{[]}"; skomentowana wersja używa, @a=...; "@"więc skomentowany kod jest nadal uruchamialny.

David Morris
źródło
map$l.$_,1..8-1
choroba
i ta sama sztuczka dla grep: grep$i=!$i||$b,mapponownie -1
choroba
3

C ++, 132 bajty

Pobiera dane z wiersza polecenia. Używa wskaźnika / modulo voodoo dla warunków drukowania.

#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);}}
MegaTom
źródło
Nie sądzę, żeby npętla była konieczna. Myślę, że zagnieżdżone dla pętli ii jodciąłoby kilka bajtów. (i+j)%2Podejście jest naprawdę mądry. Nie myślałem o tym.
WKS
Po prostu zauważam, że (i//8+i%8)%2to samo, (i//8+i)%2więc możesz wygrać trochę bajtów, jeśli usuniesz definicjęj=n%8
Erwan
3

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

Hej, to nie jest najdłuższa odpowiedź :)

Dane wejściowe są traktowane jako argument wiersza poleceń.

aditsu
źródło
3

PHP, 99 82 79 76 74 73 bajty

Wykorzystuje kodowanie ISO 8859-1.

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

Działaj w ten sposób ( -ddodano tylko dla estetyki):

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

Działa to tak: zmienna $xjest zwiększana od 1 do 71, liczby odpowiadają komórkom, jak pokazano poniżej.

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

Dlatego $x modulo 9zwraca numer kolumny i numer $x / 9wiersza, który przekonwertowałem na literę za pomocą chr. Kod $z<c|$z>k^$x&1zwraca wartość truedla input both( $z<c) oraz w przypadku lightlub darktylko dla komórek parzystych lub nieparzystych ( $z>k ^ $x&1). Wynik tego wyrażenia określa, czy współrzędne komórki zostaną wydrukowane. Wreszcie, jeśli $x modulo 9wyniki 0, pomijam tę nieistniejącą komórkę.

  • Zaoszczędzono 18 17 bajtów (naprawiono błąd), mając tylko 1 pętlę, przekształcając liczbę na znak zamiast odwrotnie
  • Zaoszczędzono 3 bajty, łącząc warunek ciemności i światła z xor
  • Zaoszczędzono 3 bajty, porównując z pełnym wejściem zamiast pierwszego znaku
  • Zapisano 2 bajty, ponieważ nie trzeba już odejmować .125wyrażenia, $x/9+69.9aby uzyskać prawidłowy numer wiersza przed konwersją na znak
  • Zapisano bajt, używając do uzyskania spacji
aross
źródło
2

JavaScript ES6, 187 160 159 bajtów

Prawdopodobnie brakuje mi czegoś boleśnie oczywistego. No cóż. Pomaga nie spłaszczać tablicy.

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

Zwraca tablicę 2D.


Wypróbuj tutaj:

Conor O'Brien
źródło
2

Ruby, 85

Myślę, że są na to krótsze sposoby, ale jest to uroczy użytek .upto.

gets;'a1'.upto('h8'){|e|puts e if e[/[1-8]/]&&(~/b/||((e.ord%2!=e[1].ord%2)^! ~/l/))}
Nie ten Charles
źródło
2

R 129 129 bajtów

Wiedziałem, że mogę wygenerować tablicę lepiej :). Zasadniczo tworzy to odwróconą tablicę, odfiltrowując odniesienia do siatki, w których cień nie pasuje do danych wejściowych. Dane wyjściowe są oddzielone spacją.

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

Nie golfił

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

Test

> 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
>
MickyT
źródło
2

Oracle SQL 11.2, 192 180 bajtów

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

Nie grał w golfa

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

Widok v generuje współrzędne każdego kwadratu. Jeśli suma współrzędnych jest równa, to kwadrat jest czarny, w przeciwnym razie jest biały.

Jeto
źródło
2

Rdza, 263 259 244 bajtów

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

Rozszerzona forma:

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());
            }
        }
    }
}
WKS
źródło
1
Czy zamiast na sztywno zakodować dane wejściowe, nie jest możliwe odczytanie ich z terminala, wiersza poleceń lub jako parametru funkcji?
Neil,
2

MATL , 31 bajtów

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

Wypróbuj online!

Luis Mendo
źródło
Ten wydaje się nie dawać poprawnych kwadratów. „ciemny” daje x1, x3, x5, x7 dla każdej litery x, ale odpowiada to 4 kolumnom, a nie czarnym kwadratom.
Esteemator
@Esteemator Przepraszamy, mój błąd. Poprawiono
Luis Mendo,
2

CJam, 29

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

Szybkie i brudne rozwiązanie: p
Wypróbuj online

Wyjaśnienie:

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
aditsu
źródło
2

Haskell, 133 116 105 100 98 91 bajtów

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

To moja pierwsza próba gry w golfa w Haskell.

Z pomocą Michaela Kleina udało nam się uzyskać mniej niż 100 znaków!

joeytwiddle
źródło
1
A może c>0za c==1i c<1za c==0? Zapisuje dwa bajty.
Michael Klein
Fantastycznie, mamy go poniżej 100! Dziękuję Michael.
joeytwiddle
1
Nie ma za co. Trochę mnie wciągnęło i zmniejszyłem do 86 bajtów, nieco refaktoryzując:f r=[[[a,b]|a<-['a'..'h'],b<-['1'..'8']]!!i|i<-[0..63],even i||r<"l",odd i||r!!0/='d']
Michael Klein
1
To bardzo miłe, przemyślane podejście. Chociaż przykro mi to mówić, że dziwne, a nawet inie dają nam ukośnych pasków. Niektórzy rozwiązują to za pomocą i+i`div`8(jak x+y). Inne zaczynają się od, ['1'..'9']a [0..71]następnie zachowują tylko i`mod`9<8wyniki później, dla 96 bajtów. Jednak ta hybryda naszych dwóch podejść radzi sobie dobrze przy 91 bajtach:l=[0..7];f r=[["abcdefgh"!!x,"12345678"!!y]|x<-l,y<-l,odd(x+y)||r<"l",even(x+y)||r!!0/='d']
joeytwiddle
Ach, cóż, wciąż jest o wiele lepiej
Michael Klein
1

Matematyka 133 bajty

Metoda 1 : 108 bajtów. To konstruuje tablicę jako tabelę, z etykietami w każdej komórce, i zwraca jasne lub ciemne przekątne lub pasy zgodnie z wymaganiami.

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


Metoda 2 : 133 bajty. Tworzy tablicę i wybiera zgodnie z nieparzystym charakterem sumy numeru wiersza + numeru kolumny każdej komórki.

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

DavidC
źródło
1

JS, 197 bajtów

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])
Łodzik
źródło
1

Python (3.5), 106 100 96 92 bajty

użyj sztuczki MegaTom, (i+j)%2aby wygrać 6 bajtów

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

Wypróbuj na repl.it

Wyniki

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

Poprzednia wersja

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]
Erwan
źródło
1

C ++, 119 bajtów

Na podstawie sztuczki 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);}}}
Johan du Toit
źródło
0

C (gcc) , 112 bajtów

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

Wypróbuj online!

Jeśli a == 1, kwadrat będzie zawsze czarny, jeśli „nieparzystość” wiersza i kolumny jest taka sama, tzn. Oba są nieparzyste lub oba są parzyste. Przeciwnie jest w przypadku białych kwadratów, w których rząd i kolumna zawsze będą się różnić nieparzystością.

Następnie wystarczy połączyć pętle wierszy i kolumn, a także zapoznać się z tabelą priorytetów operatorów, aż do osiągnięcia wystarczającego poziomu niezrozumiałości.

gastropner
źródło