26

Đặt một bàn cờ 8x8 được đại diện bởi bất kỳ hai giá trị riêng biệt nào, với một giá trị là một hình vuông trống và cái còn lại là một nữ hoàng. Trong các ví dụ sau, tôi sử dụng 0 là các ô vuông trống và 1 là các nữ hoàng. Ví dụ:

được đưa ra bởi

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

Hãy xem xét số lượng cặp nữ hoàng đang tấn công mỗi cái cách nhau ít nhất một ô vuông (như một lời nhắc nhở, nữ hoàng tấn công trực giao và theo đường chéo). Trong ví dụ trên, sơ đồ xấu xí đáng kinh ngạc sau đây cho thấy tất cả các cặp này là mũi tên.

Có 43 cặp được tìm thấy ở trên đưa ra trường hợp thử nghiệm sau:

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

Thử thách

Viết chương trình, với trạng thái bảng được biểu thị bằng hai giá trị riêng biệt, đưa ra số lượng cặp kiến chúa tấn công lẫn nhau với ít nhất một ô vuông ở giữa chúng.

Bạn có thể nhập bất kỳ định dạng nào thuận tiện nhất, sử dụng hai giá trị để biểu thị các ô vuông và nữ hoàng trống, ví dụ: một chuỗi 64 "." Cho các ô vuông trống và "Q" cho các nữ hoàng theo hàng từ dưới lên trên, 8 x 8 ma trận booleans, danh sách các số nguyên 0 và 1, v.v, miễn là nó được giải thích trong giải pháp của bạn
Đầu ra là một số nguyên
Các phương pháp I / O tiêu chuẩn được áp dụng và các sơ hở tiêu chuẩn bị cấm
Đây là mã golf nên câu trả lời ngắn nhất trong byte thắng

Các trường hợp thử nghiệm:

Sử dụng định dạng 0 và 1, với 0 là hình vuông trống và 1 là nữ hoàng:

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

code-golf chess binary-matrix

— JMigst
nguồn

Tôi nên hỏi trước khi đăng phiên bản thứ 2 của mình: có phải là 254 cho một nữ hoàng và 0 cho một giá trị đầu vào có thể chấp nhận được không?

— Arnauld

@Arnauld Bạn có thể nhập vào bất kỳ định dạng nào thuận tiện nhất sử dụng hai giá trị để thể hiện các ô vuông và kiến trúc trống. Vì vậy, điều đó là chắc chắn

— JMigst

Cảm ơn. Tôi hỏi bởi vì tôi nghĩ quy tắc này có thể hơi quá dễ dãi nếu được thực hiện theo nghĩa đen. Tôi có thể yêu cầu chuyển một chuỗi chứa hầu hết mã JS cho các nữ hoàng và chỉ cần đánh giá điều đó trong chương trình. (Nhưng nó có thể được ngăn chặn bởi một lỗ hổng mặc định. Tôi không chắc chắn.)

— Arnauld

14

Python 2 , 105 byte

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

Hãy thử trực tuyến!

Giải trình

Chúng tôi lấy đầu vào là một chuỗi gồm 64 ký tự '0'hoặc '1'. Sử dụng các lát cắt, chúng tôi tạo ra bốn "đường ngắm" từ mọi nữ hoàng mà chúng tôi gặp. Ví dụ: khi i = 10 và d = 7 , đánh dấu nữ hoàng là ♥ và các ô được chọn b[i+d::d]là █:

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

Rõ ràng, chúng ta không thực sự muốn tầm nhìn bao quanh bảng như thế này. Vì vậy, chúng tôi tính toán khoảng cách của cạnh của bảng theo mỗi hướng và xem các ô tại b[i+d::d][:…].

Đối với mỗi cặp hướng gạch, chúng tôi tính:

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

Điều này sẽ thất bại bất cứ khi nào

ckhông phải là một nữ hoàng; hoặc là
nữ hoàng mà tia này nhìn thấy quá gần ( findtrả về 0); hoặc là
tia này không thấy nữ hoàng ( findtrả về −1).

Mỗi cặp nữ hoàng chỉ được kiểm tra một lần, vì các tia luôn được chiếu về phía trước theo thứ tự đọc, từ một nữ hoàng "sớm hơn" đến một "sau".

— Lynn
nguồn

10

JavaScript (ES7), 86 byte

Lấy đầu vào là một mảng gồm 64 số nguyên với 254 cho một nữ hoàng và 0 cho một hình vuông trống.

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

Hãy thử trực tuyến!

Phiên bản này lạm dụng dòng chảy số học để có được một điều kiện dừng trong phần đệ quy.

JavaScript (ES7), 89 byte

Lấy đầu vào là một mảng 64 bit.

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

Hãy thử trực tuyến!

Làm sao?

Chúng tôi gọi đệ quy một hàm gọi lại có tên là map()để đi qua các ô vuông theo một hướng nhất định. Mặc dù chúng tôi không thực sự cần nội dung của tham số thứ ba của cuộc gọi lại (mảng map()đã được gọi), tuy nhiên chúng tôi vẫn gián tiếp sử dụng nó để biết liệu đó có phải là lần lặp đầu tiên hay không.

