खिड़कियों से बिल्लियों को फेंकना

Question

कल्पना कीजिए कि आप एक बिल्ली के साथ एक ऊंची इमारत में हैं। बिल्ली एक नीची कहानी की खिड़की से बाहर गिरने से बच सकती है, लेकिन अगर उसे ऊंची मंजिल से फेंक दिया जाए तो वह मर जाएगी। कम से कम प्रयासों का उपयोग करके, आप सबसे लंबी ड्रॉप का पता कैसे लगा सकते हैं कि बिल्ली बच सकती है?

जाहिर है, यदि आपके पास केवल एक बिल्ली है, तो आप केवल रैखिक रूप से खोज सकते हैं। पहले पहली मंजिल से बिल्ली को फेंक दो। यदि यह बच जाता है, तो इसे दूसरे से फेंक दें। आखिरकार, फर्श से फेंक दिए जाने के बाद, बिल्ली मर जाएगी। आप तब जानते हैं कि फर्श एफ -1 अधिकतम सुरक्षित मंजिल था।

लेकिन क्या होगा अगर आपके पास एक से अधिक बिल्ली हैं? अब आप कुछ प्रकार के लघुगणक खोज का प्रयास कर सकते हैं। मान लीजिए कि बिल्ड में 100 मंजिल हैं और आपके पास दो समान बिल्लियां हैं। यदि आप पहली बिल्ली को 50 वीं मंजिल से बाहर फेंक देते हैं और वह मर जाती है, तो आपको केवल 50 मंजिलों को रैखिक रूप से खोजना होगा। आप बेहतर कर सकते हैं यदि आप अपने पहले प्रयास के लिए निचली मंजिल चुनते हैं। मान लीजिए कि आप एक बार में 20 मंजिलों की समस्या से निपटने के लिए चुनते हैं और पहली घातक मंजिल # 50 है। उस स्थिति में, आपकी पहली बिल्ली फर्श 60 से मरने से पहले 20 और 40 मंजिलों से उड़ान भरेगी। आपको बस व्यक्तिगत रूप से 49 के माध्यम से फर्श 41 की जांच करनी होगी। यह कुल 12 प्रयास है, जो आपको बाइनरी एलिमिनेशन का उपयोग करने के लिए आपके द्वारा की गई 50 की तुलना में बहुत बेहतर है।

सामान्य तौर पर, 2 बिल्लियों के साथ एन-मंजिला इमारत के लिए सबसे अच्छी रणनीति क्या है और यह सबसे खराब स्थिति है? N मंजिलों और मी बिल्लियों के बारे में क्या?

मान लें कि सभी बिल्लियाँ समान हैं: वे सभी दी गई खिड़की से गिरने से बच जाएँगी या मर जाएँगी। इसके अलावा, हर प्रयास स्वतंत्र है: यदि एक बिल्ली गिर जाती है, तो यह पूरी तरह से अप्रभावित है।

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

Comments

मुझे वर्णित तरीके से बिल्लियों के उपयोग पर आपत्ति है। क्या हम इसे कुत्तों में बदल सकते हैं?

— थिलो

यह इतना आसान नहीं है। अध्ययन किया गया है (बिल्लियों के गलती से गगनचुंबी इमारतों से बाहर गिरने पर, फेंका नहीं जा रहा है)। एक निश्चित सीमा थी जहाँ उनकी मृत्यु हुई थी, और एक सीमा *** इस से अधिक थी *** जहाँ वे बच गए। कुछ इस बारे में कि उन्होंने अपने शरीर को कैसे तनाव में रखा।

— एंड्रयू शेफर्ड

मैंने कहीं पढ़ा है कि 15 फीट या उससे ऊपर, बिल्लियों के जीवित रहने की अधिक संभावना है। यह सवाल बेहतर होगा अगर हम पूर्व गर्लफ्रेंड और / या बीवियों को छेड़ रहे थे।

— एंथनी फोर्लोनी

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

