26

एक 8x8 शतरंज को दो अलग-अलग मूल्यों से दर्शाया जाता है, जिसमें एक मान एक खाली वर्ग और दूसरा एक रानी होता है। निम्नलिखित उदाहरणों में, मैं 0s को खाली वर्ग के रूप में और 1s को रानियों के रूप में उपयोग करता हूं। उदाहरण के लिए:

द्वारा दिया गया है

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

उन रानियों के जोड़े की संख्या पर विचार करें जो प्रत्येक पर हमला कर रहे हैं जो कम से कम एक वर्ग की दूरी पर हैं (एक अनुस्मारक के रूप में, क्वीन्स orthogonally और तिरछे हमले करते हैं)। उपरोक्त उदाहरण में, निम्नलिखित अविश्वसनीय बदसूरत आरेख इन सभी जोड़े को तीर के रूप में दिखाता है।

निम्नलिखित परीक्षण मामले देने के ऊपर 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 आदि की सूची, जब तक कि यह आपके समाधान में समझाया गया है
आउटपुट एक पूर्णांक है
मानक I / O विधियां लागू होती हैं और मानक खामियों को मना किया जाता है
यह कोड गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है

परीक्षण के मामलों:

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

code-golf chess binary-matrix

— JMigst
स्रोत

मुझे अपना दूसरा संस्करण पोस्ट करने से पहले पूछना चाहिए: एक रानी के लिए २५४ और एक खाली वर्ग स्वीकार्य इनपुट मानों के लिए ० हैं?

— अरनौलद

@Arnauld आप उस प्रारूप में इनपुट कर सकते हैं जो सबसे अधिक सुविधाजनक है जो खाली वर्गों और रानियों का प्रतिनिधित्व करने के लिए दो मूल्यों का उपयोग करता है। तो यह सुनिश्चित करने के लिए ठीक है

— JMigst

धन्यवाद। मैंने पूछा क्योंकि मुझे लगता है कि अगर सचमुच लिया जाए तो यह नियम थोड़ा अधिक अनुमेय हो सकता है। मैं क्वीन्स के लिए JS कोड युक्त अधिकांश स्ट्रिंग पास करने के लिए कह सकता हूं और बस कार्यक्रम में उसका मूल्यांकन कर सकता हूं। (लेकिन यह एक डिफ़ॉल्ट खामियों को रोका जा सकता है। मुझे यकीन नहीं है।)

— अरनौल्ड

14

पायथन 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'। स्टेप स्लाइस का उपयोग करते हुए, हम अपने सामने आने वाली प्रत्येक रानी से चार "दृष्टि की रेखाएं" बनाते हैं। उदाहरण के लिए, जब मैं = 10 और डी = 7 , रानी को ♥ के रूप में चिह्नित करता हूं और टाइल्स b[i+d::d]को when के रूप में चुना जाता है :

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

रानियों की प्रत्येक जोड़ी को केवल एक बार जांचा जाता है, क्योंकि किरणों को हमेशा "पहले" रानी से "बाद में" एक से पढ़ने के क्रम में आगे बढ़ाया जाता है।

— लिन
स्रोत

10

जावास्क्रिप्ट (ईएस 7), 86 बाइट्स

एक रानी के लिए 254 और एक खाली वर्ग के लिए 0 के साथ 64 पूर्णांकों की एक सरणी के रूप में इनपुट लेता है ।

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

इसे ऑनलाइन आज़माएं!

यह संस्करण पुनरावर्ती भाग में एक स्टॉप स्थिति प्राप्त करने के लिए अंकगणितीय अंडरफ़्लो का दुरुपयोग करता है।

जावास्क्रिप्ट (ईएस 7), 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 [, index [, array]])

यह कोड में 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

— Arnauld
स्रोत

8

घोंघे , 14 बाइट्स

A
rdaa7\1\0+\1

इसे ऑनलाइन आज़माएं!

इनपुट 0/1 प्रारूप है, लाइनों के भीतर रिक्त स्थान के बिना।

घोंघे एक 2 डी पैटर्न मिलान भाषा डिजाइन पीपीसीजी चुनौती के लिए बनाए गए थे । सबसे महत्वपूर्ण बात, यह डिफ़ॉल्ट रूप से पाए गए मैचों की संख्या को आउटपुट करता है, जो इस चुनौती के लिए एकदम सही है।

