पुनरावर्ती Collatz अनुमान

Question

Collatz अनुमान तत्वों है कि अगर आप किसी भी सकारात्मक पूर्णांक लेते हैं, उसके बाद निम्न एल्गोरिथ्म पर्याप्त बार दोहराने:

if number is odd, then multiply by three and add one
if number is even, then divide by two

आप अंततः 1 पर समाप्त हो जाएंगे। यह हमेशा काम करने लगता है, लेकिन यह कभी साबित नहीं हुआ है कि यह हमेशा करता है।

आपने पहले ही गणना कर ली है कि 1 को पाने में कितना समय लगता है , इसलिए मैंने सोचा कि मैं चीजों को थोड़ा बदल दूंगा ।

दिए गए धनात्मक पूर्णांक से शुरू करते हुए, गणना करें कि 1 को प्राप्त करने में कितना समय लगता है (इसका "रोक समय")। फिर उस नंबर के रुकने का समय ज्ञात करें।

जब तक आप 1 तक नहीं पहुंचते, या जब तक आप 100 पुनरावृत्तियों की पूरी तरह से मनमानी सीमा तक नहीं पहुंच जाते, तब तक दोहराएं। पूर्व के मामले में, प्रिंट करें कि कितने पुनरावृत्तियों ने इसे लिया। बाद के मामले में, "विफल" या अपनी पसंद के कुछ अन्य सुसंगत आउटपुट प्रिंट करें, जब तक कि यह पूर्णांक नहीं है 1≤n≤100। आप इस विकल्प के लिए एक रिक्त स्ट्रिंग आउटपुट नहीं कर सकते। सीमा के बाहर एक पूर्णांक को आउटपुट करना [1, 100], हालांकि, अनुमति है।

उदाहरण:

Input: 2
2->1
Output: 1

Input: 5
5->5->5->5->5->...
Output: Fail

Input: 10
10->6->8->3->7->16->4->2->1
Output: 8

Input: 100
100->25->23->15->17->12->9->19->20->7->16->4->2->1
Output: 13

Input: 10^100
10^100->684->126->108->113->12->9->19->20->7->16->4->2->1
Output: 13

Input: 12345678901234567890
12345678901234567890->286->104->12->9->19->20->7->16->4->2->1
Output: 11

Input: 1
--Depending on your code, one of two things may happen. Both are valid for the purposes of this question.
1
Output: 0
--Or:
1->3->7->16->4->2->1
Output: 6

जैसा कि मैंने उस भाषा की गणना 10^100और 12345678901234567890उपयोग किया है जो केवल उस आकार के लिए वास्तविक का समर्थन करती है, यदि आपकी भाषा अधिक सटीक है, तो आप उन लोगों के लिए अलग-अलग परिणाम प्राप्त कर सकते हैं।

स्कोरिंग

जैसा कि यह कोड-गोल्फ है , बाइट्स की सबसे कम राशि के साथ जवाब जीतता है।

Comments

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— कोल

Answer 1

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

×3‘$HḂ?’пL’
Ç1¹?ȷ2Сi1’

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

Comments

23 बाइट्स (का उपयोग कर ³के बजाय ȷ2है की अनुमति दी )।

— श्री एक्सकोडर

Answer 2

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

f=lambda n,k=0,j=0:n-1and-~f(k*[n/2,n*3+1][n%2]or f(j/99or n,1),k,j+1)

एक सौ या अधिक पुनरावृत्तियों के लिए 199 रिटर्न ।

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

Answer 3

अटैची , 40 बाइट्स

`-&3@`#@PeriodicSteps[CollatzSize@Max&1]

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

यह एक नई भाषा है जिसे मैंने बनाया है। मैं एक उचित इनफ़िक्स भाषा बनाने के लिए इधर-उधर जाना चाहता था, और इसका परिणाम है: एक गणितज्ञ नॉक-ऑफ। हुर्रे?