— mjfgates

बनियों के साथ, "महीने" को "सप्ताह" में बदल दें।

— mjfgates

Answer 1

N मंजिलों और m बिल्लियों के सामान्य मामले के लिए आप आसानी से थोड़ा DP (डायनामिक प्रोग्रामिंग) लिख सकते हैं।

मुख्य सूत्र, a[n][m] = min(max(a[k - 1][m - 1], a[n - k][m]) + 1) : for each k in 1..nआत्म-व्याख्यात्मक होना चाहिए:

• यदि पहली बिल्ली को k-th फर्श से फेंक दिया जाता है और मर जाता है, तो हमारे पास अब k - 1(सभी नीचे k) और m - 1बिल्लियों ( a[k - 1][m - 1]) की जांच करने के लिए फर्श हैं ।
• यदि बिल्ली जीवित रहती है, तो n - kफर्श छोड़ दिया जाता है (ऊपर सभी मंजिलें k) और अभी भी mबिल्लियों।
• दो का सबसे खराब मामला चुना जाना चाहिए, इसलिए max।
• + 1 इस तथ्य से आता है कि हमने सिर्फ एक प्रयास का उपयोग किया है (चाहे बिल्ली जीवित हो या नहीं)।
• हम सबसे अच्छा परिणाम खोजने के लिए हर संभव मंजिल की कोशिश करते हैं, इसलिए min(f(k)) : for k in 1..n।

यह गौरव सक्सेना के लिंक (100, 2) के Google परिणाम से सहमत है ।

int n = 100; // number of floors
int m = 20; // number of cats
int INFINITY = 1000000;

int[][] a = new int[n + 1][m + 1];
for (int i = 1; i <= n; ++i) {
    // no cats - no game
    a[i][0] = INFINITY;
}

for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= m; ++j) {
        // i floors, j cats
        a[i][j] = INFINITY;

        for (int k = 1; k <= i; ++k) {
            // try throw first cat from k-th floor
            int result = Math.max(a[k - 1][j - 1], a[i - k][j]) + 1;
            a[i][j] = Math.min(a[i][j], result);
        }
    }
}

System.out.println(a[n][m]);

आप आसानी से रणनीति पा सकते हैं (पहली बिल्ली को कैसे फेंकें), यदि आप kकिसी अन्य सरणी में सबसे अच्छा बचाते हैं ।

O (n ^ 3) संगणना को शामिल नहीं करते हुए एक तेज़ समाधान भी है, लेकिन मैं पहले से ही थोड़ा नींद में हूं।

अरे हाँ संपादित करें , मुझे याद है कि मैंने इस समस्या को पहले कहाँ देखा था ।

Comments

हम्म, + 1बाहर होने की जरूरत नहीं है min()? जैसा कि आप स्वयं कहते हैं, कि प्रयास सफल है या नहीं, यह अभी भी एक प्रयास है।

— j_random_hacker 14

@j_random_hacker क्या यह कुछ बदलता है? के +1बाहर चल रहा है min। या इसे अंदर ले जाना max:)

— निकिता रायबाक

@ नीकिता: मुझे क्षमा करें, मैंने किसी तरह से गलत लिखा है कि आपने क्या लिखा है - जो आपके पास है वह मेरे अनुसार बिल्कुल सही है! +1।

— j_random_hacker

ध्यान दें कि यह Google कोड जाम की "एग ड्रॉप समस्या" के समान है। नीचे दिया गया O (n ^ 3) समाधान पर्याप्त नहीं है, क्योंकि बड़ी समस्या सेट N = 2000000000 का उपयोग करती है। code.google.com/codejam/contest/dashboard?c=32003#s=p2

— ripper234

O (n) एल्गोरिथ्म के लिए यह नया प्रश्न देखें। Google कोड Jam का शीर्ष उत्तर O (n) है, लेकिन मुझे यह अभी तक समझ में नहीं आया है। stackoverflow.com/questions/4699067/…

— ripper234

