क्या बोगोसॉर्ट (उर्फ बंदर सॉर्ट) की तुलना में कोई बदतर सॉर्टिंग एल्गोरिदम हैं? [बन्द है]

Question

मेरे सहकर्मियों ने मुझे आज सुबह अपने विश्वविद्यालय के दिनों में एल्गोरिदम को छांटने की चर्चा के साथ वापस ले लिया। हमने स्टूपिडॉर्ट की तरह अपने पसंदीदा के बारे में याद दिलाया , और हम में से एक को यकीन था कि हमने एक सॉर्ट एल्गोरिथ्म देखा था O(n!)। मुझे मिला कि मैं "सबसे खराब" छँटाई एल्गोरिदम के लिए चारों ओर देख रहा हूँ जो मुझे मिल सकता है।

हमने पोस्ट किया कि एक पूरी तरह से यादृच्छिक प्रकार बहुत बुरा होगा (यानी तत्वों को यादृच्छिक करें - क्या यह क्रम में है? नहीं, फिर से यादृच्छिक करें), और मैंने चारों ओर देखा और पता चला कि इसे जाहिरा तौर पर बोगोॉर्ट, या बंदर सॉर्ट कहा जाता है , या कभी-कभी सिर्फ यादृच्छिक क्रमबद्ध ।

बंदर सॉर्ट में सबसे खराब स्थिति का प्रदर्शन O(∞), सबसे अच्छा मामला प्रदर्शन O(n), और औसत प्रदर्शन का प्रदर्शन होता है O(n·n!)।

सबसे खराब औसत छँटाई के प्रदर्शन के साथ वर्तमान में आधिकारिक तौर पर स्वीकृत छँटाई एल्गोरिथ्म क्या है (और इससे भी बुरा हाल है O(n·n!))?

Comments

प्रति bogosort कितने बोगोमिप्स हैं? पूछताछ करने वाले मन जानना चाहते हैं।

— zombat

स्पष्ट करने के लिए, क्या आप उस तुच्छ मामले को छोड़ रहे हैं जहां सबसे अच्छा मामला प्रदर्शन ओ (you) है?

— tloflin

c2.com/cgi/wiki?MultiplyAndSurrender

— जोश ली

मैंने सुना है कि बंदर सॉर्ट को "नशे में आदमी सॉर्ट" के रूप में भी जाना जाता है, एक ऐसा नाम जो मुझे बहुत अधिक उत्तेजक लगता है।

— मट्टियो इतालिया

@ माटेओ इटालिया - या इसे "टॉडलर सॉर्ट" कहा जा सकता है, क्योंकि 2 साल का कोई भी व्यक्ति अटेस्ट कर सकता है।

— मार्टिन कैपोडिसी

Answer 1

से डेविड मॉर्गन-मार्च की गूढ़ एल्गोरिदम पेज: इंटेलिजेंट डिजाइन क्रमबद्ध

परिचय

इंटेलिजेंट डिज़ाइन सॉर्ट एक सॉर्टिंग एल्गोरिदम है जो बुद्धिमान डिज़ाइन के सिद्धांत पर आधारित है।

एल्गोरिथम विवरण

मूल इनपुट सूची के सटीक क्रम में होने की संभावना 1 / (n) है। इस तरह की एक छोटी सी संभावना है कि यह कहने के लिए स्पष्ट रूप से बेतुका है कि यह संयोग से हुआ है, इसलिए इसे जानबूझकर एक बुद्धिमान सॉर्टर द्वारा उस क्रम में डाल दिया जाना चाहिए। इसलिए यह मान लेना सुरक्षित है कि यह पहले से ही किसी तरह से क्रमबद्ध है, जो "आरोही क्रम" की हमारी भोली नश्वर समझ को स्थानांतरित करता है। हमारे स्वयं की पूर्व धारणाओं के अनुरूप उस आदेश को बदलने का कोई भी प्रयास वास्तव में इसे कम क्रमबद्ध करेगा।

विश्लेषण

यह एल्गोरिथ्म समय में स्थिर है, और सूची में जगह को सॉर्ट करता है, जिसमें अतिरिक्त मेमोरी की आवश्यकता नहीं होती है। वास्तव में, इसके लिए किसी भी संदिग्ध तकनीकी कंप्यूटर सामान की भी आवश्यकता नहीं होती है। सॉर्टर की प्रशंसा करें!