व्याख्या

यह कुछ कार्यों की एक रचना है। ये कार्य हैं:

• PeriodicSteps[CollatzSize@Max&1]यह एक फ़ंक्शन देता है जो अपने तर्क को लागू करता है जब तक कि परिणाम में एक डुप्लिकेट तत्व नहीं होता है। यह फ़ंक्शन, इनपुट के बड़े पर CollatzSize@Max&1लागू CollatzSizeहो रहा है और 1, 0CollatSize के लिए अमान्य इनपुट से बचने के लिए।
• `#एक उद्धृत ऑपरेटर है; इस अर्थ में जब इसे लागू किया जाता है, तो यह अपने तर्क का आकार प्राप्त करता है
• `-&3एक बंधुआ फ़ंक्शन है, जो फ़ंक्शन के तर्क 3को बांड करता है `-, जो "माइनस 3" के रूप में पढ़ता है। इसका कारण यह है कि PeriodicSteps एप्लिकेशन पैदावार देता है 0, जिसका हिसाब देना आवश्यक है। (यह भी बड़े करीने से बाहर की संख्या को संभालता है 5, जैसे कि नक्शा कौन सा है -1।)

Comments

क्या आपकी स्वयं की भाषा का उपयोग करने की अनुमति है? कठबोली आप केवल प्रत्येक कोडगॉल्फ के लिए एक लंगोट बनाते हैं जिसमें केवल कुछ बाइट्स का उपयोग होता है?

— Tweakimp

@ अपनी खुद की भाषा बनाने (और उपयोग करने) की अनुमति दी जाती है। लेकिन इसे संशोधित करना ताकि एक कार्य एक आदेश है (चुनौती पोस्ट होने के बाद) एक मानक खामी है।

— caird coinheringaahing

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

— कॉनर ओ'ब्रायन

यह एक सामान्य प्रश्न था, सेल्फमेड भाषाओं की अनुमति दी जाती है, न कि एक नकारात्मक कथन जिसे आपने अपने लिए इस्तेमाल किया है।

— Tweakimp

Answer 4

जे , ₄₉ 45 बाइट्स

-4 बाइट्स के लिए धन्यवाद, @ यादृच्छिक की टिप्पणी से लिया गया Collatz अनुक्रम कोड यहाँ ।

(2-~[:#(>&1*-:+2&|*+:+>:@-:)^:a:)^:(<101)i.1:

101अमान्य परिणामों के लिए आउटपुट ।

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

व्याख्या

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

(1-~[:#%&2`(1+3&*)@.(2&|)^:(1&<)^:a:)^:(<101)i.1:

Collatz अनुक्रम की लंबाई ढूँढना

कोड का यह खंड निम्नलिखित है