Answer 2

रेडिओलैब ("फॉलिंग" के बारे में) के एक हालिया एपिसोड के अनुसार , 9 वीं मंजिल तक एक बिल्ली टर्मिनल वेग तक पहुंच जाती है। उसके बाद, यह आराम करता है और चोट लगने की संभावना कम होती है। 30 वीं से ऊपर की गिरावट के बाद पूरी तरह से बिना कटे हुए बिल्लियाँ होती हैं। सबसे जोखिम वाली मंजिलें 5 वीं से 9 वीं हैं।

Comments

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

— थिलो

उत्तर नहीं, व्यवसाय डोमेन से सिर्फ कुछ अतिरिक्त संदर्भ।

— थिलो

यह उतना ही जवाब है जितना सवाल का हकदार है।

— रैनसम

यह सिर्फ दिखाता है कि यह लाइव = 1 का मामला नहीं है, परिणाम के रूप में मर = 0, लेकिन लाइव का अधिक = 1.0, मर = 0.0 और बीच में सब कुछ संभावनाएं हैं। यह एक वक्र भी है, एक रेखा नहीं है, जिसे खोजने की आवश्यकता है।

— tadman

उस रिपोर्ट के साथ समस्या चयन पूर्वाग्रह है - कोई भी पशु चिकित्सक के लिए एक मृत बिल्ली नहीं लेता है।

— बजे निकी योशीचुकी

Answer 3

कल्पना कीजिए कि आप एक बिल्ली के साथ एक ऊंची इमारत में हैं। बिल्ली एक नीची कहानी की खिड़की से बाहर गिरने से बच सकती है, लेकिन अगर उसे ऊंची मंजिल से फेंक दिया जाए तो वह मर जाएगी। कम से कम प्रयासों का उपयोग करके, आप सबसे लंबी ड्रॉप का पता कैसे लगा सकते हैं कि बिल्ली बच सकती है?

इस समस्या को हल करने के लिए सबसे अच्छी रणनीति भौतिक विज्ञान के कानून का उपयोग करते हुए, आपकी मान्यताओं के पहले स्थान पर सही होने की संभावना है।

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

संपादित करें:
वास्तव में, आप एक अधूरा ऊंट वितरण देखेंगे।
सबसे पहले, बिल्ली के मरने की संभावना कम (बहुत कम ऊंचाई) है, फिर यह उच्च (कम ऊंचाई), फिर कम (उच्च ऊंचाई), और फिर उच्च (बहुत अधिक ऊंचाई) हो जाती है।

जमीन से ऊपर की ऊंचाई के एक समारोह के रूप में बिल्ली के मरने की संभावना का ग्राफ इस तरह दिखता है:
(3 पर खत्म, क्योंकि अधूरा ऊंट वितरण)

अपडेट:
एक बिल्ली का टर्मिनल वेग 100 किमी / घंटा (60 मील प्रति घंटा) [= 27.7m / s = 25.4 गज / सेकंड] है।
मानव टर्मिनल का वेग 210 किमी / घंटा (130mph) है। [= 75m / s = 68.58 गज / सेकंड]

टर्मिनल वेग स्रोत:
http://en.wikipedia.org/wiki/Cat_righting_reflex

क्रेडिट:
Goooooogle

मुझे बाद में सत्यापित करने की आवश्यकता है:
http://en.wikipedia.org/wiki/Terminal_velocity
http://www.gr.nasa.gov /WWW/K-12/airplane/termv.html

Comments

क्या ये सही है? निश्चित रूप से एक बार टर्मिनल वेग तक पहुँचने के बाद, संभावना नहीं बदल सकती है - और मैं इस धारणा के तहत था कि एक बिल्ली एक टर्मिनल वेग गिरने से बच सकती है।

— ZoFreX