प्रतिपुष्टि

गैरी रोजर्स लिखते हैं:

समय में निरंतर बनाने से सॉर्टर की शक्ति से इनकार किया जाता है। सॉर्टर समय के बाहर मौजूद है, इस प्रकार सॉर्ट कालातीत है। सॉर्टर की भूमिका को सत्यापित करने के लिए समय की आवश्यकता होती है। इस प्रकार ... यह विशेष प्रकार त्रुटिपूर्ण है, और इसे 'द सॉर्टर' के लिए जिम्मेदार नहीं ठहराया जा सकता है।

विधर्म!

Comments

"असेंबलिंग सॉर्ट" के रूप में भी जाना जाता है: मान लें कि सूची क्रमबद्ध है, वापस लौटें!

— बायोकेक

+100 - यह उत्तर 100% शुद्ध जीत से बना है।

— womp

अरे! "इंडिसिसिव सॉर्ट" ("श्रोडिंगर के सॉर्ट" या "क्वांटम सॉर्ट" के रूप में भी जाना जाता है) को मत भूलना, जहां सूची को सॉर्ट किया जा सकता है या नहीं किया जा सकता है, हालांकि यह जाँचने से पता चलेगा कि यह है या नहीं। यहाँ मेरी नमूना दिया गया है: void quantum_sort (void *b, size_t n, size_t s, int (*c)(const void *, const void*)) { if (rand () % 2) qsort (b, n, s, c); }।

— जो डी

हमें इस "This is the best of all posibble worlds because it is the world that is, and so in the best possible world the array would already be sorted!"

— कैंडाइड

मैं, एक के लिए, हमारे नए छँटाई अधिपति का स्वागत करता हूँ। सभी जय हो!

— ब्रायसन

Answer 2

कई साल पहले, मैंने मिरेकलसॉर्ट का आविष्कार किया (लेकिन वास्तव में कभी लागू नहीं किया गया)।

Start with an array in memory.
loop:
    Check to see whether it's sorted.
    Yes? We're done.
    No? Wait a while and check again.
end loop

आखिरकार, मेमोरी चिप्स में बिट्स फ़्लिप करने वाले अल्फा कणों का परिणाम एक सफल क्रम में होना चाहिए।

अधिक विश्वसनीयता के लिए, सरणी को एक परिरक्षित स्थान पर कॉपी करें, और मूल के विरुद्ध संभावित सॉर्ट किए गए सरणियों की जांच करें।

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

संपादित करें: सख्ती से बोलना, यह एक एल्गोरिथ्म नहीं है, क्योंकि इसे समाप्त करने की गारंटी नहीं है। क्या "एक एल्गोरिथ्म" "एक बदतर एल्गोरिथ्म" के रूप में योग्य नहीं है?

Comments

मुझे लगता है कि इस एल्गोरिथ्म की शुद्धता साबित करने के लिए कोई भी कॉस्मिक किरणों का उपयोग कर सकता है।

— ९

इसमें बड़ा O क्या है? O(2^N)?

— मूविंग डक

@MooDDuck: मुझे नहीं लगता कि वास्तव में इसका कोई बड़ा O है।

— कीथ थॉम्पसन

@MooDDuck: कड़ाई से बोलना, अगर यह समाप्त नहीं होता है तो यह एल्गोरिथम नहीं है, दोनों के अनुसार उन्होंने मुझे कॉलेज और विकिपीडिया लेख में क्या सिखाया ।

— कीथ थॉम्पसन

@ ओलाथे: हॉल्टिंग समस्या कहती है कि हम सभी कार्यक्रमों के लिए निर्धारित नहीं कर सकते हैं कि क्या वे रुकते हैं , लेकिन बहुत सारे कार्यक्रम हैं जिनके लिए हम यह निर्धारित कर सकते हैं। हम जानते हैं कि quicksort और Bubblesoft पड़ाव, और हम वे एल्गोरिदम पता है।

— कीथ थॉम्पसन

Answer 3

क्वांटम बोगोसॉर्ट

एक सॉर्टिंग एल्गोरिथ्म जो मानता है कि क्वांटम यांत्रिकी की कई-दुनिया की व्याख्या सही है:

1. जाँच लें कि सूची क्रमबद्ध है। यदि नहीं, तो ब्रह्मांड को नष्ट कर दें।

एल्गोरिथ्म के समापन पर, सूची केवल खड़े ब्रह्मांड में छंटनी की जाएगी। यह एल्गोरिथ्म सबसे खराब स्थिति वाला O (N) और औसत-केस O (1) समय लेता है। वास्तव में, प्रदर्शन की तुलना की औसत संख्या 2 है: 50% संभावना है कि ब्रह्मांड को दूसरे तत्व पर नष्ट कर दिया जाएगा, 25% संभावना है कि यह तीसरे पर नष्ट हो जाएगा, और इसी तरह।

Comments

लेकिन समय आपके द्वारा नष्ट किए गए ब्रह्मांड में मौजूद है। तो एक ब्रह्मांड में एक पर्यवेक्षक जिसे आपने अभी तक जांच नहीं किया है, यह बताने में सक्षम नहीं होगा कि एल्गोरिथ्म का कितना निष्पादन किया गया है। इस प्रकार, यह एल्गोरिथ्म हमेशा O (1) समय लेता है, क्योंकि पिछले ब्रह्मांड-विनाश अब मौजूद नहीं हैं।

— बैरी ब्राउन

हां, एकमात्र ब्रह्मांड में जो सूची को छांटता है, उसे निष्पादित करने में O (n) समय लगता है - अन्य ब्रह्मांडों में कितना समय लगा यह अप्रासंगिक है।

— निक जॉनसन

हालाँकि इस एल्गोरिथ्म में एक बहुत बड़ी समस्या है। मान लें कि 10 बिलियन में से एक बार आप गलती से एक सूची को समाप्त कर देंगे जब यह नहीं है। 20 हैं! 20 तत्व सूची को सॉर्ट करने के तरीके। सॉर्ट के बाद, शेष ब्रह्मांड वह होगा जिसमें सूची को सही ढंग से क्रमबद्ध किया गया था, और 2.4 मिलियन ब्रह्मांड जिसमें एल्गोरिथ्म ने गलती से सूची को सही ढंग से निष्कर्ष निकाला था। तो आपके पास यहां क्या है, मशीनरी के एक टुकड़े की त्रुटि दर को बड़े पैमाने पर बढ़ाने के लिए एक एल्गोरिथ्म है।

— निक जॉनसन

यह स्पष्ट रूप से सबसे अच्छा सॉर्टिंग एल्गोरिथ्म है, सबसे खराब नहीं है।

— बोएन

बीटल की सलाह को विफल करने के परिणामस्वरूप सभी ब्रह्मांड नष्ट हो सकते हैं।

— क्रैशकोड

Answer 4

मुझे आश्चर्य है कि किसी ने अभी तक स्लीपसॉर्ट का उल्लेख नहीं किया है ... या क्या मैंने इस पर ध्यान नहीं दिया है? वैसे भी:

#!/bin/bash
function f() {
    sleep "$1"
    echo "$1"
}
while [ -n "$1" ]
do
    f "$1" &
    shift
done
wait

उदाहरण का उपयोग:

./sleepsort.sh 5 3 6 3 6 3 1 4 7
./sleepsort.sh 8864569 7

प्रदर्शन के मामले में यह भयानक है (विशेषकर दूसरा उदाहरण)। 2 नंबर को सॉर्ट करने के लिए लगभग 3.5 महीने का इंतजार थोड़े बुरा है।

Comments

यह एक तरह से प्रतीत होता है O(N), लेकिन वास्तव में ओएस के लागू होने के समय से विवश है।

— मूविंग डक

किसी भी तरह से आप इसे काटते हैं, यह संभवतः बोगोसॉर्ट की तुलना में बेहतर विकास दर्शाता है।

— मूइंग डक

मुझे वहां एक रेस की हालत दिख रही है।

आप स्पष्ट रूप से प्रदर्शन में सुधार sleep "$1"करने के sleep "0.$(printf "%010d" $1)"लिए बदल सकते हैं । time ./sleepsort.sh 8864569 7फिर मेरे लैपटॉप पर 0.009s में चलता है।

— सैम केलेट

यह O (N) जटिलता (टाइमर के कार्यान्वयन पर निश्चित रूप से निर्भर) में चलता है, यह अलग-अलग रूप में एक साधारण बाल्टी प्रकार है।

