शुद्धता की संख्या

Question

आज हम एक दृश्य को देखेंगे एक , Collatz समारोह से संबंधित च :

हम प्रपत्र z, f (z), f (f (z)),… a Collatz अनुक्रम का अनुक्रम कहते हैं ।

हमारे अनुक्रम में पहली संख्या , (1) , 0 है । एफ के दोहराया आवेदन के तहत , यह एक चक्र में आता है 0 → 0 →…

सबसे छोटी संख्या जो हमने अभी तक नहीं देखी है वह 1 है, जिससे (2) = 1 बना है । एफ के दोहराया आवेदन के तहत , यह एक चक्र 1 → 4 → 2 → 1 →…

अब हमने ऊपर चक्र में नंबर 2 को देखा है, इसलिए अगला सबसे छोटा नंबर a (3) = 3 है , जो चक्र 3 में गिरता है → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 → 4 → 2 → 1 →…

उपरोक्त सभी चक्रों में हमने 4 और 5 पहले ही देख लिए हैं, इसलिए अगली संख्या a (4) = 6 है ।

अब तक आप विचार प्राप्त करें। a (n) वह सबसे छोटी संख्या है जो सभी (1),…, a (n - 1) के लिए किसी Collatz अनुक्रम का हिस्सा नहीं थी ।

एक प्रोग्राम या फ़ंक्शन लिखें, जो एक सकारात्मक पूर्णांक एन दिया जाता है , एक रिटर्न (एन) देता है । बाइट्स में सबसे छोटा कोड जीतता है।

---

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

1  -> 0
2  -> 1
3  -> 3
4  -> 6
5  -> 7
6  -> 9
7  -> 12
8  -> 15
9  -> 18
10 -> 19
50 -> 114

(यह OEIS अनुक्रम A061641 है ।)

Comments

अनिवार्य OEIS

— FryAmTheEggman

क्या इनपुट n0-आधारित हो सकता है?

— लुइस मेंडो

a(n+1) = a(n) odd: 3*a(n)+1, or a(n) even: a(n)/2

— कार्ल नेप

@LuisMendo क्षमा करें, मैंने किसी तरह आपका संदेश याद किया। नहीं, चुनौती के रूप में सटीक अनुक्रम पुन: पेश करें।

— orlp

यदि a0-आधारित नहीं है, तो मुझे समझ में नहीं आता है कि आप यहाँ "0-आधारित बात" क्यों कर रहे हैं:a(n) is the smallest number that was not part of any Collatz sequences for all a(0), …, a(n − 1).

— daniero

Answer 1

जेली , 20 19 बाइट्स

ḟ@JḢ×3‘$HḂ?ÐĿ;Ṛ
Ç¡Ṫ

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

Ç¡Ṫ              Main link. No explicit arguments. Default argument: 0
 ¡               Read an integer n from STDIN and do the following n times.
Ç                  Call the helper link.
  Ṫ              Tail; extract the last element of the resulting array.


ḟ@JḢ×3‘$HḂ?ÐĿ;Ṛ  Helper link. Argument: A (array)

  J              Yield all 1-based indices of A, i.e., [1, ..., len(A)]. Since 0
                 belongs to A, there is at least one index that does belong to A.
ḟ@               Filter-false swapped; remove all indices that belong to A.
   Ḣ             Head; extract the first index (i) that hasn't been removed.
           ÐĿ    Call the quicklink to the left on i, then until the results are no
                 longer unique. Collect all unique results in an array.
         Ḃ?      If the last bit of the return value (r) is 1:
       $           Apply the monadic 3-link chain to the left to r.
    ×3‘              Yield 3r + 1.
        H        Else, halve r.
              Ṛ  Yield A, reversed.
             ;   Concatenate the results array with reversed A.

N पुनरावृत्तियों के बाद , सरणी की शुरुआत में (n + 1) का मान होगा। चूँकि हम पुराने की उलटी प्रतिलिपि के साथ नए सरणी को संक्षिप्त करते हैं, इसका मतलब है कि (एन) अंत में होगा।

Answer 2

