16

यदि आप नहीं जानते कि शतरंज में रानी क्या है, तो यह ज्यादा मायने नहीं रखता है; यह सिर्फ एक नाम है :)

आपका इनपुट कुछ रानियों की मनमानी चौड़ाई और ऊंचाई का एक वर्ग होगा । इनपुट बोर्ड इस तरह दिखेगा (इस बोर्ड की चौड़ाई और ऊंचाई 8 है):

...Q....
......Q.
..Q.....
.......Q
.Q......
....Q...
Q.......
.....Q..

इस बोर्ड पर 8 रानियां हैं। यदि यहां 7, या 1 या 10 कहते हैं, तो बोर्ड मान्य नहीं होगा।

यहां हम .एक खाली जगह के लिए उपयोग करते हैं, और Qएक रानी के लिए। वैकल्पिक रूप से, आप इसके बजाय किसी भी गैर-व्हाट्सएप चरित्र का उपयोग कर सकते हैं।

इस इनपुट को मान्य के रूप में सत्यापित किया जा सकता है, और आपको एक सत्य मान प्रिंट करना चाहिए (या वापस लौटना चाहिए (यदि यह मान्य नहीं था, तो आपको एक गलत मूल्य पर प्रिंट करना चाहिए या वापस लौटना चाहिए)। यह मान्य है क्योंकि कोई भी रानी एक ही पंक्ति, स्तंभ, विकर्ण या विरोधी-विकर्ण के रूप में नहीं है ।

उदाहरण (कोष्ठक में चीजों का उत्पादन न करें):

...Q....
......Q.
..Q.....
.......Q
.Q......
....Q...
Q.......
.....Q..

1

...Q.
Q....
.Q...
....Q
..Q..

0

Q.
Q.

0

..Q
...
.Q.

0 (this is 0 because there are only 2 queens on a 3x3 board)


..Q.
Q...
...Q
.Q..

1

Q

1 (this is valid, because the board is only 1x1, so there's no queen that can take another)

मुझे इस बात पर जोर देना चाहिए कि एक इनपुट केवल मान्य है, यदि कोई रानी एक ही पंक्ति में नहीं है, स्तंभ, विकर्ण या एक-दूसरे के खिलाफ विरोधी ।

नियम

आपको खाली इनपुट कभी नहीं मिलेगा
यदि इनपुट में बोर्ड के क्षेत्र के sqaure रूट की तुलना में कम क्वीन्स हैं, तो यह मान्य नहीं है।
ध्यान दें कि 2x2 या 3x3 बोर्ड के लिए कोई मान्य समाधान नहीं हैं, लेकिन हर दूसरे आकार के वर्ग बोर्ड के लिए एक समाधान है , जहां चौड़ाई और ऊंचाई एक प्राकृतिक संख्या है।
पीपीसीजी नियमों के अनुसार इनपुट किसी भी उचित प्रारूप में हो सकता है
इनपुट हमेशा एक sqaure होगा
मैंने उदाहरणों में 1 और 0 का उपयोग किया, लेकिन आप किसी भी सत्य या झूठे मूल्यों (जैसे कि Why yes, sir, that is indeed the caseऔर Why no, sir, that is not the case) का उपयोग कर सकते हैं

जैसा कि यह कोड-गोल्फ है , सबसे छोटा कोड जीतता है!

code-golf string decision-problem

— Okx
स्रोत

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— ओकेक्स

1

चाहेंगे {(x, y, v)}साथ vमें [., Q]एक वैध इनपुट प्रारूप हो सकता है?

— पीजययूग्डगस्ट

@DuctrTape मुझे नहीं लगता कि इससे कोई मतलब है।

— ओकेक्स

2

@ ओकेएक्स दूसरे शब्दों में, वे इनपुट के रूप में निर्देशांक और मूल्यों की एक सूची प्राप्त करने के बारे में पूछ रहे हैं। उदाहरण के लिए: (0, 0, Q), (0, 1, .), (1, 0, Q), (1, 1, .)तीसरा टेस्ट केस होगा।

— मेरागो

क्या मैं बिना किसी लाइनब्रेक के एक स्ट्रिंग ले सकता हूं?

— टाइटस

7

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

&
o.,\Q!(z.,\Q

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

2 डी निर्णय समस्या के लिए 2 डी पैटर्न मिलान भाषा की तरह कुछ भी नहीं। :)

व्याख्या

&पहली पंक्ति पर एक मैच मोड विकल्प है जो इनपुट में हर संभव स्थिति से मिलान करने के लिए दूसरी पंक्ति पर पैटर्न की आवश्यकता है। यदि ऐसा है, तो प्रोग्राम प्रिंट करता है 1, अन्यथा यह प्रिंट करता है 0।

पैटर्न के लिए ही, ध्यान दें कि )अंत में एक निहित है ।

o       ,, Move in any orthogonal direction (up, down, left or right).
.,\Q    ,, Make sure that there's a Q somewhere in that direction from the
        ,, starting position of the match.
!(      ,, After finding the Q, make sure that the following part _doesn't_ match:
  z     ,,   Move in any orthogonal or diagonal direction.
  .,\Q  ,,   Try to find another Q in a straight line.
)

यह कार्य नकारात्मक रूप से शुरू करके देखना सबसे आसान क्यों है: यह सुनिश्चित करके कि हमारे पास पहले Qसे कोई दूसरी लाइन नहीं Qहै, हम यह सुनिश्चित करते हैं कि एन क्वीन्स से अधिक नहीं हैं (अन्यथा, वहाँ होगा एक पंक्ति में दो होने के लिए, और यह संभव नहीं होगा कि इन रानियों को दूसरे को खोजे बिना पाया जाए)। फिर पहला भाग, यह सुनिश्चित करता है कि किसी भी स्थिति से एक रूढ़िवादी दिशा में एक रानी पहुंच रही है, यह सुनिश्चित करता है कि वास्तव में एन क्वीन्स हैं। यदि कोई लापता था, तो रानी के बिना एक पंक्ति और एक स्तंभ होगा। इन के चौराहे से शुरू करके, केवल एक ऑर्थोगोनल दिशा में जाकर एक रानी को ढूंढना संभव नहीं होगा।

— मार्टिन एंडर
स्रोत

6

जेली , 17 या 15 बाइट्स

ỴµUŒD;ŒD;ZVṀ;V=1Ṃ

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

‘एक रानी के लिए और ¹रिक्त स्थान के लिए उपयोग करता है। (यह ज्यादातर एक सरणी के रूप में इनपुट लेने पर प्रतिबंध का एक परिणाम है, क्योंकि यह इनपुट को स्ट्रिंग्स होने के लिए मजबूर करता है, स्ट्रगलर्स को पूर्णांक में परिवर्तित करना जेली में सबसे आसान विधि मूल्यांकन है, और यह 1 के बजाय यह पता चला है कि; 0, का उपयोग करते हुए "1 जोड़ने" ( ‘) और "0 जोड़ने" ( ¹) यह संभव कई योग को छोड़ देते हैं और नक्शा निर्देश, क्योंकि हम यह मूल्यांकन द्वारा एक सूची में क्वीन्स भरोसा कर सकते हैं कर सकते हैं।) truthy और falsey मान हैं जेली की सामान्य 1और 0।

संपादित करें: जब से मैंने मैट्रिक्स के रूप में इनपुट लेने की अनुमति देने के लिए यह उत्तर लिखा है, प्रश्न बदल दिया गया है। यह अग्रणी को छोड़ने की अनुमति देता है Ỵµ, जिससे 2 बाइट बचती हैं। यह संभवत: मूल्यांकन के Sबजाय योग के लिए इनपुट प्रारूप को कुछ और सामान्य रूप से बदलने की अनुमति देता है V, लेकिन मुझे नहीं लगता कि बाइट्स बचाता है और मैं इस तरह के फंकी प्रारूप को पसंद करता हूं।

व्याख्या

ỴµUŒD;ŒD;ZVṀ;V=1Ṃ
Ỵ                    Split on newlines.
 µ                   Set this value as the default for missing arguments.
     ;  ;            Concatenate the following three values:
  UŒD                - the antidiagonals;
      ŒD             - the diagonals;
         Z           - and the columns.
          V          Evaluate (i.e. count the queens on) all of those.
           Ṁ         Take the largest value among the results.
            ;V       Append the evaluation (i.e. queen count) of {each row}.
              =1     Compare each value to 1.
                Ṃ    Take the minimum (i.e. most falsey) result.

इसलिए मूल विचार यह है कि हम यह सुनिश्चित करते हैं कि प्रत्येक प्रतिपक्षी, विकर्ण और स्तंभ पर सबसे अधिक एक रानी हो; और प्रत्येक पंक्ति पर ठीक एक रानी। इन शर्तों को एक साथ करने के लिए पर्याप्त है कि प्रत्येक चार पंक्ति में से प्रत्येक पर एक रानी है, और बोर्ड की लंबाई के बराबर कई रानियां हैं।

संयोग से, जेली शायद अंतर्विरोधों के लिए एक अंतर्निर्मित के साथ कर सकती थी, लेकिन AFAICT में यह एक नहीं लगता है, इसलिए मुझे बोर्ड को प्रतिबिंबित करने और फिर विकर्णों को लेने के लिए व्यवस्थित करने की आवश्यकता है।

एक और दिलचस्प नोट यह है कि (सभी बराबर) =1Ṃको बदलने से Eएक सामान्यीकृत n -queens चेकर मिलता है, जो एक n × n बोर्ड को भी स्वीकार करेगा जहां प्रत्येक पंक्ति, स्तंभ, विकर्ण और एंटीडिओगल में k क्वीन्स से अधिक नहीं होता है , और बोर्ड में बिल्कुल शामिल होता है घुटने वाली रानी। 1 के बराबर कश्मीर को प्रतिबंधित करना वास्तव में दो बाइट्स का खर्च है।

नियम अपडेट किए गए थे, अब "इनपुट किसी भी उचित प्रारूप में हो सकता है, पीपीसीजी नियमों के अनुसार", जो इसे कम कर देना चाहिए :) EDIT - मुझे लगता है कि आपने इसे नोट किया है।