— Qwerty01

Answer 5

जिंगल सॉर्ट, जैसा कि यहां वर्णित है ।

आप अपनी सूची में प्रत्येक मूल्य क्रिसमस पर एक अलग बच्चे को देते हैं। बच्चे, भयानक इंसान होने के नाते, अपने उपहारों के मूल्य की तुलना करेंगे और उसी के अनुसार खुद को क्रमबद्ध करेंगे।

Answer 6

मेरे पास एक व्याख्याता था जिसने एक बार एक यादृच्छिक सरणी उत्पन्न करने का सुझाव दिया था, अगर यह सॉर्ट किया गया था और फिर यह जाँच रहा है कि डेटा सॉर्ट किए जाने वाले सरणी के समान है या नहीं।

सबसे अच्छा मामला O (N) (पहली बार बच्चा!) सबसे खराब मामला O (कभी नहीं)

Comments

विश्लेषण करने के लिए अधिक दिलचस्प औसत मामला है , जो है ...?

— मूविंग डक

जैसा कि सभी सर्वश्रेष्ठ पाठ्य पुस्तकें कहती हैं, यह पाठक के लिए एक अभ्यास के रूप में छोड़ दिया जाता है!

— डेनियल

मूविंग डक: ओ (कभी-कभी)

— इल्या ओ।

@MooDDuck तब हमें यादृच्छिक सरणियों में यादृच्छिक तत्वों को उत्पन्न करने के लिए उपयोग किए जाने वाले तत्व प्रकार और वितरण की कार्डिनैलिटी को जानना होगा।

— प्रदर्शन नाम

जटिलता ओ (एन! * जेड ^ एन) है जहां जेड संभव मूल्यों के सेट का आकार है और एन सरणी की लंबाई है।

— जकुबिसज़ोन

Answer 7

यदि आप किसी भी तरह से एल्गोरिथ्म को सार्थक रखते हैं, O(n!)तो सबसे खराब ऊपरी सीमा है जिसे आप प्राप्त कर सकते हैं।

एक सेट के क्रमपरिवर्तन के लिए प्रत्येक संभावना की जाँच करने के बाद से छंटनी के n!कदम उठाए जाएंगे , आप इससे भी बदतर नहीं हो सकते।

यदि आप उससे अधिक कदम उठा रहे हैं तो एल्गोरिथ्म का कोई वास्तविक उपयोगी उद्देश्य नहीं है। निम्नलिखित सरल छँटाई एल्गोरिथ्म का उल्लेख नहीं करने के लिए O(infinity):

list = someList
while (list not sorted):
    doNothing

Comments

लेकिन यह जाँच करने के लिए O (n) लेता है कि क्या यह सॉर्ट किया गया है, इसलिए आप O (n * n!)

— erikkallen

@erikkallen: निश्चित रूप से हम एक एल्गोरिथ्म के साथ आ सकते हैं ताकि ओ (एन) से भी बदतर सॉर्टनेस को सत्यापित किया जा सके। उदाहरण के लिए, सरणी में प्रत्येक तत्व के लिए, सत्यापित करें कि यह पिछले सभी की तुलना में अधिक है, बहुत कुछ सम्मिलन प्रकार काम करता है। यह एक हे (n ^ 2) एल्गोरिथ्म है, और मुझे यकीन है कि मैं थोड़ा सोचा गया बदतर के साथ आ सकता हूं।

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

@ डेविड थार्नले: निम्नलिखित चेकिंग एल्गोरिथ्म संभवतः एक ही भावना दिखाएगा जैसे कि बोगोसॉर्ट: दो यादृच्छिक तत्वों को चुनें, यह जांचें कि छोटा सूचकांक वाला व्यक्ति छोटा है या बड़े सूचकांक वाले के बराबर है, फिर दोहराएं। एक वर्ग बिट मैट्रिक्स रखें यह देखने के लिए कि कौन से संयोजन पहले से ही चेक किए गए हैं। बेशक, इस मैट्रिक्स की जाँच एक यादृच्छिक चाल में भी की जा सकती है ...

— Svante

Answer 8

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

Comments

कोड की पवित्र माँ। मुझे लगता है कि हम एक बोगोप्लेक्स को छोटा भी कर सकते हैं।

