Нехай шахівниця 8х8 представлена ​​будь-якими двома різними значеннями, причому одне значення - порожній квадрат, а інше - королева. У наступних прикладах я використовую 0 як порожні квадрати, а 1 - як королеви. Наприклад:

дається

1 0 1 1 1 0 0 0
1 0 1 0 1 0 1 1
1 0 1 0 1 1 0 1
0 1 0 1 0 1 0 0
0 1 1 0 0 1 0 1
1 0 0 0 1 0 0 0
0 1 0 0 0 1 1 1
0 1 1 1 0 1 0 1

Розглянемо кількість пар королеви, які атакують кожну, що знаходяться як мінімум на один квадрат (як нагадування, королеви атакують ортогонально та діагонально). У наведеному вище прикладі наступна неймовірна негарна діаграма показує всі ці пари як стрілки.

Вище знайдено 43 пари, які дають наступний тестовий випадок:

Input:
1 0 1 1 1 0 0 0
1 0 1 0 1 0 1 1
1 0 1 0 1 1 0 1
0 1 0 1 0 1 0 0
0 1 1 0 0 1 0 1
1 0 0 0 1 0 0 0
0 1 0 0 0 1 1 1
0 1 1 1 0 1 0 1
Output: 43

Виклик

Напишіть програму, яка з урахуванням стану плати, представленого двома різними значеннями, виводить кількість пар королеви, які атакують одна одну, принаймні один квадрат між ними.

• Ви можете вводити в будь-якому зручному форматі, який використовує два значення для представлення порожніх квадратів і маток, наприклад, рядок 64 "". матриця булевих списків, список списку цілих чисел 0 і 1 тощо, якщо це пояснено у вашому рішенні
• Вихід - ціле число
• Застосовуються стандартні методи вводу / виводу, а стандартні лазівки заборонені
• Це кодовий гольф, тому найкоротша відповідь у байтах виграє

Тестові приклади:

Використовуючи формат 0 і 1, 0 - порожні квадрати, а 1 - королеви:

Input:
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
Output: 0

Input:
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
Output: 0

Input:
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 1 0 0 0 0 1 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
Output: 1

Input:
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0
0 1 0 0 0 0 1 0
0 0 0 0 1 0 1 0
0 0 0 0 0 0 0 0
0 0 0 1 0 0 1 0
0 0 0 0 0 0 0 0
Output: 10

Input:
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
Output: 4

Input:
1 1 0 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
Output: 11

Python 2 , 105 байт

lambda b:sum(b[i+d::d][:(8,7-i%8,i%8)[d%8%5]].find('1')*int(c)>0for i,c in enumerate(b)for d in[1,7,8,9])

Спробуйте в Інтернеті!

Пояснення

Ми приймаємо введення як рядок з 64 символів '0'або '1'. Використовуючи крокові фрагменти, ми відкидаємо чотири "лінії зору" від кожної королеви, з якою ми стикаємося. Наприклад, коли i = 10 і d = 7 , позначаючи королеву як ♥, а плитки обрані b[i+d::d]символом █:

1 0 1 1 1 0 0 0
1 0 ♥ 0 1 0 1 1
1 █ 1 0 1 1 0 1
█ 1 0 1 0 1 0 █
0 1 1 0 0 1 █ 1
1 0 0 0 1 █ 0 0
0 1 0 0 █ 1 1 1
0 1 1 █ 0 1 0 1

Зрозуміло, що насправді ми не хочемо, щоб бачення оберталося навколо такої дошки. Тому ми обчислюємо, наскільки далеко край дошки знаходиться в кожному напрямку, і переглядаємо плитки на b[i+d::d][:…].

Для кожної пари плитки-напрямку ми підраховуємо:

ray.find('1')*int(c)>0

Це не вдасться кожного разу

• cне королева; або
• королева, яку цей промінь бачить, занадто близька ( findповертає 0); або
• цей промінь не бачить королеви ( findповертається -1).

Кожну пару королеви перевіряють лише один раз, оскільки промені завжди подаються вперед в порядку читання, від «раніше» королеви до «пізнішої».

JavaScript (ES7), 86 байт

Вводиться як масив з 64 цілих чисел з 254 для королеви та 0 для порожнього квадрата.

a=>[s=0,6,7,8].map(d=>a.map(g=(n,p)=>(p%8-(p+=~d)%8)**2<n%4?a[p]?s+=n&1:g(n/2,p):0))|s

Спробуйте в Інтернеті!