@ZoFreX: यकीन है कि वे कर सकते हैं, यह टर्मिनल वेग के ठीक नीचे है जो सबसे घातक हैं। दूसरी ओर, एक बिल्ली को छोड़ दें, एक सौ हजार मील ऊपर कहें, और बिल्ली गिरने और रहने की तुलना में निर्वात से मरने के बाद वातावरण में जलने की अधिक संभावना है।

— डेविड थॉर्नले

क्या उस ग्राफ में वे कान हैं?

— नवजाल

@ZoFreX: कोणीय गति। बिल्ली के शरीर के डिजाइन और बिल्ली के मुड़ने के कौशल के कारण कोणीय गति के कारण बिल्ली हमेशा अपने पैरों पर ज़मीन पर बैठती है। लेकिन अभी भी इसका मतलब है कि इसे चालू करने के लिए समय चाहिए। जितना अधिक समय होगा (==> ऊंचाई जितनी अधिक होगी), उतनी ही अधिक संभावना है कि बिल्ली अपने पैरों पर उतरेगी (==> बचने की संभावना नाटकीय रूप से बढ़ जाती है, जैसे कि सिर पर उतरने के विपरीत)। लेकिन आप सही कह रहे हैं, टर्मिनल के वेग तक पहुँचने के बाद संभावना समान रहती है। मुझे लगता है कि यह बहुत संभव है कि एक बिल्ली एक टर्मिनल वेग गिरने से बच सकती है, कम से कम खदान से एक खरोंच के बिना, बाथरूम की खिड़की (ऐप्पल 20 मी) से बाहर कूद गया।

— स्टीफन स्टीगर

Answer 4

मैंने पहली बार स्टीवन स्कीना के एल्गोरिथ्म डिज़ाइन मैनुअल (व्यायाम 8.15) में इस समस्या को पढ़ा । यह गतिशील प्रोग्रामिंग पर एक अध्याय का पालन करता है, लेकिन आपको रणनीति पर सटीक सीमा साबित करने के लिए गतिशील प्रोग्रामिंग जानने की आवश्यकता नहीं है । पहले समस्या कथन, फिर नीचे समाधान।

जब काफी ऊंचाई से गिरा तो अंडे फूट गए। एक एन-स्टोरी बिल्डिंग को देखते हुए, एक फ्लोर एफ होना चाहिए जैसे कि फर्श एफ ब्रेक से अंडे गिराए गए, लेकिन फर्श एफ -1 से अंडे बच गए। (यदि अंडा किसी तल से टूटता है, तो हम कहेंगे f = 1. यदि अंडा किसी तल से बच जाता है, तो हम कहेंगे f = n + 1)।

आप महत्वपूर्ण मंजिल को ढूंढना चाहते हैं। एकमात्र ऑपरेशन जो आप कर सकते हैं वह है किसी मंजिल से एक अंडा गिराना और देखें कि क्या होता है। आप k अंडों से शुरुआत करते हैं, और जितना संभव हो उतनी बार अंडे गिराने की कोशिश करते हैं। टूटे हुए अंडे का पुन: उपयोग नहीं किया जा सकता (बरकरार अंडे कर सकते हैं)। बता दें कि E (k, n) अंडे की बूंदों की न्यूनतम संख्या होगी जो हमेशा पर्याप्त होगी।

1. दिखाएँ कि ई (1, एन) = एन।
2. वह दिखाओ E(k,n) = Θ(n**(1/k))।
3. E (k, n) के लिए पुनरावृत्ति प्राप्त करें। ई (के, एन) को खोजने के लिए गतिशील कार्यक्रम का समय क्या है?

---

केवल 1 अंडा

पहले से शुरू होने वाले प्रत्येक मंजिल से अंडे को छोड़ने से महत्वपूर्ण फर्श को (कम-खराब) एन संचालन में मिलेगा।

कोई तेज एल्गोरिथम नहीं है। किसी भी एल्गोरिथ्म में किसी भी समय, उच्चतम मंजिल को छोड़ दें जहां से अंडे को नहीं देखा गया है। एल्गोरिथ्म को किसी भी उच्च मंजिल h> g + 1 से पहले फ्लोर जी + 1 का परीक्षण करना चाहिए, अन्यथा यदि अंडा फर्श एच से टूटना था, तो यह f = g + 1 और f = h के बीच अंतर नहीं कर सका।

