एन क्वीन्स, एक्स द्वारा वाई बोर्ड निर्णय समस्या साक्षात्कार प्रश्न

Question

मुझे आज एक साक्षात्कार में निम्नलिखित प्रश्न पूछा गया था और मैं तब से इसके बारे में सोच रहा हूं। मैं इसका जवाब नहीं दे पा रहा था और ऑनलाइन समाधान नहीं पा रहा था।

Y और N रानियों द्वारा एक्स के साथ एक शतरंज बोर्ड को देखते हुए, निर्धारित करें कि क्या इन रानियों को बोर्ड पर व्यवस्थित करना संभव है, जैसे कि वे एक दूसरे पर हमला नहीं कर सकते।

2 रानियों के साथ 2 x 3 बोर्ड में एक समाधान होता है ताकि एल्गोरिथ्म सही हो जाए:

Q . .
. . Q

मैं इस पहेली के लिए एक प्रोग्रामिंग दृष्टिकोण की तलाश कर रहा हूं, न कि केवल कागज पर इसे हल करने के तरीके।

Comments

बेस्ट फर्स्ट सर्च निश्चित रूप से एक विकल्प है, जैसा कि अन्य खोज के आंकड़े हैं

— जेसन

अब तक के सबसे खराब साक्षात्कार प्रश्नों में से एक के लिए नामांकित - जब तक कि वे जिस सॉफ्टवेयर पर काम करते हैं, वह बैकग्राउंडिंग सॉल्यूशंस पर निर्भर करता है, इस स्थिति में यह पूरी तरह से प्रासंगिक है

— स्टीवन ए। लोवे

निष्पक्ष होने के लिए साक्षात्कारकर्ता ने कहा कि यह केवल एक अतिरिक्त क्रेडिट की चीज थी। बाकी साक्षात्कार बहुत वैध IMO था। मैं बिलकुल उत्सुक था।

— इंटरव्यू

हो सकता है कि यह एक परीक्षा थी यदि वह अपने उत्तर में कालेब द्वारा बताए गए तथ्यों का उपयोग करके बैकट्रैकिंग या (खोजने के बारे में सोचें) ओ (1) समाधान के साथ एक अनुकरण करेगा। साधारण चीजों को प्रोग्राम करने की क्षमता वह सब कुछ नहीं है जो नौकरी में चाहिए।

— Sopel

होमवर्क असाइनमेंट स्पष्ट रूप से यहां दायरे से बाहर हैं।

— जॉइंटिंग सेप

Answer 1

यह (IMO) प्रोग्रामिंग की दृष्टि से बहुत दिलचस्प समस्या नहीं है। आप एक पुनरावर्ती एल्गोरिदम के साथ आ सकते हैं जो हर व्यवस्था की कोशिश करता है, कुछ इस तरह से:

bool try_queens(Board board, int n)
{
    if (n == 0) {
        // no queens left to place, so we're done
        return true
    }
    // try each open position until we find one that works
    for each position on the board {
        if (is_empty(board, position) and not is_attacked(board, position)) {
            place_queen(board, position)
            if (try_queens(board, n-1)) {
                return true
            }
            remove_queen(board, position)
        }
    }
    // if we get this far, there's no available position
    return false
}

main()
{
    initialize board(X,Y)
    return try_queens(board, N)
}

यदि आप समस्या के बारे में थोड़ा सोचते हैं, तो आप महसूस करेंगे कि किसी बोर्ड पर N क्वीन्स को फिट करने का कोई तरीका नहीं है जहाँ X <N या Y <N है क्योंकि इसके लिए कम से कम दो रानियों को एक ही रैंक या फ़ाइल में समाप्त होने की आवश्यकता होगी। और इसलिए वे एक दूसरे पर हमला करेंगे। यदि आप n- क्वीन्स समस्या के बारे में पढ़ते हैं, तो आप जल्दी से जानेंगे कि N> 3. के लिए NxN बोर्ड पर N रानियों को रखना हमेशा संभव है। अब हम जानते हैं कि इसका उत्तर NO (X <N या Y <N) है। और YES के लिए (X> = N और Y> = N, N> 3)। जो कुछ बचा है वह विशेष मामले हैं:

• N = 1 (YES)
• N = 2 (X> = 2 और Y> 2 या इसके विपरीत के लिए YES)
• N = 3 (X के लिए YES = 3 और Y> 3 या इसके विपरीत)

तो अब हमारा अच्छा पुनरावर्ती कार्य एक सरल कार्य बन जाता है जो सिर्फ N से X और Y की तुलना करता है और डिब्बाबंद परिणाम देता है। प्रदर्शन के दृष्टिकोण से यह बहुत अच्छा है, क्योंकि आपको निरंतर समय में उत्तर मिल सकता है। यह एक प्रोग्रामिंग दृष्टिकोण से बहुत अच्छा नहीं है क्योंकि आप इस बिंदु पर महसूस करते हैं, कि यह सवाल वास्तव में अधिक है कि आप पहेली को कैसे सुलझा सकते हैं क्योंकि यह एक पुनरावर्ती फ़ंक्शन लिखने की आपकी क्षमता के बारे में है।

(और लड़का ओह बॉय, मैं वास्तव में आशा करता हूं कि मैंने अपने स्मार्टी-पैंट उत्तर में कुछ गूंगा गलती नहीं की; ;-)

Comments

That's great from a performance point of view, since you can get an answer in constant time. It's not so great from a programming point of view because you realize, at this point, that the question is really more about how well you can solve puzzles than it is about your ability to write a recursive function.मुझे वास्तव में लगता है कि साक्षात्कारकर्ता उस ओ (1) समाधान की प्रतीक्षा कर रहा था क्योंकि यह अंततः कई लोगों के लिए बेहतर और स्पष्ट नहीं है। Nxn रानी समस्या पुनरावृत्ति के लिए एक एक्सर्साइज़ के रूप में सभी प्रोग्रामिंग पाठ्यक्रमों में है - बहुत से लोग उस समस्या को फिर से देखने पर गहरा नहीं सोचेंगे।

— Sopel

Answer 2

यदि साक्षात्कारकर्ता ने आपको समस्या के लिए कोड लिखने के लिए कहा था, तो मुझे लगता है कि यह उचित नहीं है। एल्गोरिदम को काम की आवश्यकता होती है। हालाँकि, यदि साक्षात्कारकर्ता को कक्षाओं, विधियों या कुछ अवधारणाओं को दिखाना था, जिन्हें आपको उपयोग करना होगा या कुछ इसी तरह की आवश्यकता होगी, तो यह एक उचित प्रश्न हो सकता है।

समस्या एक शास्त्रीय कंप्यूटर विज्ञान समस्या है और ऐसी कई पुस्तकों में चर्चा की गई है। एनीमेशन के साथ एक उत्कृष्ट व्याख्या और कुछ कोड के साथ 12 अलग-अलग समाधान यहां मिल सकते हैं:

http://en.wikipedia.org/wiki/Eight_queens_puzzle

यहां भी कोड पाया जा सकता है: http://www.codeproject.com/KB/java/EightQueen.aspx

इस बारे में बुरा मत मानना, जैसा कि मैंने कहा, यह आसान नहीं है।

Answer 3

यह वास्तव में एक टिप्पणी का अधिक है, लेकिन यह वहाँ फिट नहीं है ...

एक शतरंज बोर्ड में 8x8 वर्ग होते हैं, कोई कम नहीं (ये प्रश्न मुझे हमेशा एक अनुकूलित शतरंज बोर्ड के दृष्टिकोण से परेशान करते हैं)।

लेकिन वैसे भी, अगर आपके पास एक x * y शतरंज बोर्ड है, और n क्वीन्स और ले रही है कि रानी इन क्षेत्रों को "ले"