हास्केल, 93 92 बाइट्स

c x|x<2=[[0,2]!!x]|odd x=x:c(3*x+1)|1<2=x:c(div x 2)
([y|y<-[-1..],all(/=y)$c=<<[0..y-1]]!!)

प्रयोग उदाहरण: ([y|y<-[-1..],all(/=y)$c=<<[0..y-1]]!!) 10-> 19।

c xके लिए xथोड़ा सा धोखा के साथ Collatz चक्र है x == 1। मुख्य कार्य सभी पूर्णांकों के माध्यम से लूप और उन है कि नहीं कर रहे हैं रहता है c xके लिए xमें [0..y-1]। परिभाषा का बहुत सीधा कार्यान्वयन। जैसा कि हास्केल इंडेक्स ऑपरेटर !!0-आधारित है, मैं -1इंडेक्स को ठीक करने के लिए एक (अन्यथा बेकार) नंबर शुरू करने के लिए शुरू करता हूं ।

Answer 3

MATL , 46 40 बाइट्स

Oiq:"tX>Q:yX-X<`t0)to?3*Q}2/]h5M1>]Pv]0)

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

व्याख्या

कोड में एक बाहरी forलूप है जो nCollatz अनुक्रम उत्पन्न करता है, प्रत्येक पुनरावृत्ति में एक। प्रत्येक अनुक्रम एक आंतरिक द्वारा उत्पन्न होता है do...whileपाश है कि एक में नया मान और उन्हें भंडार की गणना करता है अनुक्रम वेक्टर एक जब तक 1या 0प्राप्त की है। जब हम अनुक्रम के साथ किया जाता है, तो वेक्टर को उलट दिया जाता है और एक वैश्विक वेक्टर में बदल दिया जाता है जिसमें सभी पिछले अनुक्रमों से मान शामिल होते हैं। इस वेक्टर में बार-बार मूल्य हो सकते हैं। अनुक्रम वेक्टर का उलटना यह सुनिश्चित करता है कि बाहरी लूप के अंत में वांछित परिणाम (अंतिम अनुक्रम का प्रारंभिक मूल्य) वैश्विक वेक्टर के अंत में होगा।

छद्म कोड :

1  Initiallization
2  Generate n sequences (for loop):
3    Compute initial value for the k-th sequence
4    Generate the k-th sequence (do...while loop)
5      Starting from latest value so far, apply the Collatz algorithm to get next value
6      Update sequence with new value 
7      Check if we are done. If so, exit loop. We have the k-th sequence
8    Update vector of seen values
9  We now have the n sequences. Get final result

टिप्पणी कोड :