(1-~[:#%&2`(1+3&*)@.(2&|)^:(1&<)^:a:)

यहाँ स्पष्टीकरण है:

(1 -~ [: # %&2`(1+3&*)@.(2&|) ^: (1&<) ^: a:)  Given an input n
                                       ^: a:   Apply until convergence, collecting
                                                each result in an array.
                              ^: (1&<)         If n > 1 do the following, else
                                                return n.
                        (2&|)                  Take n mod 2.
           %&2                                 If n mod 2 == 0, divide by 2.
               (1+3&*)                         If n mod 2 == 1, multiply by 3 
                                                and add 1.
         #                                     Get the length of the resulting
                                                array.
 1 -~                                          Subtract 1.

दुर्भाग्य से, लागू करने की क्रिया ( ^:) जब परिणामों को संग्रहीत करने के लिए कहा जाता है तो प्रारंभिक मूल्य भी संग्रहीत होता है, इसलिए इसका मतलब है कि हम (हमेशा की तरह) एक-एक करके बंद कर रहे हैं। इसलिए हम 1 घटाते हैं।

पुनरावर्ती अनुक्रम की लंबाई का पता लगाना

(1-~[:#%&2`(1+3&*)@.(2&|)^:(1&<)^:a:) ^: (< 101) i. 1:  Given an input n.
                                      ^: (< 101)        Apply 100 times,
                                                         collecting results
                                                         in an array.
(1-~[:#%&2`(1+3&*)@.(2&|)^:(1&<)^:a:)                   Collatz sequence length.
                                                 i. 1:  Index of first 1 (returns
                                                         101, the length of the
                                                         array if 1 not found).

Comments

यदि आपको शीर्ष लेख अनुभाग का उपयोग करने में कोई आपत्ति नहीं है, तो यह संभवतः आपके उत्तर को सही ढंग से प्रदर्शित करेगा

— Conor O'Brien

@ ConorO'Brien मैं बिल्कुल नहीं हूँ - मैं वास्तव में नहीं जानता था कि इसे इस तरह कैसे स्वरूपित किया जाए (लेकिन मैं अब से आपकी चोरी करूंगा)। धन्यवाद

— कोल

एक n y टी मैं ई हूँ!

— कॉनर ओ'ब्रायन

38 बाइट्स *i.~(<101)1&(#@}.a:2&(<*|{%~,*+1+])])]समतुल्य होने चाहिए

— मील

Answer 5

सी (जीसीसी) , 75 बाइट्स

i,j;f(n){for(j=0;(i=n)&&j++<100;)for(n=0;i-1;++n)i=i&1?i*3+1:i/2;i=!i*j-1;}

पुनरावृत्तियों के -1लिए रिटर्न n>=100।

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

सी (जीसीसी) , 73 बाइट्स

i,j;f(n){for(j=-1;(i=n)&&j++<99;)for(n=0;i-1;++n)i=i&1?i*3+1:i/2;i=!i*j;}

पुनरावृत्तियों के 0लिए रिटर्न n>=100।

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

Answer 6

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

रिटर्न trueजब यह विफल रहता है। के लिए लौटता 0है 1।

f=(n,k=i=0)=>n>1?f(n&1?n*3+1:n/2,k+1):k?i>99||f(k,!++i):i

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

f=(n,k=i=0)=>n>1?f(n&1?n*3+1:n/2,k+1):k?i>99||f(k,!++i):i

console.log(f(2))    // 1
console.log(f(5))    // fail
console.log(f(10))   // 8
console.log(f(100))  // 13
console.log(f(1))    // 0

Comments

मुझे संदेह है कि यदि आपका कार्यक्रम अतिप्रवाह / अशुद्धि के अलावा सही परिणाम की गणना करने के लिए होता है या यदि ओपी ने समान संख्या कार्यान्वयन वाली भाषा का उपयोग करके अपने परिणाम निकाले हैं (मुझे लगता है कि उन्होंने हाथ से सभी परीक्षण मामलों की गणना नहीं की है)।

— जोनाथन फ्रीच

@ जोनाथनफ्रेच दरअसल। यह दोनों परिणाम समान रूप से अमान्य थे।

— अरनुलद

Answer 7

एपीएल (डायलॉग यूनिकोड) , 39 60 53 52 49 बाइट्स

-3 बाइट्स @ngn की बदौलत

0∘{99<⍺:⋄1=⍵:0⋄1+(⍺+1)∇{1=⍵:0⋄1+∇⊃⍵⌽0 1+.5 3×⍵}⍵}

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

Collatz के लिए @ngn कोड का उपयोग करता है, लेकिन पहले @ Uriel के कोड का उपयोग करता था।

यहां वह पुराना संस्करण है जो विनिर्देशन को पूरा नहीं करता है:

{1=⍵:0⋄1+∇{1=⍵:0⋄2|⍵:1+∇1+3×⍵⋄1+∇⍵÷2}⍵}

Comments

2|⍵:1+∇1+3×⍵⋄1+∇⍵÷2->1+∇⊃⍵⌽0 1+.5 3×⍵

— ngn

Answer 8

पर्ल 6 , 56 बाइट्स

{($_,{($_,{$_%2??$_*3+1!!$_/2}...1)-1}...1).head(102)-1}

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

101नॉन-टर्मिनेटिंग सीक्वेंस के लिए रिटर्न ।

Answer 9

भूसी , 21 बाइट्स

←€1↑101¡ȯ←€1¡?½o→*3¦2

इसे ऑनलाइन आज़माएं!इनपुट -1पर विफलता, रिटर्न ।01

व्याख्या

←€1↑101¡ȯ←€1¡?½o→*3¦2  Implicit input (a number).
             ?½o→*3¦2  Collatz function:
             ?     ¦2   if divisible by 2,
              ½         then halve,
               o→*3     else multiply by 3 and increment.
        ȯ←€1¡?½o→*3¦2  Count Collatz steps:
            ¡           iterate Collatz function and collect results in infinite list,
          €1            get 1-based index of 1,
        ȯ←              decrement.
       ¡               Iterate this function on input,
   ↑101                take first 101 values (initial value and 100 iterations),
←€1                    get index of 1 and decrement.

Answer 10

सी (जीसीसी) , 70 73 बाइट्स

g(x){x=x-1?g(x%2?3*x+1:x/2)+1:0;}f(x,m){for(m=0;(x=g(x))&&100>m++;);x=m;}

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

101पुनरावृत्तियों की संख्या 100 से अधिक होने पर वापस आती है।

Comments

PPCG में आपका स्वागत है! यह उत्तर काफी मान्य नहीं है, क्योंकि सभी फ़ंक्शन सबमिशन को पुन: उपयोग करने की आवश्यकता है । मुझे लगता है कि आप इसे m=0अपने में डालकर ठीक कर सकते हैं f(शायद forएक को बचाने के लिए वर्तमान में खाली इंटेलाइज़र का उपयोग भी कर रहे हैं ;)।

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

Answer 11

क्लीन , 146 ... 86 बाइट्स

-11 बाइट्स थैंक्स टू अर्जन जोहान्सन

import StdEnv
?f l n=hd[u\\1<-iterate f n&u<-l]

?(?(\b|isOdd b=3*b+1=b/2)[0..])[0..99]

आंशिक कार्य शाब्दिक के रूप में।

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

साथ रोकता hd of []है, तो पुनरावृत्तियों की संख्या 100 से अधिक है
के साथ बाहर निकलता है Heap Fullके लिए ~ ऊपर आदानों 2^23जब तक आप एक बड़ा ढेर आकार निर्दिष्ट करें।

Comments

मैं आपके उत्तरों से कुछ क्लीन सिंटैक्स (जैसा कि हास्केल से भिन्न होता है) को समझना शुरू कर रहा हूं ... आप एक सहायक फ़ंक्शन के साथ इसे छोटा कर सकते हैं j f l n=hd[u\\1<-iterate f n&u<-l]।

— अर्जन जोहान्सन

@ ØrjanJohansen धन्यवाद!

— Οसूरस

आपको इस \a=...aभाग की आवश्यकता नहीं है , यह करी है। (या एटा कम कर देता है।)

— अर्जन जोहान्सन

@ ,RjanJohansen ओह, चूक गए, धन्यवाद!

— Οurous

Answer 12

पायथन 2 , 99 98 97 बाइट्स

• के c and t or fबजाय का उपयोग करके एक बाइट बचाया t if c else f।
• के -1बजाय fया 'f'नॉन-हॉल्टिंग इनपुट के लिए आउटपुट करके एक बाइट को बचाया ।

exec"f,F="+"lambda n,i=0:n<2and i or %s"*2%("f([n/2,3*n+1][n%2],-~i),","i>99and-1or F(f(n),-~i)")

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

Answer 13

BiwaScheme , 151 वर्ण

(define(f n i s)(if(= s 0) 'F(if(= n 0)i(f(letrec((c(lambda(m k)(if(= m 1)k(c(if(=(mod m 2)0)(/ m 2)(+(* m 3)1))(+ k 1))))))(c n 0))(+ i 1)(- s 1)))))

आप इसे यहाँ आज़मा सकते हैं ।

Answer 14

आर , ११ ९ 107 बाइट्स

आंशिक रूप से यहाँ से जारको डबेलडैम के कोलेज़ कोड का उपयोग करता है । 0> 100 पुनरावृत्तियों (विफलता) के लिए रिटर्न ।

pryr::f(x,{N=n=0
while(x-1){while(x-1){x=`if`(x%%2,3*x+1,x/2);n=n+1}
x=n
n=0
N=N+1
if(N==100)return(0)}
N})

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

Answer 15

एपीएल नार, 115 बाइट्स, 63 चरस

{d←0⋄{⍵=1:d⋄99<d+←1:¯1⋄∇{c←0⋄{1=⍵:c⋄c+←1⋄2∣⍵:∇1+3×⍵⋄∇⍵÷2}⍵}⍵}⍵}

संभवतः लूप्स का उपयोग करना अधिक स्पष्ट होगा ... 4 फ़ंक्शन, 2 नेस्टेड और रिकसरिव हैं, और केवल केवल परिभाषित करने और = 0 के लिए प्रारंभ करने के लिए, वैरिएबल डी, 2 वें फ़ंक्शन से वैश्विक चर काउंटर के रूप में देखा जाता है।

q←{c←0⋄{1=⍵:c⋄c+←1⋄2∣⍵:∇1+3×⍵⋄∇⍵÷2}⍵}

यह 3 वां समारोह है, यह समारोह होगा कि इसके आरजीबी के लिए Collatz अनुमान को हल करने के लिए कितने कॉल हैं

{⍵=1:d⋄99<d+←1:¯1⋄∇q⍵}

यह 2 वाँ कार्य है, यदि इसका arg = 1 है, तो इसकी पुनरावृत्ति को रोकें और d को उस समय की संख्या में लौटाएं जब इसे स्वयं कहा जाता है -1; अगर खुद को 99times से अधिक कहा जाता है, तो इसकी पुनरावृत्ति को रोकें और -1 (असफल) वापस जाएं और इसके arg के लिए Collatz अनुमान की गणना करें, और Collatz अनुक्रम लंबाई मान के लिए खुद को कॉल करें। मेरे लिए भले ही यह सब लगता है कि एक बड़ी समस्या हो सकती है अगर एक वैश्विक चर और एक चर को एक ही नाम के फ़ंक्शन में परिभाषित किया जाए, जब प्रोग्रामर इसे केवल एक स्थानीय चर के रूप में देखता है।

  f←{d←0⋄{⍵=1:d⋄99<d+←1:¯1⋄∇{c←0⋄{1=⍵:c⋄c+←1⋄2∣⍵:∇1+3×⍵⋄∇⍵÷2}⍵}⍵}⍵}     
  f 2
1
  f 3
5
  f 5
¯1
  f 10
8
  f 100
13
  f 12313
7
  f 1
0

Answer 16

(एमएसीएस, कॉमन, ...) लिस्प, 105 बाइट्स

पुनरावृत्तियों के लिए प्रतिफल> 100

(defun f(n k c)(or(> c 100)(if(= n 1)(if(= k 0)c(f k 0(1+ c)))(f(if(oddp
n)(+ n n n 1)(/ n 2))(1+ k)c))))

विस्तारित:

(defun f (n k c)
  (or (> c 100)
      (if (= n 1)
          (if (= k 0) c
            (f k 0 (1+ c)))
        (f (if (oddp n) (+ n n n 1) (/ n 2))
           (1+ k) c))))
(f (read) 0 0)