Выведите все белые или черные квадраты шахматной доски


29

Введение

Так выглядит шахматная доска.

введите описание изображения здесь

Вы можете видеть, что 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

Примечание: я предварительно подтвердил вывод, но это не обязательно .

Это , поэтому выигрывает представление с наименьшим количеством байтов!


Итак, что-то вроде a2a4a6...будет хорошо?
Конор О'Брайен

@ CᴏɴᴏʀO'Bʀɪᴇɴ Он должен содержать разделитель, например, пробел или символ новой строки, поэтому он недопустим.
Аднан

Можем ли мы вывести необработанную 2d матрицу? Т.е.[[a2,a4,a6,a8],[...]...]
Конор О'Брайен,

@ CᴏɴᴏʀO'Bʀɪᴇɴ Да, это разрешено
Аднан

Делать light, darkи bothдолжны быть введены как Strings или они могут быть представлены через любой тип данных?
WKS

Ответы:


15

Pyth, 22 21 байт

-1 байт от @ Sp3000

fn%Chz3%sCMT2sM*<G8S8

В соответствии с функцией %Chz3, darkхэши в 1, lightв 0 и bothв 2. Если мы берем четность суммы орд шахматного квадрата (то есть, 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.

Попробуй это здесь .


21:fn%Chz3%sCMT2sM*<G8S8
Sp3000

@ Sp3000 Спасибо! Зная, что я использовал 6 байтов, чтобы привести его в соответствие, я должен был попробовать разные хэши.
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}это расширение фигурной скобки, которое выдает все координаты для доски 8х8 плюс дополнительный столбец 9. Это важно, потому что это делает длину строки нечетной, что обеспечивает эффект шахматной доски.

printfПросто форматы каждой координате, по одному в каждой строке.

Затем встроенное выражение sed удаляет все x9координаты и затем печатает либо четные, либо нечетные, либо обе входные строки в соответствии со входными данными скрипта.


11

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.


Хорошо. Это ES7
edc65

@ edc65 Ах, я не мог вспомнить. Я так понимаю, моя вторая версия "только" ES6.
Нил

Теперь ES6 побеждает ES7
edc65

@ edc65 Вы говорили?
Нил

4
@ edc65 Не думаю, что мы могли бы согласиться на ничью?
Нил

10

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


1
Вау ... это просто безумие! Интересно, можно ли стать короче с ES6 ...
ETHproductions

@ETHproductions да, это так! У меня готов 86, но я все еще пытаюсь сделать что-то лучше (моя движущаяся цель - Нил с 85 ... нет, черт возьми, 83)
edc65

7

Пакет, 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%

4

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

О, черт , это длиннее моего.
Эддисон Крамп

4

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]

Я все еще немного сбит с толку, подходят ли функции для этого вопроса, поскольку в задании упоминается «разделитель», но, поскольку есть много других представлений функций, я сделал то же самое.

Аналогично ответу Эрвана, но с гораздо большим количеством Python-2.

(-2 байта благодаря @xnor)


LOL Я даже не проверяю между s=="dark"и, s[0]=="d"но для моей защиты в моей действительно первой попытке, которую я использовал s,*_=sи 4cmp
Эрван

1
Я чувствую, что должно быть что-то короче, как ord(s[_])&_или ord(s[_])/_.
xnor

@xnor Действительно, есть с %:) Спасибо!
Sp3000

4

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}


1
Добро пожаловать в PPCG! Это хороший ответ, но вы получите больше голосов, если добавите объяснение.
lirtosiast

Я думаю, что вы можете заменить $s==2на $s-1. Если $ s = 2 и -1, то это 1, что верно и будет продолжаться
Мартейн

И я думаю, что $c=0может быть $c, это даст кучу уведомлений, но, по крайней мере, для темных он отлично работает
Martijn

Спасибо, Мартейн! Я тоже забыл удалить скобки, пока что -6 байт. И я не знаю почему, но $s-1не работает, но должно. Спасибо за эту прекрасную идею! Я исправлю это позже.
killerbees19

Я новичок в этом сайте, но сообщения об ошибках из-за неопределенной $cпеременной? Это звучит немного странно и недействительно. Или не?
killerbees19

3

Вицы , 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.