A "ऑल पाथ्स" विकल्प सेट करता है, ताकि यदि एक रानी कई जोड़े में हो, तो उनमें से प्रत्येक जोड़ी एक मैच उत्पन्न करेगी।

rdaa7एस, एसई, ई और एनई के लिए मैच की दिशा निर्धारित करता है। सभी दिशाओं में सेट करने से zदोहरी गणना होगी।

\1\0+\1एक से मेल खाता है 1, फिर एक या अधिक 0एस, फिर एक और 1।

— TwiNight
स्रोत

6

एपीएल (डायलॉग क्लासिक) , ४१ ३ ९ ३२ बाइट्स

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

इसे ऑनलाइन आज़माएं!

≠⍨ "खुद के बराबर नहीं है" - एक 8x8 ऑल-जीरो मैट्रिक्स

⊢,≠⍨,⌽,≠⍨- यदि मूल मैट्रिक्स है 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⍪शीर्ष पर 0s जोड़ता है और <इसके नीचे के तत्व के खिलाफ प्रत्येक तत्व का उपयोग करने की तुलना करता है, इसलिए हमें 1s के प्रत्येक ऊर्ध्वाधर समूह में अग्रणी 1 के लिए 1 मिलता है, और हमें हर जगह 0s मिलता है

+⌿-⌈⌿ कॉलम द्वारा रकम अधिकतम कॉलम के हिसाब से घटाती है - हम हर कॉलम में 1-समूहों के बीच अंतराल की संख्या की गणना करते हैं, अगर कोई नहीं है

+/ योग

— NGN
स्रोत

5

जेली , 22 20 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— user202729
स्रोत

यह कैसे काम करता है?

— lirtosiast

@lirtosiast मुझे याद नहीं है ...

— user202729

@lirtosiast पहला लिंक 1D में जोड़े की संख्या को गिनता है, दूसरा लिंक तालिका में सभी लाइनों पर पहले लिंक का योग लेता है।

— user202729

3

रेटिना 0.8.2 , 60 58 बाइट्स

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

इसे ऑनलाइन आज़माएं! इनपुट को 8 अल्पविराम से अलग 8-वर्ण बाइनरी स्ट्रिंग्स के रूप में लेता है, लेकिन हेडर आपके लिए प्रदान किए गए प्रारूप को परिवर्तित करता है। स्पष्टीकरण:

1
¶1$';___¶

एक रानी से शुरू होने वाले बोर्ड के सभी सबस्ट्रिंग बनाएं। प्रत्येक प्रतिस्थापन के लिए एक मार्कर मूल्य प्रत्यय। संपादित करें: कुछ कचरे के तारों को पीछे छोड़कर 2 बाइट्स बचाए; इन्हें प्रभावी रूप से नजरअंदाज किया जाता है।

_
$n$%`7$*_

प्रत्येक मार्कर को एक समावेशी सीमा में विभाजित करें, और गैर-शून्य तत्वों में 7 जोड़ें।

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

मार्कर की लंबाई के बराबर वर्णों के प्रत्येक रन को हटा दें। यह प्रत्येक रानी से प्रत्येक पूर्व, दक्षिण-पश्चिम, दक्षिण या दक्षिण-पूर्व किरण को खोजने के बराबर है।

m`^10+1

किसी अन्य रानी से मिलने से पहले कम से कम एक खाली वर्ग से गुजरने वाली सभी किरणों की गणना करें।

— नील
स्रोत

3

JavaScript (ES6) + SnakeEx , 38 बाइट्स

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

फॉर्म में इनपुट लेता है '10111000\n10101011\n10101101\n01010100\n01100101\n10001000\n01000111\n01110101'। बाहर मुड़ता है, SnakeEx अभी भी अपनी मूल चुनौती के बाहर इस्तेमाल किया जा सकता है!

— LegionMammal978
स्रोत

2

K (ngn / k) , 45 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— NGN
स्रोत

पारस्परिक रूप से क्वींस पर हमला

चुनौती

परीक्षण के मामलों:

पायथन 2 , 105 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 7), 86 बाइट्स

जावास्क्रिप्ट (ईएस 7), 89 बाइट्स

कैसे?

घोंघे , 14 बाइट्स

एपीएल (डायलॉग क्लासिक) , ४१ ३ ९ ३२ बाइट्स

जेली , 22 20 बाइट्स

रेटिना 0.8.2 , 60 58 बाइट्स

JavaScript (ES6) + SnakeEx , 38 बाइट्स

K (ngn / k) , 45 बाइट्स