— श्रीकॉनसन

Answer 9

आपको Pessimal Algorithms और Simplexity Analysis के रोमांचक क्षेत्र में कुछ शोध करना चाहिए । ये लेखक एक पेसिमल-बेस्ट-केस (आपके बोगोसॉर्ट का सबसे अच्छा मामला ओमेगा (n) है, के साथ एक तरह से विकसित होने की समस्या पर काम करते हैं, जबकि स्लॉज़ोर्ट (पेपर देखें) में एक गैर-बहुपद-सर्वोत्तम समय-जटिलता है)।

Answer 10

एक प्रकार है जिसे bogobogosort कहा जाता है। सबसे पहले, यह पहले 2 तत्वों की जांच करता है, और उन्हें फर्जी बनाता है। इसके बाद यह पहले 3 की जांच करता है, उन्हें फर्जी करता है, और इसी तरह।

किसी भी समय सूची क्रम से बाहर होनी चाहिए, यह पहले 2 फिर से bogosorting द्वारा पुनरारंभ होता है। नियमित बोगोसॉर्ट की औसत जटिलता है O(N!), इस एल्गोरिथ्म की औसत जटिलता हैO(N!1!2!3!...N!)

संपादित करें : आप कैसे बड़े इस संख्या है, के लिए की एक विचार देने के लिए 20तत्वों, इस एल्गोरिथ्म के एक औसत लेता 3.930093*10^158 साल , अच्छी तरह से ब्रह्मांड के प्रस्तावित गर्मी मौत से ऊपर की (अगर यह होता है) 10^100 वर्ष ,

जबकि मर्ज सॉर्ट .0000004 सेकंड , बबल सॉर्ट .0000016 सेकंड के आसपास होता है , और बोगोसॉर्ट में 308 साल , 139 दिन , 19 घंटे , 35 मिनट , 22.306 सेकंड लगते हैं , एक साल में 365.242 दिन लगते हैं और एक कंप्यूटर प्रति सेकंड 250,000,000 32 बिट पूर्णांक ऑपरेशन करता है।

Edit2 : यह एल्गोरिथ्म "एल्गोरिथ्म" चमत्कार की तरह धीमा नहीं है, जो शायद इस तरह की तरह, कंप्यूटर को ब्लैक होल में चूसा जाएगा इससे पहले कि यह सफलतापूर्वक 20 elemtnts को सॉर्ट करता है, लेकिन अगर यह हुआ, तो मैं एक औसत शुद्धता का अनुमान लगाऊंगा के 2^(32(the number of bits in a 32 bit integer)*N)(the number of elements)*(a number <=10^40) वर्ष ,

चूँकि गुरुत्वाकर्षण चिप्स के चलने की गति को बढ़ाता है, और 2 ^ N अवस्थाएँ हैं, जो कि है 2^640*10^40, या 5.783*10^216.762162762 वर्षों के बारे में है , हालाँकि यदि सूची क्रमबद्ध होने लगी, तो इसकी जटिलता केवल O(N)मर्ज सॉर्ट की तुलना में तेज़ होगी , जो केवल N लॉग एन भी है सबसे खराब स्थिति में।

Edit3 : यह एल्गोरिथ्म वास्तव में चमत्कार की तुलना में धीमा है क्योंकि आकार बहुत बड़ा हो जाता है, 1000 का कहना है, क्योंकि मेरे एल्गोरिथ्म में 2.83*10^1175546 वर्षों का एक रन समय होगा , जबकि चमत्कार सॉर्ट एल्गोरिथ्म में 1.156*10^9657 वर्षों का एक रन समय होगा ।

Comments

शानदार काम किया। दुखद यह दृश्यता नहीं है

— swyx

Answer 11

यहाँ 2 तरह से मैं कॉलेज में अपने रूममेट के साथ आया हूँ

1) आदेश की जांच करें 2) शायद एक चमत्कार हुआ, 1 पर जाएं

तथा

1) जाँच करें कि क्या यह क्रम में है, अगर 2 नहीं) प्रत्येक तत्व को एक पैकेट में डालें और इसे दूर सर्वर पर वापस उछाल दें। उनमें से कुछ पैकेट एक अलग क्रम में वापस आ जाएंगे, इसलिए 1 पर जाएं