Будут бонусные трейлинговые строки для «темных» и «обоих». Требуется, чтобы вводились только «темный», «оба» или «светлый».

Попробуйте онлайн!


3

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в первом тесте) и добавить , что квадрат в случае необходимости трубопровода. После выполнения элементы в конвейере выводятся по одному на строку.

Требуется v3 или новее для -inоператора.

Редактировать - 13 байтов сохранено путем исключения switchи путем изменения порядка проверки на равенство


3

Джольф, 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

3

Perl, 69 + 3 = 72 байта

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

Для запуска perl -p, для которого я добавил 3 байта.

Версия с меньшим объемом игры (немного отличается, так как оператор детской тележки затрудняет форматирование):

$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=...; "@"так, чтобы закомментированный код все еще работал.


map$l.$_,1..8-1
Чороба

и та же самая уловка для grep: grep$i=!$i||$b,mapснова -1
choroba

3

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

Я не думаю, что n-луп необходим. Я думаю, что вложенные в циклы iи jобрезать несколько байтов. (i+j)%2Подход действительно умный. Я не думал об этом.
WKS

Я просто замечаю, что (i//8+i%8)%2это то же самое, что (i//8+i)%2вы можете выиграть несколько байтов, если j=n%8
Erwan

3

Ява, 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);}}

Эй, это не самый длинный ответ :)

Ввод принимается в качестве аргумента командной строки.


3

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для input 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чтобы получить правильный номер строки перед преобразованием в символ
  • Сохраненный байт с помощью пробела

2

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

Возвращает двумерный массив.


Попробуйте это здесь:


2

Руби, 85

Я думаю, что есть более короткие пути, но это симпатичное использование .upto.

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

2

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
>

2

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

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 генерирует координаты каждого квадрата. Если сумма координат четна, тогда квадрат черный, иначе белый.


2

Rust, 263 259 244 Bytes

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

1
Вместо того, чтобы жестко кодировать ваш ввод, нельзя ли прочитать его из терминала или из командной строки или как параметр функции?
Нил

2

MATL , 31 байт

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

Попробуйте онлайн!


Этот, кажется, не дает правильных квадратов. «темный» дает x1, x3, x5, x7 для каждой буквы x, но это соответствует 4 столбцам, а не черным квадратам.
Оценщик

@Esteemator Извините, моя ошибка. Исправлено
Луис Мендо

2

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

2

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.

С некоторой помощью Михаэля Кляйна нам удалось получить его под 100 символов!


1
Как насчет c>0для c==1и c<1для c==0? Сохраняет два байта.
Майкл Кляйн

Фантастика, мы получили его под 100! Спасибо, Майкл.
Joeytwiddle

1
Пожалуйста. Я немного засосал и уменьшил его до 86 байт, немного изменив рефакторинг:f r=[[[a,b]|a<-['a'..'h'],b<-['1'..'8']]!!i|i<-[0..63],even i||r<"l",odd i||r!!0/='d']
Майкл Кляйн

1
Это очень хорошо, переосмысленный подход. Хотя мне жаль говорить, что странно и даже iне дают нам диагональные полосы. Некоторые решают это с i+i`div`8(как x+y). Другие начинаются с ['1'..'9']и [0..71]затем сохраняют только i`mod`9<8результаты позже, для 96 байтов. Тем не менее, этот гибрид наших двух подходов хорошо работает при 91 l=[0..7];f r=[["abcdefgh"!!x,"12345678"!!y]|x<-l,y<-l,odd(x+y)||r<"l",even(x+y)||r!!0/='d']
байте

Ах, хорошо, это все еще немного лучше
Майкл Кляйн

1

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


1

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

1

Python (3,5), 106 100 96 92 байта

используйте трюк MegaTom, (i+j)%2чтобы выиграть 6 байтов

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]

1

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

0

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, то квадрат всегда будет черным, если «нечетность» строки и столбца одинакова, то есть оба являются нечетными или оба являются четными. Противоположность верна для белых квадратов, где строка и столбец всегда будут отличаться по странности.

После этого нужно просто объединить циклы строк и столбцов, а также просмотреть таблицу приоритетов операторов, пока не будет достигнут достаточный уровень непонятности.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.