2 अंडे

पहले, आइए k = 2 अंडे के मामले पर विचार करें, जब n = r ** 2 एक पूर्ण वर्ग है। यहाँ एक रणनीति है जो O (sqrt (n)) समय लेती है। आर फर्श की वृद्धि में पहले अंडे छोड़ने से शुरू करो। जब पहला अंडा टूटता है, फर्श पर कहते हैं ar, हमें पता है कि महत्वपूर्ण मंजिल च होना चाहिए (a-1)r < f <= ar। हम फिर से शुरू होने वाले प्रत्येक मंजिल से दूसरा अंडा गिराते हैं (a-1)r। जब दूसरा अंडा टूटता है, तो हमें महत्वपूर्ण मंजिल मिल गई है। हमने प्रत्येक अंडे को अधिकांश आर समय पर गिरा दिया, इसलिए यह एल्गोरिथ्म सबसे खराब 2r ऑपरेशन लेता है, जो कि Θ (sqrt (n)) है।

जब n एक पूर्ण वर्ग नहीं है, तो r = लें ceil(sqrt(n)) ∈ Θ(sqrt(n))। एल्गोरिथ्म The (sqrt (n)) बना हुआ है।

सबूत है कि किसी भी एल्गोरिथ्म में कम से कम sqrt (n) समय लगता है। मान लीजिए कि एक तेज एल्गोरिथम है। फर्श के अनुक्रम पर विचार करें जिससे वह पहला अंडा गिराता है (इसलिए जब तक वह टूट न जाए)। चूँकि यह sqrt (n) से कम है, इसलिए कम से कम n / sqrt (n) का अंतराल होना चाहिए जो sqrt (n) है। जब एफ इस अंतराल में होता है, तो एल्गोरिथ्म को दूसरे अंडे के साथ इसकी जांच करनी होगी, और यह 1-अंडा मामले को याद करते हुए फर्श-दर-मंजिल किया जाना चाहिए। अंतर्विरोध।

k अंडे

2 अंडों के लिए प्रस्तुत एल्गोरिदम को आसानी से k अंडों तक बढ़ाया जा सकता है। प्रत्येक अंडे को लगातार अंतराल के साथ गिराएं, जिसे n की kth जड़ की शक्तियों के रूप में लिया जाना चाहिए। उदाहरण के लिए, n = 1000 और k = 3 के लिए, पहले अंडे के साथ 100 मंजिलों की खोज करें, दूसरे अंडे के साथ 10 और आखिरी अंडे के साथ 1।

इसी तरह, हम यह साबित कर सकते हैं कि कोई भी एल्गोरिथ्म Θ(n**(1/k))k = 2 प्रमाण से शामिल होने से तेज़ नहीं है ।

सटीक समाधान

हम पहले अंडे (फर्श छ) को छोड़ने के लिए अनुकूलन करके पुनरावृत्ति को कम करते हैं, यह मानते हुए कि हम छोटे मापदंडों के लिए इष्टतम समाधान जानते हैं। यदि अंडा टूटता है, तो हमारे पास k-1 अंडे के साथ घूमने के लिए नीचे जी -1 मंजिल है। यदि अंडा जीवित रहता है, तो हमारे पास के अंडे के साथ तलाशने के लिए ऊपर की मंजिलें हैं। शैतान हमारे लिए सबसे बुरा चुनता है। इस प्रकार k> 1 पुनरावृत्ति के लिए

E(k,n) = min(max(E(k,n-g), E(k-1,g))) minimised over g in 1..n

Comments

अगर मेरे पास के अंडे हैं, O(k*n**(1/k))तो सबसे खराब स्थिति के लिए रनटाइम क्यों नहीं है ? चूंकि सबसे बुरे मामले में मुझे n**(1/k) ठीक kसमय से गुजरना पड़ता है ।