Comments

दूसरा लगभग एक बोजो प्रकार के बराबर है। हालांकि पहले चालाक है।

— मूविंग डक

पहला है मिरेकल सॉर्ट।

— चार्ल्स

Answer 12

हमेशा बोगोबोगोसॉर्ट (बोगैसेप्शन!) है। यह सूची के तेजी से बड़े सबसेट पर बोगोसॉर्ट करता है, और फिर सभी को फिर से शुरू करता है यदि सूची कभी भी क्रमबद्ध नहीं होती है।

for (int n=1; n<sizeof(list); ++n) {
  while (!isInOrder(list, 0, n)) {
    shuffle(list, 0, n);
  }
  if (!isInOrder(list, 0, n+1)) { n=0; }
}

Comments

मुझे यह विचार पसंद है कि यह एल्गोरिथ्म "किसी भी बड़ी सूची के लिए ब्रह्मांड की गर्मी से मौत से पहले" खत्म करने के लिए डिज़ाइन किया गया है

— ए.ग्रैंडेट

Answer 13

1 अपनी वस्तुओं को इंडेक्स कार्ड पर क्रमबद्ध करने के लिए रखें
2 उन्हें हवा में फेंक दें, अपने घर से एक मील की दूरी पर।
2 उन्हें एक अलाव में फेंक दें और पुष्टि करें कि वे पूरी तरह से नष्ट हो गए हैं।
3 सही क्रम के लिए अपनी रसोई के फर्श की जाँच करें।
4 दोहराएँ अगर यह सही क्रम नहीं है।

सबसे अच्छा मामला scenerio O (is) है

केनीटीएम द्वारा अवलोकन अवलोकन के आधार पर ऊपर संपादित करें ।

Comments

नहीं, यह बदतर है क्योंकि इसके सफल होने की कोई संभावना नहीं है। इंडेक्स कार्ड आपकी रसोई में कैसे मिलेगा? वे बाहर बह रहे हैं। यह कहा जाता है, उह, buttheadsort।

— पैट्रिक करचर

मुझे लगता है कि उसका मतलब है कि कार्डों को बाहर हवा में फेंक दें , और फिर अपनी मंजिल को अंदर जांचें , जहां कार्ड न होने की गारंटी हो। यद्यपि "नाम" एल्गोरिथम नहीं ... यह निश्चित रूप से बदतर है!

— womp

@ पैट्रिक क्वांटम टनलिंग।

— kennytm

@KennyTM। जो वास्तव में मेरे साथ हुआ था। एक बहुत छोटा लेकिन गैर-शून्य मौका है कि कोई भी वस्तु गायब हो सकती है और ब्रह्मांड में किसी अन्य बिंदु पर फिर से प्रकट हो सकती है। मुझे लगता है कि यह एक हजार इंडेक्स कार्ड के साथ हो सकता है। । । Oi। खतरे, मेरे एल्गोरिथ्म त्रुटिपूर्ण है । मैं इसे ठीक कर दूंगा । । ।

— पैट्रिक करचर

यह चाय की तरह है और एक ही समय में चाय नहीं है। या एक अनंत असंभव ड्राइव का उपयोग करके अंतरिक्ष यात्रा।

— बैरी ब्राउन

Answer 14

"आप इसे क्या पसंद करेंगे?" तरह

1. सिस्टम का समय नोट करें।
2. क्विकॉर्ट (या कुछ और समझदारी से) का उपयोग करके क्रमबद्ध करें, बहुत अंतिम स्वैप को छोड़ दें।
3. सिस्टम का समय नोट करें।
4. आवश्यक समय की गणना करें। विस्तारित परिशुद्धता अंकगणित एक आवश्यकता है।
5. आवश्यक समय की प्रतीक्षा करें।
6. अंतिम स्वैप करें।

न केवल यह अनंत के किसी भी बोधगम्य ओ (एक्स) मूल्य को लागू कर सकता है, लिया गया समय काफी सही है (यदि आप उस लंबे समय तक इंतजार कर सकते हैं)।

Answer 15

अनंत से बुरा कुछ नहीं हो सकता।

Comments

इन्फिनिटी + 1. जिंक्स, नो रिटर्न।

— ज़ोम्बैट

