एक अनुक्रम में एक अजीब खोजें

Question

चुनौती:

उस फ़ंक्शन पर विचार करें F(N) = 2^N + 1जहां Nएक सकारात्मक पूर्णांक से कम है 31। इस फ़ंक्शन द्वारा परिभाषित अनुक्रम है:

3, 5, 9, 17, 33, 65, 129, 257, 513, 1025, 2049, 4097, 8193, 16385, 32769, 65537, 131073, 262145, 524289, 1048577, 2097153, 4194305, 8388609, 16777217, 33554433, 67108865, 134217729, 268435457, 536870913, 1073741825

एक इनपुट निम्नानुसार उत्पन्न किया जाएगा:

• उपरोक्त अनुक्रम से 5 सन्निहित पूर्णांक लें ।
• उनमें से एक को एक अलग, सकारात्मक पूर्णांक से बदलें (जो उपरोक्त अनुक्रम का हिस्सा हो सकता है या नहीं भी हो सकता है)।
• वैकल्पिक रूप से 5 परिणामी संख्याओं को फिर से व्यवस्थित करें।

5 पूर्णांकों की ऐसी सूची को देखते हुए, इसमें जो स्वैप किया गया था उसे ढूंढें और इसलिए मूल 5 सन्निहित पूर्णांक का हिस्सा नहीं है।

उदाहरण:

• मूल सबलिस्ट 5, 9, 17, 33, 65:।
• एक बदलें 5, 7, 17, 33, 65:।
• पुन:: 33, 17, 5, 7, 65।

अपेक्षित आउटपुट होगा 7।

इनपुट में 5 मान हमेशा अलग होंगे और हमेशा एक अनूठा समाधान होगा। (उदाहरण के लिए, आप की तरह आदानों के साथ सौदा करने के लिए नहीं होगा 3, 9, 17, 33, 129जहां या तो 3या 129में बदली की गई है।)

परीक्षण के मामलों:

5,9,17,33,829
o/p: 829

9,5,17,829,33
o/p: 829

33, 17, 5, 7, 65
o/p: 7

5,9,177,33,65
o/p: 177

65,129,259,513,1025
o/p: 259

129,259,513,1025,65
o/p: 259

63,129,257,513,1025
o/p: 63

65,129,257,513,4097
o/p: 4097

5, 9, 2, 17, 33
o/p: 2

536870913, 67108865, 1073741825, 1, 268435457
o/p: 1

Comments

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

— मार्टिन एंडर

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

— मार्टिन एंडर

@MartinEnder नया टेस्ट केस होना चाहिए536870913,67108865,134217729,1,268435457

— Jörg Hülsermann

@ JörgHülsermann के रूप में अच्छी तरह से जोड़ने के लिए स्वतंत्र लग रहा है, लेकिन मेरा इरादा एक परीक्षण मामले को जोड़ना था N = 30जो इनपुट मानों में से एक के रूप में शामिल है ।

— मार्टिन एंडर

एक दिलचस्प चुनौती क्योंकि गलत एल्गोरिदम के साथ आना इतना आसान है। और वास्तव में मैंने कभी इतने गलत उत्तर पोस्ट नहीं किए। यह और भी बुरा होता अगर डुप्लिकेट को अनुमति दी जाती (कई सेट आधारित विधियाँ (मेरे सहित) विफल होंगी)

— टन हास्पेल

Answer 1

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

⁹R2*‘ṡ5ḟ@€µEÐfQ

TryItOnline
सभी परीक्षण मामले TryItOnline पर भी

एक सूची देता है जिसमें एक सूची होती है जिसमें एक विषम होती है।

कैसे?

⁹R2*‘ṡ5ḟ@€µEÐfQ - Main link, a (list)
⁹               - literal 256 (saving a byte over literal 30)
 R              - range, [1,2,3,...]
  2*            - 2 ** x, [2,4,8,...]
    ‘           - increment, [3,5,9,...]
     ṡ5         - all contiguous slices of length 5
       ḟ@€      - filter with reversed arguments for each
          µ     - monadic chain separation
            Ðf  - filter on condition:
           E    - all equal (those previously filtered lists with only one value)
              Q - unique (there can be two, but both will have the same odd-one-out)

Answer 2

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

a=>a.find(n=>--n&--n|!n)||a.sort((a,b)=>a-b)[a[0]*16>a[3]?4:0]

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

Comments