— Rakete1111

Answer 5

क्या यह नहीं लगता कि आप "द सेम कैट" का उपयोग कर रहे हैं?

आप इसे गणितीय रूप से प्राप्त कर सकते हैं, लेकिन गणित के बारे में यह अच्छी बात है ... सही मान्यताओं के साथ, 0 1 के बराबर हो सकता है (0 के बड़े मूल्यों के लिए)।

एक व्यावहारिक दृष्टिकोण से, आप 'समान बिल्लियाँ' प्राप्त कर सकते हैं, लेकिन आप "द सेम कैट" नहीं प्राप्त कर सकते।

आप उत्तर को आनुभविक रूप से निर्धारित करने का प्रयास कर सकते हैं, लेकिन मुझे लगता है कि पर्याप्त सांख्यिकीय अंतर होगा कि उत्तर सांख्यिकीय अर्थहीन होगा।

आप "द सेम कैट" का उपयोग करने की कोशिश कर सकते हैं, लेकिन यह काम नहीं करेगा, जैसे कि पहली बूंद के बाद, यह अब एक ही बिल्ली नहीं है। (इसी तरह, onecan दो बार एक ही नदी में कदम नहीं रखते)

या, आप बिल्ली के स्वास्थ्य को पूरी तरह से जोड़ सकते हैं, बेहद करीबी अंतराल पर नमूने ले सकते हैं, और उन ऊंचाइयों को पा सकते हैं जिनके लिए बिल्ली "ज्यादातर जीवित" है ("राजकुमारी दुल्हन" से "ज्यादातर मृत" के विपरीत)। बिल्लियाँ जीवित रहेंगी, औसतन (अंतिम अंतराल तक)।

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

Answer 6

मैंने समाधान के निर्माण के लिए थोड़ा अलग तरीका अपनाया।

मैंने अधिकतम मंजिल पर काम करना शुरू कर दिया है जिसे एक्स बिल्लियों और वाई अनुमानों का उपयोग करके कवर किया जा सकता है ।

1 मंजिल से शुरू करें और मंजिलों की जांच करते समय अनुमानों की संख्या बढ़ाते रहें, जिससे लगता है कि उनकी जाँच की गई थी और प्रत्येक मंजिल के लिए कितनी बिल्लियाँ शेष थीं।
इसे y समय तक दोहराएं ।

यह बहुत ही अक्षम कोड दिए गए उत्तर की गणना करने के लिए है, लेकिन फिर भी छोटी संख्या में बिल्लियों / मंजिलों के लिए उपयोगी है।

पायथन कोड:

def next_step(x, guess):
  next_x = []
  for y in x:
    if y[0] == guess:
      if y[1] != 1:
        next_x.append((guess+1, y[1] - 1))
    next_x.append(y)
    if y[0] == guess:
      next_x.append((guess+1, y[1]))
  return next_x

x = [(1, TOTAL_NUM_CATS)]
current_floor = 1
while len(x) <= TOTAL_NUM_FLOORS:
  x = next_step(x, current_floor)
  current_floor += 1
  print len(x)

2 बिल्लियों के लिए एक्स अनुमानों में पहचानी जाने वाली अधिकतम मंजिलें हैं:
1, 3, 6, 10, 15, 21, 28 ...

3 बिल्लियों के लिए:
1, 3, 7, 14, 25, 41, 63 ...

4 बिल्लियों के लिए:
1, 3, 7, 15, 30, 56, 98 ...

व्यापक शोध के बाद (ज्यादातर ओईआईएस में टाइपिंग के क्रमों को शामिल करते हुए ) मैंने देखा कि एक्स के लिए अधिकतम फर्श एक संयोजन टुकड़े के पैटर्न का अनुसरण करता है ।

2 बिल्लियों के लिए:
n <2: 2 ^ n - 1
n> = 2: C (n, 1) + C (n, 2)