क्या आप सिर्फ एक दो आयामी सरणी और "ध्वज" सभी फ़ील्ड बना सकते हैं जो एक रानी पर हमला करता है। फिर अन्य एक (बोर्ड के मध्य से) को रखें, शेष क्षेत्रों को चिह्नित करें, और इसी तरह ... जब तक आप या तो खेतों या रानियों को न चलाएं।

यह निश्चित रूप से एक बहुत ही सरलीकृत दृष्टिकोण है, क्योंकि अगर एक बुरे तरीके से तैनात किया जाता है, तो मैं इकट्ठा करता हूं कि अधिकतम रानियां अलग-अलग होंगी।

हम्म, बस यह भी पाया - 8 क्वीन्स समस्या।

Comments

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

— इंटरव्यू

@ इंट्रव्यू - हाँ, मुझे पता है। यह सिर्फ कुछ है जो मैंने अपने सिर के ऊपर से सोचा था। जैसा कि कहा गया है, यह एक दिलचस्प समस्या है और शायद इसमें सुधार किया जा सकता है, लेकिन 4 बजे (यहां) मैं सिर्फ सोचने के लिए बहुत आलसी हूं। Btw, साक्षात्कार कैसे हुआ?

— रूक

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

— कालेब

मुझे पसंद है कि आपका अवतार एक शतरंज का टुकड़ा है :)

— वॉरेन

Answer 4

असल में, बैकग्राउंड एल्गोरिथ्म इस तरह काम करता है:

1. Y सरणी द्वारा एक X बनाएँ। सभी वर्गों को खाली करने के लिए सेट करें।

2. रानी की गिनती शून्य पर सेट करें।

3. (1,1) के लिए अपनी वर्तमान स्थिति सेट करें

4. देखें कि आप रानी को वर्तमान स्थिति में रख सकते हैं या नहीं।

5. यदि आप रानी के लिए ऐरे (एक्स, वाई) सेट कर सकते हैं, तो रानी की गिनती बढ़ा सकते हैं। यदि आपने सभी रानी को रखा, तो रुकिए , आपके पास एक समाधान है।

6. यदि वर्तमान स्थिति (X, Y) नहीं है, तो वर्तमान स्थिति को बढ़ाएँ और चरण 4 पर जाएँ।

7. रानी को अंतिम स्थिति में खोजें (वह है जो उस क्रम में अंतिम रूप से आती है जिसे आप पदों में वृद्धि करते हैं)। वर्तमान स्थिति को उस रानी की स्थिति पर सेट करें, उसे हटा दें, और रानी की संख्या घटाएं।

8. अगर रानी की गिनती शून्य है, तो रुकें, कोई उपाय नहीं है।

9. वर्तमान स्थिति में वृद्धि।

10. चरण 4 पर जाएं।

Comments

इस विवरण में एल्गोरिथ्म सही ढंग से पीछे नहीं हटता है: यह केवल अंतिम प्रशंसनीय रानी को हटा देता है; आप अन्य पदों पर पहले के रानियों की कोशिश करने का जोखिम कभी नहीं उठाते।

— कैस्पर वैन डेन बर्ग

@KaspervandenBerg एल्गोरिथ्म सही ढंग से पीछे हटता है। मैं सीधे आपकी आलोचना का जवाब दूंगा, लेकिन मैं ईमानदारी से इसे नहीं समझ सकता। मुझे नहीं पता कि "अंतिम पठनीय रानी" से आपका क्या मतलब है। यह केवल अंतिम रखी गई रानी को हटा देगा, लेकिन किसी भी रानी को हटाए जाने के बाद रखी जाने वाली रानी को एक बार रखा जाएगा। यह जहां तक ​​जरूरत होगी, उस क्रम के उलट रानियों को हटाकर उन्हें पीछे कर देगा।

— डेविड श्वार्ट्ज

Answer 5

अन्य उत्तरों को जोड़ना: एक द्वि-आयामी सरणी बनाना केवल कोड को जटिल करता है।