1 के अत्यंत बड़े मूल्यों के लिए नहीं;)

— zombat

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

— ज़ोम्बैट

@ ज़ोम्बैट: आप कार्डिनैलिटी के बारे में बात कर रहे हैं, न कि अनंत के रूप में एक प्रतीक जो वास्तविक रेखा / जटिल विमान पर एक प्रवृत्ति का संकेत देता है।

— kennytm

@zombat। सम पूर्णांक के सेट का आकार पूर्णांक के सेट के आकार के समान है, जैसा कि इस तथ्य से दिखाया गया है कि आप उन्हें एक-से-एक पत्राचार में रख सकते हैं। अब, पूर्णांक की तुलना में अधिक वास्तविक संख्याएं हैं, जैसा कि पहले कैंटर द्वारा दिखाया गया था।

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

Answer 16

बूझो सॉर्ट एक संबंधित एल्गोरिथ्म है जो यह जांचता है कि सूची को क्रमबद्ध किया गया है या नहीं, यदि यादृच्छिक पर दो आइटम स्वैप करता है। यह एक ही सबसे अच्छा और सबसे खराब मामला है, लेकिन मैं सहजता से औसत मामले की अपेक्षा बोगोसॉर्ट से करूंगा। इस एल्गोरिथ्म के प्रदर्शन पर किसी भी डेटा को ढूंढना (या उत्पन्न करना) कठिन है।

Answer 17

के खंड

मान लें π सभी संभव परिमित संख्या संयोजन शामिल हैं। Math.stackexchange प्रश्न देखें

1. सरणी के आकार से आवश्यक अंकों की संख्या निर्धारित करें।
2. सरणी को फिर से ऑर्डर करने के तरीके को निर्धारित करने के लिए अनुक्रमित के रूप में segments स्थानों के सेगमेंट का उपयोग करें। यदि कोई खंड इस सरणी के लिए आकार की सीमाओं से अधिक है, तो and दशमलव ऑफसेट समायोजित करें और शुरू करें।
3. जांचें कि क्या पुन: आदेश दिया गया सरणी क्रमबद्ध है। यदि यह वूट है, तो ऑफसेट को समायोजित करें और शुरू करें।

Answer 18

O (∞) का सबसे खराब मामला प्रदर्शन शायद इसे कुछ के अनुसार एक एल्गोरिथ्म भी नहीं बना सकता है ।

एक एल्गोरिथ्म सिर्फ चरणों की एक श्रृंखला है और आप इसे पहले से ले जाने की तुलना में अधिक चरणों में वांछित आउटपुट प्राप्त करने के लिए इसे थोड़ा छोटा करके हमेशा खराब कर सकते हैं। एल्गोरिथ्म में उठाए गए कदमों की संख्या का ज्ञान जानबूझकर किया जा सकता है और इसे समाप्त कर सकते हैं और चरणों की संख्या समाप्त होने के बाद ही सही आउटपुट का उत्पादन करते हैं X। यह Xबहुत अच्छी तरह से O (n ² ) या O (n ^n! ) के क्रम का हो सकता है या जो कुछ भी करने के लिए वांछित एल्गोरिथ्म हो। यह प्रभावी रूप से अपने सर्वश्रेष्ठ-मामले के साथ-साथ औसत मामले की सीमा को बढ़ाएगा।

लेकिन आपके सबसे खराब स्थिति में सबसे ऊपर नहीं जा सकता :)

Answer 19

मेरी पसंदीदा धीमी छँटाई एल्गोरिथ्म stooge सॉर्ट है:

void stooges(long *begin, long *end) {
   if( (end-begin) <= 1 ) return;
   if( begin[0] < end[-1] ) swap(begin, end-1);
   if( (end-begin) > 1 ) {
      int one_third = (end-begin)/3;
      stooges(begin, end-one_third);
      stooges(begin+one_third, end);
      stooges(begin, end-one_third);
   }
}

सबसे खराब स्थिति जटिलता है O(n^(log(3) / log(1.5))) = O(n^2.7095...)।

एक और धीमी गति से छँटाई एल्गोरिथ्म वास्तव में slowsort नाम दिया गया है!

void slow(long *start, long *end) {
   if( (end-start) <= 1 ) return;
   long *middle = start + (end-start)/2;
   slow(start, middle);
   slow(middle, end);
   if( middle[-1] > end[-1] ) swap(middle-1, end-1);
   slow(start, end-1);
}