लगभग ठीक है, लेकिन n-1&n-2मान के साथ प्रयास करें2

— edc65

@ edc65 के लिए काम नहीं करता है [3, 17, 33, 65, 257]।

— नील

@ edc65 क्या मामला --n&--n|!nअच्छा लगता है 2?

— नील

यह वास्तव में अच्छा लग रहा है

— edc65

Answer 3

पायथन, 84 बाइट्स

def f(a,i=0):s=set(a)-{2**j+1for j in range(i,i+5)};return len(s)<2and s or f(a,i+1)

सभी परीक्षण के मामले विचारधारा पर हैं

वैध इनपुट के लिए एक सेट होता है जिसमें केवल ऑड-वन-आउट होता है।
अमान्य इनपुट के लिए पुनरावर्तन सीमा तक पहुंचा जाएगा और एक त्रुटि डाली जाएगी।

Answer 4

गणितज्ञ, 65 बाइट्स

f[a___,x_,b___]/;NestList[2#-1&,a~Min~b/. 2->0,4]~SubsetQ~{a,b}=x

यह एक फ़ंक्शन को परिभाषित करता fहै जिसे 5 तर्कों के साथ बुलाया जाना चाहिए, जैसे

f[5, 9, 17, 33, 829]

सिद्धांत रूप में फ़ंक्शन को तर्कों के किसी भी (गैर-शून्य) नंबर के साथ कहा जा सकता है, लेकिन आपको अप्रत्याशित परिणाम मिल सकते हैं ...

मुझे लगता है कि यह पहली बार है, जब मैंने पूरे समाधान को गैर-तुच्छ चुनौती के लिए बाएं हाथ के पक्ष में रखा =।

व्याख्या

यह समाधान वास्तव में हमारे लिए काम करने के लिए मैथमेटिका की पैटर्न मिलान क्षमताओं को रखता है। हम जो मूलभूत सुविधा का उपयोग कर रहे हैं, वह यह है कि गणितज्ञ केवल सरल कार्यों को परिभाषित नहीं कर सकता है, f[x_] := (* some expression in x *)लेकिन हम बाईं ओर के मनमाने ढंग से जटिल पैटर्न का उपयोग कर सकते हैं, उदाहरण के f[{a_, b_}, x_?OddQ] := ...लिए एक परिभाषा को जोड़ना होगा fजिसका उपयोग केवल तब किया जाता है जब इसे दो-तत्व के साथ बुलाया जाता है। सूची और एक अजीब पूर्णांक। आसानी से, हम पहले से ही बाएं हाथ की ओर अभिव्यक्ति के नीचे मनमाने ढंग से तत्वों को नाम दे सकते हैं (उदाहरण के लिए पिछले उदाहरण में, हम तुरंत दो सूची तत्वों को संदर्भित कर सकते हैं ) aऔर b।

इस चुनौती में हम जिस पैटर्न का उपयोग कर रहे हैं वह है f[a___,x_,b___]। यहाँ a___और शून्य या अधिक तर्कों के अनुक्रमb___ हैं और एक एकल तर्क है। चूंकि परिभाषा के दाएँ हाथ की ओर बस है , क्या हम चाहते हैं कुछ जादू सुनिश्चित करता है कि है और के लिए इनपुट हम खोज के लिए प्रयोग किया जाता है और बस वाइल्डकार्ड कि कवर शेष तत्व हैं।xxxa___b___

यह एक शर्त को पैटर्न के साथ जोड़कर किया जाता है /;। इस पैटर्न के मिलान के लिए दाईं ओर /;(सब कुछ तक =) की आवश्यकता है True। सुंदरता कि मेथेमेटिका के पैटर्न मिलान के हर एक काम की कोशिश करेंगे है a, xऔर bहमारे लिए आदानों की है, तो सही तत्व के लिए खोज हमारे लिए किया जाता है। यह अनिवार्य रूप से समस्या का एक घोषित समाधान है।

हालत के लिए ही:

NestList[2#-1&,a~Min~b/. 2->0,4]~SubsetQ~{a,b}

ध्यान दें कि यह बिल्कुल भी निर्भर नहीं करता है x। इसके बजाय, यह स्थिति केवल शेष चार तत्वों पर निर्भर करती है। यह पैटर्न मिलान समाधान की एक और सुविधाजनक विशेषता है: अनुक्रम पैटर्न के कारण, aऔर bसाथ में अन्य सभी इनपुट होते हैं।

इसलिए इस स्थिति को यह जाँचने की आवश्यकता है कि क्या शेष चार तत्व हमारे अनुक्रम से सबसे अधिक अंतर के साथ सन्निहित तत्व हैं या नहीं। इसे जाँचने के लिए मूल विचार यह है कि हम अगले चार तत्वों को न्यूनतम (से ) उत्पन्न करते हैं और जाँचते हैं कि क्या चार तत्व इसके सबसेट हैं। एकमात्र इनपुट जहां परेशानी पैदा कर सकता है, उनमें एक ए शामिल है , क्योंकि यह वैध अनुक्रम तत्व भी उत्पन्न करता है, इसलिए हमें इसे अलग से संभालने की आवश्यकता है।xi+1 = 2xi - 12

अंतिम भाग: चलिए वास्तविक अभिव्यक्ति के माध्यम से चलते हैं, क्योंकि यहाँ कुछ और मज़ेदार वाक्य रचना है।

...a~Min~b...

इस जानकारी के लिए संकेत कम है Min[a,b]। लेकिन याद रखें कि aऔर bअनुक्रम हैं, इसलिए यह वास्तव में चार तत्वों तक फैलता है Min[i1, i2, i3, i4]और हमें इनपुट में सबसे छोटा शेष तत्व देता है।

.../. 2->0

यदि यह 2 में परिणत होता है, तो हम इसे 0 से बदलते हैं (जो ऐसे मान उत्पन्न करेगा जो अनुक्रम में नहीं हैं)। अंतरिक्ष आवश्यक है क्योंकि अन्यथा गणितज्ञ फ्लोट शाब्दिक रूप से पार्स करता है .2।

NestList[...&,...,4]

हम इस मान पर बाईं ओर 4 बार अनाम फ़ंक्शन लागू करते हैं और एक सूची में परिणाम एकत्र करते हैं।

2#-1&

यह बस इसके इनपुट को 2 से गुणा करता है और इसे घटाता है।

...~SubsetQ~{a,b}

और अंत में, हम जाँचते हैं कि सूची में सभी तत्वों से युक्त aऔर इस bका एक सबसेट है।

Comments

मुझे नहीं पता था कि गणितज्ञ ऐसा कर सकता है!

— DanTheMan

Answer 5

रैकेट 198 बाइट्स

(λ(m)(let((l(for/list((i(range 1 31)))(+ 1(expt 2 i))))(r 1)(n(length m)))(for((i(-(length l)n)))(let
((o(for/list((j m)#:unless(member j(take(drop l i)n)))j)))(when(eq?(length o)1)(set! r o))))r))

Ungolfed संस्करण:

(define f
  (λ(m)
    (let ((l (for/list ((i (range 1 31))) 
               (+ 1 (expt 2 i))))
          (res 1)
          (n (length m)))
      (for ((i (- (length l) n)))
        (let ((o (for/list ((j m) 
                             #:unless (member j 
                                             (take (drop l i) n))) 
                    j)))
          (when (eq? (length o) 1)
            (set! res o))))
      res)))

परिक्षण:

(f '(5 9 17 33 829))
(f '(9 5 17 829 33))
(f '(5 9 177 33 65))
(f '(65 129 259 513 1025))
(f '(129 259 513 1025 65))
(f '(63 129 257 513 1025))
(f '(65 129 257 513 4097))

आउटपुट:

'(829)
'(829)
'(177)
'(259)
'(259)
'(63)
'(4097)

Answer 6

05AB1E , 32 30 26 24 20 बाइट्स

30Lo>Œ5ùv¹yvyK}Dgi`q

व्याख्या

30Lo>    # list containing the sequence [3 .. 1073741825]
Œ5ù      # all sequence sublists of length 5
v        # for each such list
 ¹yvyK}  # remove it's elements from input
 Dgi     # if the remaining list has length 1
    `q   # end the program and print the final list flattened

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

Answer 7

आर, 97 बाइट्स

यह मेरे विचार से अधिक कठिन निकला। मुझे यकीन है कि यह काफी गोल्फ हो सकता है।

m=match(x<-sort(scan()),2^(1:31)+1);l=diff(m);ifelse(NA%in%m,x[is.na(m)],x[ifelse(l[4]>1,5,l>1)])

अनगढ़ और समझाया गया

x<-sort(scan())                  # read input from stdin and sort, store as vector
m=match(x, 2^(1:31)+1)           # generate a vector of indices for which input matches the sequence
l=diff(m)                        # vector of the difference of indices (will only contain 4 elements)
ifelse(NA%in%m,                  # if m contains NA do:
       x[is.na(m)],              # return x where no match has been found, else:
       x[ifelse(l[4]>1,5,l>1)])  # return x by index where diff>1 unless it's the last object, then return x[5]

match()समारोह वापस आ जाएगी NA, तो इनपुट वेक्टर के किसी भी तत्व अनुक्रम में नहीं है और इसके परिणामस्वरूप हम सिर्फ सूचकांक कहां मिल सकता NAइनपुट में मौजूद हैं और इस वापसी:x[is.na(m)]

यदि इनपुट अनुक्रम का हिस्सा है, लेकिन गलत जगह है तो यह थोड़ा अधिक जटिल हो जाता है। क्योंकि इनपुट को सॉर्ट किया गया है, प्रत्येक जोड़ी के सूचकांकों के बीच की दूरी होनी चाहिए 1। इसलिए हम 1stमिलान किए गए सूचकांकों के अंतर की जांच करके गलत तत्व का पता लगा सकते हैं l=diff(m)और इसके लिए सूचकांक का चयन कर सकते हैं l>1। यह सिर्फ पर्याप्त होगा यदि यह इस तथ्य के लिए नहीं था कि lइसमें 4तत्व शामिल हैं 5। यह केवल एक समस्या है अगर हल किए गए इनपुट में अंतिम तत्व अनुक्रम का एक सदस्य है लेकिन बाद के भाग (अंतिम परीक्षण मामले में) का हिस्सा नहीं है। नतीजतन, अगर 4thतत्व सॉर्ट किए गए इनपुट में प्रविष्टि >1प्राप्त करता है , तो -length वेक्टर 5thमें सूचकांक की तलाश करता है 4:x[ifelse(l[4]>1,5,l>1)]

Comments

R के हाल के संस्करणों में एक फ़ंक्शन है anyNAजो कि बराबर हैany(is.na(x))

— JDL

Answer 8

हास्केल, 66 64 बाइट्स

g x=[s|n<-[1..],[s]<-[filter(`notElem`[2^m+1|m<-[n..n+4]])x]]!!0

प्रयोग उदाहरण: g [65,129,257,513,4097]-> 4097।

लंबाई 5 के सभी सन्निहित उपविभागों के माध्यम से लूप F(N), उन तत्वों को रखता है जो इनपुट सूची में नहीं हैं xऔर पैटर्न 1 (-> [s]) की लंबाई से मेल खाता है ।

संपादित करें: @xnor ने बाहरी लूप की ऊपरी सीमा को हटाकर दो बाइट्स बचाए। एक समाधान के रूप में मौजूद होने की गारंटी है, हास्केल का आलस्य पहले नंबर पर पाया जाता है।

Comments

क्या आपको वास्तव में 26 की ऊपरी सीमा की आवश्यकता है?

— xnor

Answer 9

पर्ल, 64 59 बाइट्स

के लिए +2 शामिल है -an

STDIN पर इनपुट सूची दें:

perl -M5.010 oddout.pl <<< "5 9 2 17 33"

oddout.pl:

#!/usr/bin/perl -an
@a=grep$_,@a{@F,map{2**$_+++1}($.++)x5}=@F while$#a;say@a

यदि आपको इस 58 बाइट वर्सन के परिणाम के आसपास अंतरिक्ष की परिवर्तनीय मात्रा से कोई आपत्ति नहीं है:

#!/usr/bin/perl -ap
$_=join$",@a{@F,map{2**$_+++1}($.++)x5}=@F while/\b +\b/

यदि इनपुट का कोई समाधान नहीं है, तो दोनों संस्करण हमेशा के लिए लूप करते हैं।

यह बहुत बीमार कोड है, लेकिन मैं सुरुचिपूर्ण कुछ भी नहीं सोच सकता ...

जिस तरह से मैं (एबी) उपयोग %aएक नया perlgolf चाल है जहाँ तक मुझे पता है।

Answer 10

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

s=set(input());i,=d={1}
while~-len(s-d):i*=2;d=d-{i/32+1}|{i+1}
print s-d

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

dपांच लगातार तत्वों के सेट को नए तत्व i+1को बार-बार जोड़ने और i/32+15. की वर्तमान विंडो से पहले आने वाले किसी भी पुराने तत्व को हटाने से कुछ भी नहीं बनाया गया है। यहां इसकी प्रगति दिखती है।

{1}
{3}
{3, 5}
{3, 5, 9}
{3, 5, 9, 17}
{3, 5, 9, 17, 33}
{5, 9, 17, 33, 65}
{9, 17, 33, 65, 129}
{17, 33, 65, 129, 257}
{33, 65, 129, 257, 513}

प्रारंभ से प्रारंभ में एक भटका 1 है, लेकिन यह हानिरहित है क्योंकि यह तुरंत हटा दिया गया है। 5 तत्वों तक का निर्माण करने वाले छोटे सेट भी हानिरहित हैं।

Answer 11

PHP, 87 76 75 बाइट्स

for(;count($b=array_diff($argv,$a?:[]))-2;)$a[$n%5]=1<<++$n|1;echo end($b);

साथ दौड़ो php -r '<code>' <value1> <value2> <value3> <value4> <value5>

Comments

'ए = []'

— नेकलेस

@ JörgHülsermann: यह आवश्यक है array_diff। लेकिन मैं वहां एक बाइट बचा सकता हूं।

— टाइटस

इसके परिणामस्वरूप एक चेतावनी array_diff (): तर्क # 2 एक सरणी नहीं है। मोड के साथ सरणी भरने के साथ अच्छा तरीका। यह मेरे प्रस्ताव में array_map और रेंज को

— बचाएगा

endइसके बजाय maxऔर आपका नोट अधिक महत्वपूर्ण नहीं है

— Jörg Hülsermann

Answer 12

सी #, 69 बाइट्स

int M(int[]a)=>a.Except(new int[30].Select((_,i)=>(1<<i+1)+1)).Sum();

Answer 13

जावा 7,85 बाइट्स

int f(int[]a,int l){int i=1;for(;i<l;)if(a[i++-1]*2-1!=a[i])return a[i];return a[0];}

Ungolfed

int f(int[]a,int l){
    int i=1;
    for(;i<l;)
    if(a[i++-1]*2-1!=a[i])
    return a[i];
   return a[0];

}

Comments

हम्म, क्या आपको यकीन है कि यह सही ढंग से काम करता है? क्योंकि मुझे परीक्षण मामलों 1, 5, 6, और 7 के लिए गलत आउटपुट मिल रहा है (केवल दूसरा, तीसरा और चौथा आउटपुट सही है)। इसके अलावा, पैरामीटर l31 है? प्रश्न में मैं केवल इनपुट के रूप में एक इंट-सरणी देखता हूं, लेकिन एक अतिरिक्त इंट नहीं? : एस

— केविन क्रूज़सेन

क्या यह विफल नहीं होगा यदि विषम मूल्य दूसरा है (सूचकांक 1 पर)?

— टन हास्पेल

सॉरी दोस्तों, मैं इस सवाल का गलत अर्थ लगाता हूं .. दरअसल अब मैं अस्पताल में हूं .. मैं इसे बहुत कम समय में बदलूंगा।

— नंबर

Answer 14

PHP, 76 बाइट्स

मॉड 5 के साथ टाइटस विचार लागू किया

<?for(;count($x=array_diff($_GET[a],$r))-1;$r[++$i%5]=2**$i+1);echo end($x);

126 बाइट्स से पहले

<?for(;$x=array_diff($_GET[a],array_map(function($z){return 2**$z+1;},range(++$i,$i+4)));)if(count($x)<2){echo end($x);break;}

Comments

अनाम फ़ंक्शन array_map(function($z){return 2**$z+1;},range($i,$i+4)):। $x[key($x)]->end($x)

— टाइटस

लाना 1-count($x=...): हालत के लिए आप को तोड़ने से छुटकारा मिल जाएगा for(;1-count($x=...););echo end($x);(-13)

— टाइटस

Answer 15

पायथ, 18 बाइट्स

hhlD-LQ.:mh^2dSCd5

अनुक्रम तैयार करें, लंबाई 5 के सब्लिस्ट्स लें, क्यू से प्रत्येक सबलिस्ट को निकालें, सबसे छोटा परिणाम लें, इसका एकमात्र तत्व आउटपुट करें।

Comments

के लिए काम नहीं करता है[5, 9, 2, 17, 33]

— एमिग्ना

Answer 16

कोटलिन, 55 बाइट्स

fun f(a:IntArray)=a.find{it-1 !in(1..30).map{1 shl it}}