आपको बस नियमित शतरंज बोर्ड के लिए आकार 8 के वेक्टर की आवश्यकता है। या 8 + 1 अगर सी 1 पद की तरह 0 है, केवल कोड को सरल बनाने के लिए, और 1-8 से निपटना है और 4-7 नहीं।

यदि आप एक्स के बारे में सोचते हैं कि यह एरे में आपकी स्थिति है, और वाई स्थिति की सामग्री है। उदा बोर्ड [1] = 8 का अर्थ है पहली रानी [1,8] पर है।

इस तरह, आपको केवल कॉलम सत्यापन के लिए जांचना होगा।

संकाय समय में, मैं डार्टमाउथ बेसिक में कार्यान्वित एल्गोरिदम के बारे में एक बहुत पुरानी पुस्तक (60 के दशक में) आया, जिसने कम स्मृति संभव का उपयोग करके 8 रानी समस्या को लागू किया (जो पुराना है, यह समझ में आता है)।

जहाँ तक मुझे याद है, इसने सदिश विचार का उपयोग किया था, और इसने अनिवार्य रूप से बोर्ड में सभी पदों के लिए दो चक्रों के साथ मजबूर किया। स्थिति की वैधता के लिए जाँच करने के लिए, इसने तीसरे लूप का उपयोग किया, प्रत्येक स्थिति में एक WHILE चक्र वेक्टर में वापस जाता है, और समान संख्या के लिए, या विकर्ण के लिए जाँच करने के लिए एक स्पर्शरेखा ऑपरेशन का उपयोग करके सूत्र के लिए जाँच करता है।

अफसोस की बात है, मैंने उस किताब का ट्रैक खो दिया ...

कहा एल्गोरिथ्म में एन-क्वीन समस्या के लिए सभी समाधान पाए गए।

Answer 6

यदि आपको बस यह निर्धारित करने के लिए एक एल्गोरिथ्म लिखना है कि क्या ऐसी व्यवस्था मौजूद है, तो मौजूदा शोध को देखें:
विकिपीडिया पर आठ रानियों की पहेली ।

यदि n> मिनट (X, Y) हो तो आप तुच्छ रूप से झूठ बोल सकते हैं।
उस पृष्ठ को पढ़ने के बाद, यदि आप एन <= मिनट (एक्स, वाई) और 2, 3! = मिनट (एक्स, वाई) को पूरा करना जानते हैं।

जो 2, 3 == मिनट (एक्स, वाई) और एन <= मिनट (एक्स, वाई) को छोड़ देता है।

खैर, अगर एन <मिनट (एक्स, वाई), एक समाधान ढूँढना तुच्छ है।
यदि एन == मिनट (एक्स, वाई), केवल एक समाधान है यदि अधिकतम (एक्स, वाई)> एन।

f(X, Y, N)
    if X < Y => f(Y, X, N)
    if Y > N => false
    => (Y < N) or (Y != 2 and Y != 3) or (X > N)

Answer 7

एन> मिनट (एक्स, वाई) होने पर स्पष्ट रूप से कोई समाधान नहीं है। अन्यथा, आप आसानी से दिखा सकते हैं कि एन = एक्स = वाई = 2, एन = एक्स = वाई = ३ के लिए कोई समाधान नहीं है। अन्य सभी मामलों के लिए एक समाधान प्रतीत होता है। समाधानों की संख्या एन बढ़ने के रूप में लगती है।

आप बैकग्राउंडिंग के साथ संपूर्ण खोज के माध्यम से एक समाधान पा सकते हैं: पहली पंक्ति में एक रानी रखो, कॉलम 1. दूसरी पंक्ति में एक रानी रखो, पहले कॉलम में कि पंक्ति 1 में रानी नहीं पहुंच सकती। दूसरी पंक्ति आदि में एक रानी रखो। यदि रानी को पंक्ति k में नहीं डाला जा सकता है, तो आप इसे हटा दें और रानी को अगले निर्लिप्त स्थिति में पंक्ति k-1 में स्थानांतरित करें।