पिछला 65 बाइट समाधान:
r->{for(int a,b=0,z,i=0;;b=a)if((a=b|1<<(z=r[i++]))==b)return z;}
नया उपाय। 19 बाइट्स के लिए शामिल हैंimport java.math.*;
-8 बाइट्स @Nevay को धन्यवाद
r->{int z,i=0;for(BigInteger c=BigInteger.ZERO;c.min(c=c.setBit(z=r[i++]))!=c;);return z;}
इसे ऑनलाइन आज़माएं!
संपादित करें
मेरे मूल कार्यक्रम में एल्गोरिथ्म ठीक था, लेकिन उपयोग किए गए डेटाटाइप के स्थिर आकार का मतलब था कि आकार के एक निश्चित सीमा से ऊपर जाने के बाद यह काफी जल्दी टूट गया।
मैंने इसे समायोजित करने के लिए कार्यक्रम की मेमोरी सीमा को बढ़ाने के लिए गणना में उपयोग किए गए डेटाटाइप को बदल दिया है ( या BigIntegerइसके बजाय मनमाना परिशुद्धता के लिए उपयोग intकर रहा है long)। हालांकि, यह इस बात को बहस का विषय बनाता है कि क्या यह O(1)अंतरिक्ष जटिलता के रूप में गिना जाता है या नहीं ।
मैं अपनी व्याख्या को नीचे छोड़ दूंगा, लेकिन मैं यह जोड़ना चाहता हूं कि मैं अब मानता हूं कि O(1)कुछ धारणाएं बनाए बिना अंतरिक्ष जटिलता को प्राप्त करना असंभव है ।
प्रमाण
Nपूर्णांक के रूप में परिभाषित करें कि ऐसा 2 <= N।
आज्ञा Sदेना एक सूची है जो यादृच्छिक पूर्णांक की एक श्रृंखला का प्रतिनिधित्व करती है [x{1}, ..., x{N}], जहां x{i}बाधा है 1 <= x{i} <= N।
समय जटिलता (बिग-ओ संकेतन में) इस सूची के माध्यम से पुनरावृत्ति करने के लिए आवश्यक है जो कि एक बार प्रति तत्व है O(n)
दी गई चुनौती सूची में पहले डुप्लिकेट मान को खोजने के लिए है। अधिक विशेष रूप से, हम पहले मूल्य की खोज कर रहे हैं Sजो सूची में पिछले आइटम का डुप्लिकेट है।
चलो pऔर qऐसी है कि सूची में दो तत्वों के पदों हो p < qऔर x{p} == x{q}। हमारी चुनौती सबसे छोटी हो जाती है जो qउन स्थितियों को पूरा करती है।
इस समस्या के लिए स्पष्ट दृष्टिकोण एस के माध्यम से पुनरावृत्त करना है और जांचें कि क्या हमारी x{i}सूची में मौजूद है T: यदि x{i}मौजूद नहीं है T, तो हम इसे स्टोर करते हैं T। यदि x{i}इसमें मौजूद है T, तो यह पहला डुप्लिकेट मान है और इसलिए सबसे छोटा है q, और जैसे हम इसे वापस करते हैं। यह अंतरिक्ष दक्षता है O(n)।
समय की O(1)जटिलता को बनाए रखते हुए अंतरिक्ष जटिलता को प्राप्त करने के लिए O(n), हमें सूची में प्रत्येक वस्तु के बारे में अद्वितीय जानकारी को अंतरिक्ष की सीमित मात्रा में संग्रहीत करना होगा। इस वजह से, किसी भी एल्गोरिथ्म पर एक ही तरीका प्रदर्शन कर सकता हैO(1)अंतरिक्ष जटिलता है अगर: 1. N को किसी विशेष परिमित डेटाटाइप के लिए अधिकतम संभव मानों को संग्रहीत करने के लिए आवश्यक मेमोरी के अनुरूप एक ऊपरी बाउंड दिया जाता है। 2. एक अपरिवर्तनीय चर के पुन: असाइनमेंट को जटिलता के खिलाफ नहीं गिना जाता है, केवल चर की संख्या (एक सूची जिसमें कई चर होते हैं)। 3. (अन्य उत्तरों के आधार पर) सूची है (या कम से कम, सूची के तत्व) परस्पर हैं, और सूची का डेटाटाइप एक हस्ताक्षरित पूर्णांक के रूप में पूर्व निर्धारित है, जिससे सूची में आगे तत्वों को किए जाने वाले बदलावों की अनुमति मिलती है। अतिरिक्त मेमोरी का उपयोग किए बिना।
1 और 3 दोनों को डेटाटाइप के बारे में मान्यताओं और विशिष्टताओं की आवश्यकता होती है, जबकि 2 की आवश्यकता होती है कि केवल उन वेरिएबल्स के आकार के बजाय अंतरिक्ष जटिलता की गणना के लिए चर की संख्या पर विचार किया जाना चाहिए। यदि इन धारणाओं में से कोई भी स्वीकार नहीं किया जाता है, तो O(n)समय जटिलता और O(1)अंतरिक्ष जटिलता दोनों को प्राप्त करना असंभव होगा ।
व्याख्या
किसका लड़का, यह एक मस्तिष्क शक्ति का एक सा सोचने के लिए एक लंबे समय तक एक शर्मनाक समय लिया ।
तो, बोनस के लिए जाना मुश्किल है। हमें पूरी सूची पर ठीक एक बार काम करने और उन मूल्यों को ट्रैक करने की आवश्यकता है जो हमने पहले ही अतिरिक्त अंतरिक्ष जटिलता के बिना पुनरावृत्त कर दिए हैं।
बिट हेरफेर उन समस्याओं को हल करता है। हम अपने O(1)'स्टोरेज' को, पूर्णांक की एक जोड़ी को आरंभीकृत करते हैं, फिर सूची के माध्यम से पुनरावृति करते हैं, या हमारे पहले पूर्णांक में ith बिट को इन्न-बिट करते हैं और उस परिणाम को दूसरे तक संग्रहीत करते हैं।
उदाहरण के लिए, यदि हमारे पास है 1101, और हम एक OR ऑपरेशन करते हैं 10, तो हम प्राप्त करते हैं 1111। यदि हम एक और OR के साथ करते हैं 10, तो हमारे पास अभी भी है 1101।
Ergo, एक बार जब हम OR ऑपरेशन करते हैं और उसी नंबर के साथ समाप्त होते हैं, तो हमने अपना डुप्लिकेट ढूंढ लिया है। सरणी में कोई भी डुप्लिकेट कार्यक्रम को चलाने और अपवाद को फेंकने का कारण नहीं बनता है।