8x8'lik bir satranç tahtasının herhangi iki farklı değerle temsil edilmesine izin verin; biri boş bir kare, diğeri ise kraliçe. Aşağıdaki örneklerde, boş kareler olarak 0'ları ve kraliçe olarak 1'leri kullanıyorum. Örneğin:

tarafından verilir

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

En az bir kare uzaklıktaki her birine saldıran kraliçe çiftlerinin sayısını düşünün (hatırlatma olarak, kraliçe ortogonal ve çapraz olarak saldırır). Yukarıdaki örnekte, aşağıdaki inanılmaz çirkin diyagram tüm bu çiftleri oklar olarak göstermektedir.

Aşağıdaki test olayını veren yukarıda bulunan 43 çift bulunmaktadır:

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

Meydan okuma

İki farklı değerle temsil edilen bir yönetim kurulu durumu göz önüne alındığında, aralarında en az bir kare olacak şekilde birbirlerine saldıran kraliçe çiftlerinin sayısını veren bir program yazın.

• Boş kareleri ve kraliçeleri temsil etmek için iki değer kullanan en uygun formatı girin; örneğin, boş kareler için 64 "." S, alttan üste, 8x8. boolean matrisi, çözümünüzde açıklandığı sürece 0 ve 1 tamsayılarının bir listesi.
• Çıktı bir tamsayıdır
• Standart G / Ç yöntemleri uygulanır ve standart boşluklar yasaktır
• Bu kod golf, bayt cinsinden en kısa cevap kazanır

Test durumları:

0 ve 1 formatlarını kullanarak, 0 boş kareler ve 1 kraliçelerdir:

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 bayt

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

Çevrimiçi deneyin!

açıklama

Biz 64 karakterden oluşan bir dize olarak girdi almak '0'veya '1'. Adım dilimlerini kullanarak karşılaştığımız her kraliçeden dört "görüş hattı" koyduk. Örneğin, i = 10 ve d = 7 olduğunda , kraliçeyi ♥ ve b[i+d::d]█ olarak seçilen karoları işaretleyin :

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

Açıkçası, aslında tahtaya böyle sarılmak için vizyon istemiyoruz. Bu yüzden tahtanın kenarının ne kadar uzakta olduğunu her yönden hesaplıyoruz ve döşemeleri görüyoruz b[i+d::d][:…].

Her kiremit yönü çifti için şunları sayarız:

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

Bu ne zaman başarısız olur

• cbir kraliçe değil; veya
• bu ışının gördüğü kraliçe çok yakın ( find0 döndürür); veya
• bu ışın kraliçeyi görmez ( find−1 döndürür).

Işınları hep döküm çünkü kraliçelerin her bir çifti, bir kez kontrol okunur ileri bir "daha sonra" birine bir "erken" kraliçe gelen, okuma sırasına göre.

JavaScript (ES7), 86 bayt

Bir kraliçe için 254 ve boş bir kare için 0 olan 64 tamsayı dizisi olarak girdi alır .

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

Çevrimiçi deneyin!

Bu sürüm, özyinelemeli bölümde bir durma koşulu elde etmek için aritmetik akışı kötüye kullanır.

JavaScript (ES7), 89 bayt

64 bitlik bir dizi olarak girdi alır.

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

Çevrimiçi deneyin!

Nasıl?

map()Kareleri belli bir yöne yürümek için adlandırılmış bir geri çağırma işlevini tekrar tekrar çağırırız . Geri çağrının üçüncü parametresinin içeriğine gerçekten ihtiyacımız olmasa da (dizi map()çağrıldı), ilk yinelemenin olup olmadığını bilmek için yine de dolaylı olarak kullanıyoruz.

arr.map (function geri çağırma (currentValue [, index [, array]])

Bu, koddaki x değişkenidir.

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

Salyangozlar , 14 bayt

A
rdaa7\1\0+\1

Çevrimiçi deneyin!

Giriş, 0/1 formatıdır, satırlar içinde boşluklar yoktur.

Salyangoz bir 2D desen eşleştirme dil tasarımı PPCG meydan okuma için oluşturuldu . En önemlisi, varsayılan olarak, bu zorluk için mükemmel olan bulunan eşleşme sayısını gösterir.

A "tüm yollar" seçeneğini belirler, böylece bir kraliçe birden fazla çiftlikte ise, bu çiftlerin her biri bir eşleşme oluşturur.

rdaa7eşleşme yönünü S, SE, E ve NE olarak ayarlar. Tüm yönlere ( z) ayarlamak çift ​​sayıma neden olur.

\1\0+\1a ile eşleşir 1, sonra bir veya daha fazla 0s, sonra başka 1.

APL (Dyalog Classic) , 41 39 32 bayt

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

Çevrimiçi deneyin!

≠⍨ "kendisine eşit değil" - 8x8 değerinde sıfır matris

⊢,≠⍨,⌽,≠⍨- Eğer orijinal matris ise ABC..., bu ifade:

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⍴ Elemanı satır ana sırada yeniden kullanarak 8x32'den 8x31'e yeniden şekillendirir:

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

⊢,⍉, orijinal matrisi ve transpozisyonunu hazırlar (netlik için fazladan boşluklar):

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⍪üstüne 0s ekler ve <her öğeyi altındaki öğeye karşı karşılaştırır , böylece her dikey gruptaki ilk 1 için 1 alırız ve her yerde 0s alırız

+⌿-⌈⌿ sütuna göre toplamlar eksi sütuna göre maksima - eğer varsa, her sütunda 1 grup arasındaki boşluk sayısını, 0 ise hesaplarız.

+/ toplam

Jöle , 22 20 bayt

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

Çevrimiçi deneyin!

Retina 0.8.2 , 60 58 bayt

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

Çevrimiçi deneyin! 8 virgülle ayrılmış 8 karakterli ikili dizeler olarak girdi alır, ancak başlık sizin için sağlanan biçimi dönüştürür. Açıklama:

1
¶1$';___¶

Bir kraliçeden başlayarak bütün tahta altlıklarını oluşturun. Her alt dizeye bir marker değeri ekleyiniz. Düzenleme: Arkasında bazı çöp dizeleri bırakarak 2 bayt kaydedildi; bunlar etkin bir şekilde göz ardı edilir.

_
$n$%`7$*_

Her işaretçiyi kapsayıcı bir aralığa bölün ve sıfır olmayan öğelere 7 ekleyin.

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

İşaretçinin uzunluğuna eşit olan her karakter çalışmasını silin. Bu, her kraliçeden doğu, güneybatı, güney veya güneydoğu ışını bulmakla eşdeğerdir.

m`^10+1

Başka bir kraliçeyle görüşmeden önce en az bir boş kareden geçen tüm ışınları sayın.

JavaScript (ES6) + SnakeEx , 38 bayt

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

Formdaki girişi alır '10111000\n10101011\n10101101\n01010100\n01100101\n10001000\n01000111\n01110101'. Görünen o ki, SnakeEx hala asıl mücadelesinin dışında da kullanılabilir!

K (ngn / k) , 45 bayt

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

Çevrimiçi deneyin!