यह O(n ^ (log n))सबसे अच्छा मामले में लेता है ... यहां तक ​​कि stoogesort से भी धीमा।

Answer 20

Recursive Bogosort (probably still O(n!){
if (list not sorted)
list1 = first half of list.
list 2 = second half of list.
Recursive bogosort (list1);
Recursive bogosort (list2);
list = list1 + list2
while(list not sorted)
    shuffle(list);
}

Answer 21

यह पृष्ठ इस विषय पर एक दिलचस्प पढ़ने के लिए है: http://home.tiac.net/~cri_d/cri/2001/badsort.html

मेरा निजी पसंदीदा टॉम डफ का सिलिंडर है:

/*
 * The time complexity of this thing is O(n^(a log n))
 * for some constant a. This is a multiply and surrender
 * algorithm: one that continues multiplying subproblems
 * as long as possible until their solution can no longer
 * be postponed.
 */
void sillysort(int a[], int i, int j){
        int t, m;
        for(;i!=j;--j){
                m=(i+j)/2;
                sillysort(a, i, m);
                sillysort(a, m+1, j);
                if(a[m]>a[j]){ t=a[m]; a[m]=a[j]; a[j]=t; }
        }
}

Answer 22

डबल दलदली

दो बार बोगसॉर्ट और परिणामों की तुलना करें (बस यह सुनिश्चित करने के लिए कि यह क्रमबद्ध है) यदि यह फिर से नहीं करते हैं

Answer 23

आप किसी भी तरह के एल्गोरिथ्म को धीमी गति से चला सकते हैं अपना "क्या यह क्रमबद्ध है" कदम बेतरतीब ढंग से। कुछ इस तरह:

1. आप जिस सॉर्ट को सॉर्ट कर रहे हैं, उसी आकार के बूलियंस की एक सरणी बनाएं। उन सबको झूठा सेट करें।
2. बोगोसॉर्ट की एक पुनरावृत्ति चलाएँ
3. दो यादृच्छिक तत्वों को चुनें।
4. यदि प्रत्येक तत्व (I <j && array [i] <array [j]) के संबंध में दो तत्वों को क्रमबद्ध किया जाता है, तो बूलियन सरणी पर दोनों के अनुक्रमितों को सही पर चिह्नित करें। ओवर वाइज, ओवर शुरू।
5. जांचें कि क्या सरणी में सभी बूलियन सही हैं। यदि नहीं, तो 3 पर वापस जाएं।
6. किया हुआ।

Answer 24

हां, सिंपलसॉर्ट, सिद्धांत रूप में यह चलता है, O(-1)हालांकि यह इसके बराबर हैO(...9999) जो बदले में O (1 - 1) के बराबर है, जैसा कि ऐसा होता है कि यह O (∞) के बराबर भी है। यहाँ मेरा नमूना कार्यान्वयन है:

/* element sizes are uneeded, they are assumed */
void
simplesort (const void* begin, const void* end)
{
  for (;;);
}

Answer 25

एक मैं सिर्फ दो यादृच्छिक बिंदुओं को शामिल करने पर काम कर रहा था, और यदि वे गलत क्रम में हैं, तो उनके बीच की संपूर्ण व्यवस्था को उलट देना। मुझे http://richardhartersworld.com/cri_d/cri/2001/badsort.html पर एल्गोरिथ्म मिला , जो कहता है कि औसत मामला संभवतः O (n ^ 3) या O (n ^ 2 log n) के आसपास कहीं है ( वह वास्तव में निश्चित नहीं है)।

मुझे लगता है कि इसे और अधिक कुशलता से करना संभव हो सकता है, क्योंकि मुझे लगता है कि ओ (1) समय में उलट ऑपरेशन करना संभव हो सकता है।

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

Answer 26

Randomsubsetsort।

N तत्वों की एक सरणी को देखते हुए, प्रत्येक तत्व को प्रायिकता 1 / n के साथ चुनें, इन तत्वों को रैंडमाइज़ करें और जांचें कि क्या सरणी सॉर्ट की गई है। छंटनी तक दोहराएं।

अपेक्षित समय पाठक के लिए एक अभ्यास के रूप में बचा है।