— जोनाथन एलन

5

ऑक्टेव, 57 70 67 51 52 बाइट्स

@LuisMendo के लिए धन्यवाद के flipबजाय 1 बाइट का उपयोग करके rot90सहेजा गया, लेकिन 1x1 मामले पर एक बग मिला

@(A)all(sum([A A' (d=@spdiags)(A) d(flip(A))],1)==1)

एक बाइनरी मैट्रिक्स के रूप में इनपुट लेता है 1 एक रानी का प्रतिनिधित्व करता है और 0 एक खाली स्थान का प्रतिनिधित्व करता है।

एक अनाम फ़ंक्शन बनाता है जो सबसे पहले इनपुट मैट्रिक्स और उसके स्थानान्तरण को समाप्‍त करता है।

spdiagsतर्क के रूप में समान पंक्तियों के साथ एक मैट्रिक्स बनाता है, विकर्णों को कॉलम (आवश्यक के रूप में शून्य-गद्देदार) में बदल दिया जाता है, इसलिए spdiagsविकर्ण प्राप्त करने के लिए इनपुट मैट्रिक्स spdiagsका अधिवृक्क और मैट्रिक्स को एंटीडिओग्नल प्राप्त करने के लिए क्षैतिज रूप से फ़्लिप किया जाता है।

अब संघटित मैट्रिक्स के प्रत्येक कॉलम का योग लें और सुनिश्चित करें कि प्रत्येक कॉलम ठीक 1 है।

नमूना विचारधारा पर चलता है ।

— बीकर
स्रोत

मुझे लगता है कि आप उपयोग कर सकते हैं flipके बजायrot90

— लुइस Mendo

@LuisMendo हां, वह भी काम करेगा। धन्यवाद!

— बीकर

इसके अलावा, आप से बचने नहीं कर सकते all()?

— लुइस मेन्डो

@LuisMendo ऊ ... शायद ... लेकिन रात के खाने के बाद तक इंतजार करना होगा;)

— बीकर

4

MATL , 38 34 बाइट्स

@ बकेर के लिए धन्यवाद 4 बाइट्स !

sG!sGt&n_w&:&XdsGP5M&Xdsv2<GnGzU=*

इनपुट शून्य और लोगों का एक 2 डी सरणी है, जो सेमीकोलन को पंक्ति विभाजक के रूप में उपयोग करता है।

यह सत्य के रूप में लोगों के एक कॉलम वेक्टर को आउटपुट करता है, और एक कॉलम वेक्टर को कम से कम एक शून्य के रूप में गलत माना जाता है।

इसे ऑनलाइन आज़माएं! पाद लेख कोड ifसच्चाई या मिथ्यात्व को प्रदर्शित करने के लिए एक शाखा है।

या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

s      % Input binary matrix implicitly. Sum of columns. Gives a row vector
G!     % Paste input again. Transpose
s      % Sum of columns (rows in the original matrix). Gives a row vector
G      % Paste input again
t&n    % Duplicate. Push number of rows and number of columns (will be equal)
_w     % Negate, flip
&:     % Binary range. Gives [-n -n+1 ... n] for input of size n×n
&Xd    % Get diagonals -n through n. This gives all diagonals as colums
s      % Sum of each column (diagonals of original matrix). Gives a row vector
GP     % Paste input again. Flip vertically
5M     % Push [-n -n+1 ... n] again
&Xd    % Get diagonals -n through n (anti-diagonals of original matrix)
s      % Sum of each column. Gives a row vector
v      % Concatenate everything into a column vector
2<     % True for elements that are less than 2
Gn     % Paste input again. Number of elements
Gz     % Paste input again. Number of nonzeros (i.e. of queens)
U      % Square
=      % True if equal
*      % Mutiply, element-wise

— लुइस मेंडो
स्रोत

अब आप 2 बाइट्स बचा सकते हैं ताकि आप इनपुट के रूप में एक बाइनरी मैट्रिक्स ले सकें।

— बीकर

2

जे , 37 बाइट्स

(+/&,=#)*1=[:>./+//.,+//.&|.,+/,+/&|:

अनाम फ़ंक्शन ट्रेन जो बूलियन मैट्रिक्स को तर्क के रूप में लेती है।

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

( +/योग &का ,फैलना= के बराबर होती है #पंक्तियों की संख्या)

* और (जलाई बार)

1एक =बराबर [:है>./ की अधिकतम

+/रकम /.तिरछे, और (lit. catenated to)

+/रकम /.तिरछे &की |.रिवर्स, और

+/ रकम भर में , और

+/रकम &की |:पक्षांतरित

— एडम
स्रोत

2

स्नेकएक्स। , 67 बाइट्स

m:({q<>}({q<R>}[{q<RF>}{n<RF>}].)*{e<>}<R>)%{4}
e:.$
q:_*Q_*$
n:_+$

के _स्थान पर उपयोग करता है.इनपुट के । सत्य के लिए 1 या अधिक मैच लौटाता है, 0 मैच फ़ालसे के लिए होता है। आप शीर्ष लेख में लिंक पर एक ऑनलाइन दुभाषिया पा सकते हैं।

व्याख्या

SnakeEx 2-D पैटर्न मिलान चुनौती से एक भाषा है । यह "सांपों" को परिभाषित करता है जो ग्रिड मिलान वाले सामान के चारों ओर घूमते हैं। सांप अन्य सांपों को पाल सकते हैं, जिससे भाषा काफी शक्तिशाली हो जाएगी।

आइए नीचे से ऊपर इस कार्यक्रम को देखें।

n:_+$

यह एक सांप को परिभाषित करता है nजो 1 या अधिक अंडरस्कोर और फिर ग्रिड के किनारे से मेल खाता है। ध्यान दें कि यह 8 कार्डिनल दिशाओं में से किसी में भी हो सकता है - दिशा निर्धारित की जाती है जब सांप को देखा जाता है।

q:_*Q_*$

nऊपर के समान , यह qएक साँप के रूप में परिभाषित होता है जो किसी भी संख्या में अंडरस्कोर, एक एकल Q, किसी भी संख्या में अंडरस्कोर और ग्रिड के किनारे से मेल खाता है । दूसरे शब्दों में, एक पंक्ति / स्तंभ / विकर्ण जिसमें केवल एक रानी होती है।

e:.$

e एक सांप है जो एक पात्र और ग्रिड के किनारे से मेल खाता है।

m:({q<>}({q<R>}[{q<RF>}{n<RF>}].)*{e<>}<R>)%{4}

मुख्य सांप m पूरे बोर्ड की जांच के लिए इन बिल्डिंग ब्लॉक्स का उपयोग करता है। वैचारिक रूप से, यह ग्रिड के बाहरी किनारों के आसपास चलता है, अन्य सांपों की जाँच करने के लिए कि सभी स्तंभों और पंक्तियों में बिल्कुल एक रानी है, और सभी विकर्णों में सबसे अधिक एक रानी है। यदि कोई भी स्पैन्स्ड सांप मैच नहीं करता है, तो पूरा मैच फेल हो जाता है। चलो इसे तोड़ दो।

( )%{4}प्रत्येक पक्ष के लिए, 4 बार कोष्ठक के अंदर क्या चलता है। (किस प्रकार, यह किसी विशेष पक्ष को कहने के लिए सहायक है - कहते हैं, ग्रिड के ऊपरी किनारे, ऊपर के बाएं कोने से शुरू होकर दाएं चलते हैं।)
{q<>}qसांप को उसी दिशा में घुमाता है जिस दिशा में मुख्य सांप घूम रहा होता है। यह सत्यापित करता है कि वर्तमान किनारा "बिल्कुल एक रानी" नियम से मिलता है। ध्यान दें कि सांपों के सांप मुख्य सांप के मैच पॉइंटर को स्थानांतरित नहीं करते हैं, इसलिए हम अभी भी किनारे की शुरुआत में हैं।
( )* कोष्ठक के अंदर क्या है, 0 या उससे अधिक मेल खाता है।
{q<R>}qमुख्य साँप के निर्देशन में एक साँप दाएं मुड़ता है। (जैसे यदि मुख्य साँप ऊपरी किनारे के साथ दाईं ओर घूम रहा है, तो यह साँप नीचे की ओर बढ़ता है।) यह प्रत्येक स्तंभ / पंक्ति की जाँच करता है।
[ ] कोष्ठक के अंदर किसी एक विकल्प से मेल खाता है:
- {q<RF>}spawns एक qसाँप 45 डिग्री दाहिनी ओर (यानी दिया Right और Fमुख्य सांप की दिशा से orward)। qसाँप से मेल खाता है विकर्ण ठीक एक रानी है या नहीं।
- {n<RF>}nइसके बजाय एक सांप पैदा करता है । nसाँप मेल खाता है तो विकर्ण कोई क्वीन्स में शामिल है।
. किसी भी पात्र से मेल खाता है, मैच पॉइंटर को आगे बढ़ाता है।
यथासंभव कई क्षैतिज और विकर्णों की जांच करने के बाद, हम यह सत्यापित करते हैं कि हम किनारे पर हैं {e<>}।
अंत में, <R>मुख्य साँप को दाएं मुड़ता है, अगले किनारे से मेल खाने के लिए तैयार।

अजीब चीजें

यह सुनिश्चित करने के लिए कार्यक्रम में कुछ भी नहीं है कि मिलान एक बाहरी कोने से शुरू होता है। वास्तव में, सत्य परीक्षण मामलों में कई मैच निकलते हैं, जिनमें से कुछ कहीं न कहीं अंदर से शुरू होते हैं। इसके बावजूद, मैंने जितने भी झूठे मामले दर्ज किए हैं उनमें से कोई भी झूठी सकारात्मकता उत्पन्न नहीं करता है।
अगर मैं भाषा की युक्ति सही पढ़ रहा हूं , तो मुझे इसके स्थान पर X(सभी विकर्ण दिशाओं में शाखा) का उपयोग करने में सक्षम होना चाहिए RF। दुर्भाग्य से, ऑनलाइन दुभाषिया ने कहा कि एक वाक्यविन्यास त्रुटि थी। मैंने भी कोशिश की *(सभी दिशाओं में शाखा), लेकिन उस दुभाषिए को लटका दिया।
सैद्धांतिक रूप से, कुछ _*Q?_*$को विकर्णों में "अधिकतम एक रानी" के लिए काम करना चाहिए, लेकिन यह भी दुभाषिया लटका दिया। मेरा अनुमान है कि खाली मैचों की संभावना समस्याओं का कारण बनती है।

— DLosc
स्रोत

2

रूबी, 120 बाइट्स

एक स्ट्रिंग के रूप में इनपुट के लिए आवश्यक मूल कल्पना पर आधारित लैम्ब्डा फ़ंक्शन।

->s{t=k=0
a=[]
s.bytes{|i|i>65&&(a.map{|j|t&&=((k-j)**4).imag!=0};a<<k)
k=i<11?k.real+1:k+?i.to_c}
t&&~a.size**2>s.size}

Q की जटिल संख्याओं में परिवर्तित करता है और उन्हें एक दूसरे से घटाता है। यदि किसी भी दो रानियों के निर्देशांक के बीच का अंतर क्षैतिज, ऊर्ध्वाधर या विकर्ण है, तो इसे 4 वीं शक्ति तक बढ़ाने से वास्तविक संख्या प्राप्त होगी और व्यवस्था अमान्य है।

परीक्षण कार्यक्रम में अपराजित

f=->s{                                 #Take input as string argument.
  t=k=0                                #k=coordinate of character. t=0 (truthy in ruby.)
  a=[]                                 #Empty array for storing coordinates.
  s.bytes{                             #Iterate through all characters as bytes.
    |i|i>65&&(                         #If alphabetical, compare the current value of k to the contents of a
      a.map{|j|t&&=((k-j)**4).imag!=0} #If k-j is horizontal, vertical or diagonal, (k-j)**4 will be real and t will be false
      a<<k)                            #Add the new value of k to the end of a.
    k=i<11?k.real+1:k+?i.to_c          #If not a newline, increment the imaginary part of k. If a newline, set imaginary to 0 and increment real
  }                                    #s.size should be a*a + a newlines. ~a.size = -1-a.size, so ~a.size**2 = (a.size+1)**2
t&&~a.size**2>s.size}                  #compare a.size with s.size and AND the result with t. Return value. 


p f["...Q....
......Q.
..Q.....
.......Q
.Q......
....Q...
Q.......
.....Q.."]

p f["...Q.
Q....
.Q...
....Q
..Q.."]

p f["Q.
Q."]

p f["..Q
...
.Q."]

p f["..Q.
Q...
...Q
.Q.."]

p f["Q"]

— स्तर नदी सेंट
स्रोत

2

पायथन 3 , 232 200 155 बाइट्स

d=1
f=input()
Q=[]
for i in f:d=[0,d][i.count('Q')==1];Q+=[(len(Q),i.index('Q'))]
print[0,d][sum(k[1]==i[1]or sum(k)==sum(i)for k in Q for i in Q)==len(Q)]

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

-32 बाइट्स इनपुट विनिर्देशों में बदलाव की सूचना @beaker के लिए धन्यवाद; मैंने पायथन 3 से 2 में भाषा बदल दी है, इस प्रकार मुझे उपयोग करने की अनुमति हैinput इनपुट स्ट्रिंग्स की एक सरणी या चरित्र सरणियों के एक सरणी के रूप ।

-45 बाइट्स थैंक्स टू @Leaky नन

— HyperNeutrino
स्रोत

इनपुट आवश्यकताओं में ढील दी गई है, अगर इससे आपको कोई मदद मिलती है।

— बीकर

@ बीकर ठीक है, धन्यवाद। मैं बदले में एक सरणी के रूप में इनपुट लूंगा। यह बात बताने के लिए धन्यवाद!

— हाइपरनेत्रिनो

157 बाइट्स

— लीक नन

1

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

a=>!a.some((b,i)=>b.some((q,j)=>q&&h[i]|v[j]|d[i+j]|e[i-j]|!(h[i]=v[j]=d[i+j]=e[i-j]=1))|!h[i],h=[],v=[],d=[],e=[])

Ungolfed:

function queens(arr) {
    horiz = [];
    vert = [];
    diag = [];
    anti = [];
    for (i = 0; i < arr.length; i++) {
        for (j = 0; j < arr.length; j++) {
            if (arr[i][j]) { // if there is a queen...
                if (horiz[i]) return false; // not already on the same row
                if (vert[j]) return false; // or column
                if (diag[i + j]) return false; // or diagonal
                if (anti[i - j]) return false; // or antidiagonal
                horiz[i] = vert[j] = diag[i + j] = anti[i - j] = true; // mark it
            }
        }
        if (!horiz[i]) return false; // fail if no queen in this row
    }
    return true;
}

— नील
स्रोत

0

रूबी, 155 बाइट्स

->x{(y=x.map{|r|(i=r.index ?Q)==r.rindex(?Q)?i:p or-2}).zip(y.rotate).map.with_index{|n,i|n.max-n.min==1&&i<y.size-1?-2:n[0]}.inject(:+)*2==(s=x.size)*~-s}

यह पढ़ने के लिए भयानक है, इसलिए मुझे नीचे थोड़ा कम गोल्फ वाला संस्करण मिला है

->x{
    (y=x.map{|r|(i=r.index ?Q)==r.rindex(?Q)?i:p or-2})
    .zip(y.rotate)
    .map.with_index{|n,i|n.max-n.min==1&&i<y.size-1?-2:n[0]}
    .inject(:+)*2==(s=x.size)*~-s
}

यह वही कोड है, लेकिन जो कुछ हो रहा है उसे अलग करने के लिए कुछ नई कहानियों के साथ।

कोड स्वयं एक अनाम लंबो फ़ंक्शन है जो स्ट्रिंग्स की एक सरणी लेता है (x प्रारूप में )["..Q", "Q..", ".Q."] ।

पहली पंक्ति उस स्ट्रिंग में Q वर्ण के सूचकांक में प्रत्येक स्ट्रिंग को मैप कर रही है। यदि कोई Q वर्ण नहीं है, तो इसे -2 ^{1 से} बदल दिया जाता है । सूचकांकों के इस नए सरणी को चर को सौंपा गया है y।

अगली पंक्ति सूचकांकों के इस सरणी को अपने आप में एक (घुमाए हुए) से ऑफसेट करती है। यह लगातार सूचकांकों के जोड़े की एक सरणी में परिणाम करता है।

अगली पंक्ति विशेष रूप से जटिल है। यह सूचकांकों के प्रत्येक जोड़े के माध्यम से जाता है, और बड़े से छोटे को घटाता है। यदि यह 1 है (और हम अंतिम जोड़ी ² पर नहीं हैं ), तो दो कतारें हैं जो एक ही विकर्ण पर हैं, और -2 का मान डाला जाता है, अन्यथा स्ट्रिंग में रानी का मूल सूचकांक डाला जाता है ।

अंतिम पंक्ति प्रत्येक के लिए सभी अनुक्रमितों को जमा करती है और यह देखने के लिए जांचती है कि क्या यह n-1 के लिए त्रिकोण संख्या है, जहां n वर्ग की चौड़ाई (या ऊंचाई) है।

1: -1 मेरा गो-टू होगा, लेकिन यह 0 से अलग है, इसलिए विकर्णों की जाँच के साथ गड़बड़ होगी। अंतिम राशि को गलत बनाने के लिए इसका नकारात्मक-नेस महत्वपूर्ण है। मैंने 9 की तरह एक उच्च संख्या (एकल अंकों के साथ) के बारे में सोचा, लेकिन मुझे यकीन नहीं हो सकता है कि एक गलत सत्यापन का परिणाम नहीं होगा।
2: बोर्ड गोल लपेटता नहीं है, जबकि रूबी की rotateसरणी फ़ंक्शन करती है, और अगर अंतिम जोड़ी एक से भिन्न होती है तो कोई फर्क नहीं पड़ता - यह एक विकर्ण नहीं है।

— IMP1
स्रोत

0

PHP, 137 143 बाइट्स

नील के समाधान से प्रेरित है

for($n=1+strlen($s=$argv[1])**.5|0;($c=$s[$p])&&!(Q==$c&&$v[$x=$p%$n]++|$h[$x=$p/$n]++|$d[$y-$x]++|$a[$y+$x]++);$p++);echo$n-1==count($a)&&!$c;

पहली कमांड लाइन तर्क से इनपुट लेता है; साथ चलाना -r। सिंगल बाइट लाइन ब्रेक की आवश्यकता है।
^{वास्तव में आप किसी भी चरित्र का उपयोग कर सकते हैं लेकिन 0लाइन ब्रेक के लिए।}
सच ( 1) या गलत (खाली स्ट्रिंग) प्रिंट करता है ।

टूट - फूट

for($n=1+strlen($s=$argv[1])**.5|0; // copy input to $s, $n=size+1 (for the linebreak)
    ($c=$s[$p])&&!(                 // loop through characters
        Q==$c&&                         // if queen: test and increment lines
            $v[$x=$p%$n]++|$h[$x=$p/$n]++|$d[$y-$x]++|$a[$y+$x]++
    );                                  // break if a line had been marked before
    $p++);
echo$n-1==count($a)             // print result: true for $n-1(=size) marks
    &&!$c;                      // and loop has finished

— टाइटस
स्रोत

0

पायथन 3 , 185 176 175 172 171 बाइट्स

lambda x,c=lambda x:x.count("Q")==1:all([*map(c,x+[[l[i]for l in x]for i in range(len(x[0]))])])*~any(map(lambda s:"Q%sQ"%(s*".")in"".join(x),[len(x[0]),len(x[0])-2]))==-1

एक अज्ञात फ़ंक्शन इनपुट के रूप में तार की एक सूची ले रहा है।

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

lambda x:all([a.count("Q")==1for a in x]+[[l[i]for l in x].count("Q")==1for i in range(len(x[0]))]+[all(map(lambda s:"Q%sQ"%(s*".")not in"".join(x),[len(x[0]),len(x[0])-2]))])

— Trelzevir
स्रोत

रानियों की पहेली को सत्यापित करें

उदाहरण (कोष्ठक में चीजों का उत्पादन न करें):

नियम

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

व्याख्या

जेली , 17 या 15 बाइट्स

व्याख्या

ऑक्टेव, 57 70 67 51 52 बाइट्स

MATL , 38 34 बाइट्स

व्याख्या

जे , 37 बाइट्स

स्नेकएक्स। , 67 बाइट्स

व्याख्या

अजीब चीजें

रूबी, 120 बाइट्स

पायथन 3 , 232 200 155 बाइट्स

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

रूबी, 155 बाइट्स

PHP, 137 143 बाइट्स

पायथन 3 , 185 176 175 172 171 बाइट्स