Ця версія зловживає арифметичним підтоком, щоб отримати стан зупинки в рекурсивній частині.

JavaScript (ES7), 89 байт

Приймає вхід як масив з 64 біт.

a=>[s=0,6,7,8].map(d=>a.map(g=(n,p,x)=>(p%8-(p+=~d)%8)**2>1|p<0?0:a[p]?s+=!x&n:g(n,p)))|s

Спробуйте в Інтернеті!

Як?

Ми рекурсивно викликаємо названу функцію зворотного виклику, map()щоб пройти через квадрати в заданому напрямку. Хоча насправді нам не потрібен вміст третього параметра зворотного виклику (масив map()був викликаний), ми побічно використовуємо його, тим не менш, щоб знати, чи це перша ітерація чи ні.

arr.map (зворотний виклик функції (currentValue [, індекс [, масив]])

Це змінна x у коді.

a =>                        // given the input array a[]
  [ s = 0,                  // initialize the sum s to 0
    6, 7, 8 ].map(d =>      // for each direction d in [0, 6, 7, 8]:
    a.map(g = (n, p, x) =>  //   for each square n at position p in a[]:
      (                     //     we are out of the board if:
        p % 8 -             //       - abs(p % 8 - p' % 8) is greater than 1
        (p += ~d) % 8       //         where p' = p - (d + 1)
      ) ** 2 > 1 |          //         (squaring is shorter than using Math.abs)
      p < 0 ?               //       - or p' is less than 0
        0                   //       if so, stop recursion
      :                     //     else:
        a[p] ?              //       if there's a queen on the target square:
          s +=              //         increment s if:
            !x &            //           x is undefined (this is not the 1st iteration)
            n               //           and n = 1 (there's a queen on the source square)
        :                   //       else:
          g(n, p)           //         do a recursive call to g(), with x undefined
    )                       //   end of inner map()
  ) | s                     // end of outer map(); return s

Равлики , 14 байт

A
rdaa7\1\0+\1

Спробуйте в Інтернеті!

Вхід - це формат 0/1, без пробілів у рядках.

Равлики були створені для виклику 2D, що відповідає мовному дизайну PPCG . Найголовніше, що він за замовчуванням видає кількість знайдених матчів, що ідеально підходить для цього завдання.

A встановлює параметр "усі шляхи", так що якщо королева знаходиться в декількох парах, кожна з цих пар генерує збіг.

rdaa7встановлює напрямок відповідності на S, SE, E та NE. Якщо встановити всі напрямки ( z), це спричинить подвійний підрахунок.

\1\0+\1відповідає a 1, то одному або більше 0s, потім іншим 1.

APL (Dyalog Classic) , 41 39 32 байт

(+/+⌿-⌈⌿)2<⌿0⍪⊢,⍉,8 31⍴⊢,≠⍨,⌽,≠⍨

Спробуйте в Інтернеті!

≠⍨ "не дорівнює собі" - матриця 8х8 з усіма нулями

⊢,≠⍨,⌽,≠⍨- якщо початкова матриця є ABC..., це вираз повертає:

A B C D E F G H 0 0 0 0 0 0 0 0 H G F E D C B A 0 0 0 0 0 0 0 0
I J K L M N O P 0 0 0 0 0 0 0 0 P O N M L K J I 0 0 0 0 0 0 0 0
Q R S T U V W X 0 0 0 0 0 0 0 0 X W V U T S R Q 0 0 0 0 0 0 0 0
Y Z A B C D E F 0 0 0 0 0 0 0 0 F E D C B A Z Y 0 0 0 0 0 0 0 0
G H I J K L M N 0 0 0 0 0 0 0 0 N M L K J I H G 0 0 0 0 0 0 0 0
O P Q R S T U V 0 0 0 0 0 0 0 0 V U T S R Q P O 0 0 0 0 0 0 0 0
W X Y Z A B C D 0 0 0 0 0 0 0 0 D C B A Z Y X W 0 0 0 0 0 0 0 0
E F G H I J K L 0 0 0 0 0 0 0 0 L K J I H G F E 0 0 0 0 0 0 0 0

8 31⍴ переробляє її з 8x32 на 8x31, повторно використовуючи елементи в основному рядку:

A B C D E F G H 0 0 0 0 0 0 0 0 H G F E D C B A 0 0 0 0 0 0 0
0 I J K L M N O P 0 0 0 0 0 0 0 0 P O N M L K J I 0 0 0 0 0 0
0 0 Q R S T U V W X 0 0 0 0 0 0 0 0 X W V U T S R Q 0 0 0 0 0
0 0 0 Y Z A B C D E F 0 0 0 0 0 0 0 0 F E D C B A Z Y 0 0 0 0
0 0 0 0 G H I J K L M N 0 0 0 0 0 0 0 0 N M L K J I H G 0 0 0
0 0 0 0 0 O P Q R S T U V 0 0 0 0 0 0 0 0 V U T S R Q P O 0 0
0 0 0 0 0 0 W X Y Z A B C D 0 0 0 0 0 0 0 0 D C B A Z Y X W 0
0 0 0 0 0 0 0 E F G H I J K L 0 0 0 0 0 0 0 0 L K J I H G F E

⊢,⍉, попереджує початкову матрицю та її транспонирование (додаткові пробіли для наочності):

A B C D E F G H  A I Q Y G O W E  A B C D E F G H 0 0 0 0 0 0 0 0 H G F E D C B A 0 0 0 0 0 0 0
I J K L M N O P  B J R Z H P X F  0 I J K L M N O P 0 0 0 0 0 0 0 0 P O N M L K J I 0 0 0 0 0 0
Q R S T U V W X  C K S A I Q Y G  0 0 Q R S T U V W X 0 0 0 0 0 0 0 0 X W V U T S R Q 0 0 0 0 0
Y Z A B C D E F  D L T B J R Z H  0 0 0 Y Z A B C D E F 0 0 0 0 0 0 0 0 F E D C B A Z Y 0 0 0 0
G H I J K L M N  E M U C K S A I  0 0 0 0 G H I J K L M N 0 0 0 0 0 0 0 0 N M L K J I H G 0 0 0
O P Q R S T U V  F N V D L T B J  0 0 0 0 0 O P Q R S T U V 0 0 0 0 0 0 0 0 V U T S R Q P O 0 0
W X Y Z A B C D  G O W E M U C K  0 0 0 0 0 0 W X Y Z A B C D 0 0 0 0 0 0 0 0 D C B A Z Y X W 0
E F G H I J K L  H P X F N V D L  0 0 0 0 0 0 0 E F G H I J K L 0 0 0 0 0 0 0 0 L K J I H G F E

2<⌿0⍪додає 0 вгорі і порівнює використання <кожного елемента проти елемента під ним, тому ми отримуємо 1 для провідного 1 у кожній вертикальній групі 1s, і ми отримуємо 0s скрізь

+⌿-⌈⌿ суми за стовпцями мінус максимуми за стовпцями - ми обчислюємо кількість прогалин між 1 групами в кожному стовпці, 0 якщо таких немає

+/ сума

Желе , 22 20 байт

t0ŒgL:2
Z,U;ŒD$€ẎÇ€S

Спробуйте в Інтернеті!

Сітківка 0,8,2 , 60 58 байт

1
¶1$';___¶
_
$n$%`7$*_
(.)(?=.*;(_)*)(?<-2>.)*
$1
m`^10+1

Спробуйте в Інтернеті! Вводиться як 8-символьних двійкових рядків, розділених комами, але заголовок перетворює наданий для вас формат. Пояснення:

1
¶1$';___¶

Створіть усі підряди дошки, починаючи з королеви. Додайте значення маркера до кожної підрядки. Редагувати: збережено 2 байти, залишивши за собою кілька рядків сміття; вони фактично ігноруються.

_
$n$%`7$*_

Розділіть кожен маркер на інклюзивний діапазон і додайте 7 до ненульових елементів.

(.)(?=.*;(_)*)(?<-2>.)*
$1

Видаліть кожен пробіг символів, який дорівнює довжині маркера. Це рівнозначно пошуку кожного східного, південно-західного, південного чи південно-східного променя у кожної королеви.

m`^10+1

Порахуйте всі промені, які проходять принаймні один порожній квадрат, перш ніж зустрітися з іншою королевою.

JavaScript (ES6) + SnakeEx , 38 байт

s=>snakeEx.run('m:<*>10+1',s).length/2

Бере введення у формі '10111000\n10101011\n10101101\n01010100\n01100101\n10001000\n01000111\n01110101'. Виявляється, SnakeEx все ще можна використовувати поза початковим завданням!

К (нг / к) , 45 байт

{+/0|-1++/0|-':x,'+x,+8 31#,/+x,a,(|x),a:0*x}

Спробуйте в Інтернеті!