3 बिल्लियों के लिए:
n <3: 2 ^ n - 1
n> = 3: C (n, 1) + C (n, 2) + C (n, 3)

4 बिल्लियों के लिए:
n <4: 2 ^ n - 1
n> = 4: C (n, 1) + C (n, 2) + C (n, 3) + C (n, 4)

यहाँ से मैंने सरल वेतन वृद्धि का आसान तरीका अपनाया जब तक कि मैं मंजिलों की आवश्यक संख्या को पार नहीं कर देता।

पायथन कोड:

def find_smallest(floors, eggs):
  maximum_floors = 0
  n = 0
  while maximum_floors < floors:
    maximum_floors = 0
    n += 1
    if n < eggs:
      maximum_floors = 2**n - 1
    else:
      count = 0
      for x in xrange(1, eggs+1):
        maximum_floors += combination(n, x)
  print n

यह (100, 2) = 14. के
लिए सही समाधान देता है जो किसी के लिए कुछ तुच्छ चीज़ों की जांच करना चाहता है, वह देता है (1 000 000, 5) = 43।

यह O (n) में चलता है जहाँ n समस्या का उत्तर है (अधिक बिल्लियों बेहतर)।
हालांकि मुझे यकीन है कि गणित के उच्च स्तर के साथ कोई व्यक्ति ओ (1) में गणना करने के लिए टुकड़े के सूत्रों को सरल बना सकता है।

Answer 7

O(m*(n^(1/m))) algorithm.

Let 'x' be the maximum number of attempts needed.  

m = 1 => linear => x=n

m = 2:  
Let the floors be split into 'k' partitions. The first cat is thrown at the end of each partition (max 'k' times). 
When it dies, the second cat is used to go up from the beginning of this partition.   
x = k + n/k.   
Minimize x by diff wrt k and setting = 0, to get k = n^(1/2) and x = 2 * n^(1/2).

m = 3:  
x = k + 2*(y^(1/2)), where y = n/k  
diff wrt x and set = 0, to get k = n^(1/3) and x = 3 * n^(1/3)

for general m:  
x = m * n^(1/m). 

Answer 8

मैं इस पर Google ब्लॉगस्पॉट नहीं पढ़ सकता (ब्लॉगवर्क के लिए धन्यवाद), लेकिन मुझे नहीं लगता कि एक सीधी बाइनरी स्टाइल खोज सबसे अच्छी होगी। इसका कारण यह है कि एक द्विआधारी खोज इस धारणा के आसपास आधारित है कि आप जिस उत्तर की तलाश कर रहे हैं, वह सूची में किसी भी सूचकांक सूचकांक में होने के बराबर मौका है। हालाँकि इस मामले में यह सच नहीं है। इस मामले में उत्तर की सीमा दूसरे के मुकाबले एक छोर के करीब होने की अधिक संभावना होगी। मुझे पता नहीं है कि खोज में कैसे कारक है, लेकिन यह एक दिलचस्प विचार है।

Comments

मुझे लगता है कि सवाल सबसे खराब स्थिति के लिए पूछ रहा है, इसलिए वितरण अप्रासंगिक है जब तक कि हर मंजिल संभव है।

— स्टीव जेसप

Answer 9

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

Comments

FWIW यह एक प्रच्छन्न वास्तविक जीवन समस्या हो सकती है। मान लीजिए कि आपके पास एक स्वचालित परीक्षण है जो संस्करण 1234 में विफल रहता है, लेकिन संस्करण 42 में काम किया है। बिल्ली 1234 पर मर चुकी है, लेकिन संस्करण 42 में रहती है। किस संशोधन ने इसे मार दिया? अगर 42 से 43 तक उदा अपडेट करना त्वरित और आसान है, लेकिन नए संस्करण की जांच करना और पुनर्निर्माण करना कठिन है, तो यह बिल्ली की समस्या की तरह लग रहा है।

— mcdowella