Array.map (gọi lại hàm (currentValue [, index [, mảng]])

Đây là biến x trong mã.

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

— Arnauld
nguồn

8

Ốc , 14 byte

A
rdaa7\1\0+\1

Hãy thử trực tuyến!

Đầu vào là định dạng 0/1, không có khoảng trắng trong các dòng.

Ốc sên được tạo ra cho một thách thức PPCG phù hợp với thiết kế ngôn ngữ mẫu 2D . Quan trọng nhất, theo mặc định, nó xuất ra số lượng các trận đấu được tìm thấy, hoàn hảo cho thử thách này.

A đặt tùy chọn "tất cả các đường dẫn", để nếu một nữ hoàng ở nhiều cặp, thì mỗi cặp đó sẽ tạo ra một trận đấu.

rdaa7đặt hướng khớp với S, SE, E và NE. Đặt thành tất cả các hướng ( z) sẽ gây ra tính hai lần.

\1\0+\1khớp với a 1, rồi một hoặc nhiều 0s, rồi khác 1.

— TwiNight
nguồn

6

APL (Dyalog Classic) , 41 39 32 byte

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

Hãy thử trực tuyến!

≠⍨ là "không bằng chính nó" - một ma trận 8 số 0

⊢,≠⍨,⌽,≠⍨- nếu ma trận gốc là ABC..., biểu thức này trả về:

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⍴ định hình lại nó từ 8x32 đến 8x31, sử dụng lại các yếu tố theo thứ tự chính hàng:

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

⊢,⍉, chuẩn bị ma trận gốc và chuyển vị của nó (không gian thêm cho rõ ràng):

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⍪thêm 0 vào đầu và so sánh bằng cách sử dụng <mọi phần tử so với phần tử bên dưới nó, vì vậy chúng tôi nhận được 1 cho số 1 đứng đầu trong mỗi nhóm 1 số dọc và chúng tôi nhận được 0 ở mọi nơi khác

+⌿-⌈⌿ các tổng theo cột trừ đi cực đại theo cột - chúng tôi tính toán số lượng khoảng cách giữa các nhóm 1 trong mỗi cột, 0 nếu không có

+/ tổng

— ngn
nguồn

5

Thạch , 22 20 byte

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

Hãy thử trực tuyến!

— người dùng202729
nguồn

Cái này hoạt động ra sao?

— lirtosiast

@lirtosiast Tôi không nhớ ...

— user202729 27/11/18

@lirtosiast Liên kết đầu tiên đếm số cặp trong 1D, liên kết thứ hai lấy tổng của liên kết đầu tiên trên tất cả các dòng trong bảng.

— dùng202729

3

Võng mạc 0.8.2 , 60 58 byte

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

Hãy thử trực tuyến! Có đầu vào là 8 chuỗi nhị phân 8 ký tự được phân tách bằng dấu phẩy, nhưng tiêu đề sẽ chuyển đổi định dạng được cung cấp cho bạn. Giải trình:

1
¶1$';___¶

Tạo tất cả các chuỗi con của bảng bắt đầu từ một nữ hoàng. Hậu tố một giá trị đánh dấu cho mỗi chuỗi con. Chỉnh sửa: Đã lưu 2 byte bằng cách để lại một số chuỗi rác phía sau; những điều này được bỏ qua một cách hiệu quả.

_
$n$%`7$*_

Chia mỗi điểm đánh dấu thành một phạm vi bao gồm và thêm 7 vào các phần tử khác không.

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

Xóa mọi bước chạy của ký tự bằng với độ dài của điểm đánh dấu. Điều này tương đương với việc tìm kiếm từng tia đông, tây nam, nam hoặc đông nam từ mỗi nữ hoàng.

m`^10+1

Đếm tất cả các tia đi qua ít nhất một ô vuông trống trước khi gặp một nữ hoàng khác.

— Neil
nguồn

3

JavaScript (ES6) + SnakeEx , 38 byte

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

Đưa đầu vào theo mẫu '10111000\n10101011\n10101101\n01010100\n01100101\n10001000\n01000111\n01110101'. Hóa ra, SnakeEx vẫn có thể được sử dụng ngoài thử thách ban đầu của nó!

— LegionMammal978
nguồn

2

K (ngn / k) , 45 byte

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

Hãy thử trực tuyến!

— ngn
nguồn

Tấn công lẫn nhau

Thử thách

Các trường hợp thử nghiệm:

Python 2 , 105 byte

Giải trình

JavaScript (ES7), 86 byte

JavaScript (ES7), 89 byte

Làm sao?

Ốc , 14 byte

APL (Dyalog Classic) , 41 39 32 byte

Thạch , 22 20 byte

Võng mạc 0.8.2 , 60 58 byte

JavaScript (ES6) + SnakeEx , 38 byte

K (ngn / k) , 45 byte