O           % Push 0                                                          1
iq:         % Input n. Generate [1 2 ... n-1]                                 ·
"           % For loop: repeat n-1 times. Let k denote each iteration         2
  t         %   Duplicate vector of all seen values                           · 3
  X>Q       %   Take maximum, add 1                                           · ·
  :         %   Range from 1 to that: these are potential initial values      · ·
  y         %   Duplicate vector of all seen values                           · ·
  X-X<      %   Set difference, minimum: first value not seen                 · ·
  `         %   Do...while: this generates the k-th Collatz sequence          · 4
    t0)     %     Duplicate, push last value of the sequence so far           · · 5
    to      %     Duplicate, parity: 1 if odd, 0 if even                      · · ·
    ?       %     If odd                                                      · · ·
      3*Q   %       Times 3, plus 1                                           · · ·
    }       %     Else                                                        · · ·
      2/    %       Half                                                      · · ·
    ]       %     End if                                                      · · ·
    h       %     Concatenate new value of the sequence                       · · 6
    5M      %     Push the new value again                                    · · 7
    1>      %     Does it exceed 1? This is the loop condition                · · ·
  ]         %   End do...while. The loops ends when we have reached 0 or 1    · ·
  P         %   Reverse the k-th Collatz sequence                             · 8
  v         %   Concatenate with vector of previously seen values             · ·
]           % End for                                                         ·
0)          % Take last value. Implicitly display.                            9

Answer 4

ब्रेकीलॉग , 70 67 65 63 62 बाइट्स

,[]:?:1ih.
,0<=X=,?'eXg{t{:2/.*?|:3*+.}gB,(?.sB;?:Bc:2&.)}:?c.

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

Answer 5

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

r,=s={-1}
exec'n=r=min({r+1,r+2,r+3}-s)\nwhile{n}-s:s|={n};n=(n/2,3*n+1)[n%2]\n'*input()
print r

इस तथ्य का लाभ उठाता है कि 3 के सभी गुणक शुद्ध हैं। Ideone पर इसका परीक्षण करें ।

यह काम किस प्रकार करता है

पहली पंक्ति में, r,=s={-1}सेट रों = {-1} (सेट) और आर = -1 ।

अगला हम STDIN से एक पूर्णांक पढ़ते हैं, एक निश्चित स्ट्रिंग को दोहराते हैं जो कई बार होती है, फिर इसे निष्पादित करते हैं। यह निम्नलिखित पायथन कोड के बराबर है।

for _ in range(input())
    n=r=min({r+1,r+2,r+3}-s)
    while{n}-s:
        s|={n}
        n=(n/2,3*n+1)[n%2]

प्रत्येक पुनरावृत्ति में, हम {r + 1, r + 2, r + 3} के सबसे छोटे सदस्य को खोजने से शुरू करते हैं जो s से संबंधित नहीं है । पहले पुनरावृत्ति में, यह आर 0 के रूप में आरंभीकरण करता है ।

बाद के सभी रनों में, s (और वसीयत) में कुछ r + 1 , r + 2 और r + 3 होते हैं , लेकिन उनमें से सभी कभी नहीं, क्योंकि 3 के सभी गुणक शुद्ध होते हैं। इस बयान को सत्यापित करने के लिए, देख सकते हैं कि कोई एक से अधिक मीटर की 3 फार्म की है 3k + 1 । यह केवल 2 मी पूर्व संभव छवि के रूप में छोड़ देता है , जो कि 3 का एक गुणक भी है । इस प्रकार, m किसी भी संख्या के Collatz अनुक्रम में प्रकट नहीं हो सकता है जो m से कम है , और इसलिए शुद्ध है।

पहचान करने के बाद आर और आरंभ n , हम साथ Collatz समारोह लागू n=(n/2,3*n+1)[n%2], में से प्रत्येक के मध्यवर्ती मूल्य जोड़ने n सेट करने के लिए रों साथ s|={n}। एक बार जब हम एक संख्या एन का सामना करते हैं जो पहले से ही एस में है , {n}-sतो एक खाली सेट निकलेगा, और पुनरावृत्ति बंद हो जाती है।

R का अंतिम मान अनुक्रम का वांछित तत्व है।

Comments

इसे जोड़ने के लिए, एक प्रमाण कि 3 के सभी गुणक शुद्ध हैं। किसी भी Collatz अनुक्रम modulo को देखें। 3x + 1 नियम के किसी भी अनुप्रयोग के बाद, modulo है 1. x / 2 नियम के आवेदन के बाद, mod 1 2 हो जाता है, और mod 2 बन जाता है। 1. न तो नियम एक से अधिक उत्पन्न कर सकता है 3 का, जब तक कि शुरुआती मूल्य पहले से ही 3 का एक बड़ा हिस्सा नहीं था, जो आधा हो गया। लेकिन वे बड़े मूल्य अभी तक उत्पन्न नहीं हुए हैं, इसलिए n = 0 (mod 3) => n शुद्ध है।

— orlp

Answer 6

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

VtQ=+Y.u?%N2h*3N/N2Z)=Zf!}TYhZ)Z

परीक्षण सूट।

Answer 7

जावा, 148 बाइट्स

int a(int n){if(n<2)return 0;int f=a(n-1),b,i,c;do{f++;for(b=1,i=1;i<n;i++)for(c=i==2?4:a(i);c>1;c=c%2>0?c*3+1:c/2)b=c==f?0:b;}while(b<1);return f;}

Ideone यह! (चेतावनी: शून्य अनुकूलन के कारण घातीय जटिलता।)

इसे do...whileलूप से forलूप में बदलना गोल्फ खिलाड़ी होगा, लेकिन मुझे ऐसा करने में परेशानी हो रही है।

गोल्फ सलाह हमेशा की तरह स्वागत है।

Comments

ज्यादा नहीं, लेकिन आप कर सकते हैं गोल्फ 1 बदलकर बाइट बंद for(b=1,i=1;i<n;i++)करने के लिए for(b=1,i=0;++i<n;)। Btw, मैं समझता हूं कि आपके विचारक 50 के लिए परीक्षण के मामले को क्यों याद कर रहे हैं, लेकिन यह 10 को भी क्यों याद करता है? यह एक समस्या के बिना इसे संभाल सकता है।

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

@ केविनक्रूजसेन क्योंकि फॉर्मेटिंग खराब होगी।

— लीक नून

नहीं सबसे अच्छा सुधार है, लेकिन मैं (147 बाइट्स) बहुत अधिक समय खर्च नहीं किया है ...int a(int n){if(n<2)return 0;int f=a(n-1),b=0,i,c;for(;b<1;){f++;for(b=1,i=1;i<n;i++)for(c=i==2?4:a(i);c>1;c=c%2>0?c*3+1:c/2)b=c==f?0:b;}return f;}

— प्रहार

Answer 8

पर्ल 6, 96

my @s;my $a=0;map {while ($a=@s[$a]=$a%2??3*$a+1!!$a/2)>1 {};while @s[++$a] {}},2..slurp;$a.say;

पर्ल 5 उत्तर के आधार पर । Perl6 सिंटैक्स से थोड़ा लंबा है क्योंकि Perl5 सिंटैक्स की तुलना में कम क्षमा है, लेकिन मैं अभी इसके लिए समझौता करूंगा।

Answer 9

PHP, 233 124 बाइट्स

<?$n=$argv[1];for($c=[];$n--;){for($v=0;in_array($v,$c);)$v++;for(;$n&&!in_array($v,$c);$v=$v&1?3*$v+1:$v/2)$c[]=$v;}echo$v;

समारोह के लिए +4:

function a($n){for($c=[];$n--;){for($v=0;in_array($v,$c);)$v++;for(;$n&&!in_array($v,$c);$v=$v&1?3*$v+1:$v/2)$c[]=$v;}return$v;}

Answer 10

पर्ल 5 - 74 बाइट्स

map{0 while 1<($a=$c[$a]=$a%2?$a*3+1:$a/2);0 while$c[++$a]}2..<>;print$a+0

यह एक बहुत ही सरल उपाय है। यह बार-बार Collatz फ़ंक्शन को वैरिएबल पर लागू करता है $aऔर उस सरणी में स्टोर करता @cहै जिसे मान देखा गया है, फिर 0 या 1 तक पहुंचने के बाद यह $aतब तक बढ़ जाता है जब तक कि यह एक संख्या नहीं है जिसे अभी तक नहीं देखा गया है। यह इनपुट माइनस 2 के बराबर कई बार दोहराया जाता है, और अंत में आउटपुट का मान होता $aहै।

Answer 11

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

f=If[EvenQ@#,#/2,3#+1]&;a@n_:=(b={i=c=0};While[i++<n-1,c=First[Range@Max[#+1]~Complement~#&@b];b=b~Union~NestWhileList[f,c,f@#>c&]];c)

पढ़ने में आसान प्रारूप:

f = If[EvenQ@#, #/2, 3#+1] &;                        Collatz function
a@n_ := (                                            defines a(n)
  b = {i = c = 0};                                   initializations
                                                       b is the growing sequence
                                                       of cycles already completed
  While[i++ < n - 1,                                 computes a(n) recursively
    c = First[Range@Max[# + 1]~Complement~# & @b];   smallest number not in b
    b = b~Union~NestWhileList[f, c, f@# > c &]       apply f to c repeatedly
                                                       until the answer is smaller
                                                       than c, then add this new
                                                       cycle to b
    ]
  ; c)                                                 output final value of c