Collatz अनुमान (OEIS A006577)

Question

यह Collatz अनुमान (OEIS A006577 ) है:

• पूर्णांक n > 1 से प्रारंभ करें ।
• निम्नलिखित चरणों को दोहराएं:
  • यदि n सम है, तो इसे 2 से भाग दें।
  • यदि n विषम है, तो इसे 3 से गुणा करें और 1 जोड़ें।

यह साबित होता है कि सभी सकारात्मक पूर्णांकों के लिए 5 * 2 ⁶⁰ , या लगभग 5764000000000000000 , n अंततः 1 बन जाएगा ।

आपका काम यह पता लगाना है कि 1 तक पहुंचने के लिए (इसे आधा करने या ट्रिपलिंग-प्लस-वन) के कितने पुनरावृत्तियों का पता चलता है ।

प्रासंगिक xkcd :)

नियम:

• सबसे छोटा कोड जीतता है।
• यदि संख्या <2 इनपुट है, या एक गैर-पूर्णांक, या एक गैर-संख्या है, तो आउटपुट कोई फर्क नहीं पड़ता।

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

2  -> 1
16 -> 4
5  -> 5
7  -> 16

Answer 1

GolfScript, 24 23 21 20 18 वर्ण

~{(}{3*).2%6\?/}/,

स्टड पर इनपुट मानता है। ऑनलाइन टेस्ट

Comments

1+के रूप में विशेष आवरण है )।

— पीटर टेलर

@PeterTaylor बेशक, उस बारे में भूल गए;)

— अस्थिरता

अच्छा काम! <! - गद्दी ->

— पीटर टेलर

@Peter: <-! -> टिप्पणियों में काम न करें। इसकी जगह इसका इस्तेमाल करें ।

— इल्मरी करोनन

या यह।

— टिमवी

Answer 2

सी - ५० ४ characters अक्षर

दुर्भाग्यवश C C को मूल I / O के लिए एक भयानक मात्रा में कोड की आवश्यकता होती है, इसलिए सभी को छोटा करके UI को थोड़ा अनपेक्षित बना दिया जाता है।

b;main(a){return~-a?b++,main(a&1?3*a+1:a/2):b;}

उदाहरण के लिए इसे संकलित करें gcc -o 1 collatz.c। इनपुट अंतरिक्ष से अलग किए गए अंकों के साथ एकतरफा है, और आपको इसका उत्तर निकास कोड में मिलेगा। संख्या 17 के साथ एक उदाहरण:

$> ./1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
$> echo $?
12
$>

Comments

return~-a?बचाता है 1. इसके अलावा चलती b++करने के लिए ?मामले को बचाने चाहिए b--।

— ugoren

हेहे आप नियमों झुकने रहे हैं तो रचनात्मकता के लिए पी 1 और एक भाषा का प्रयोग आम तौर पर गोल्फ के लिए नहीं इस्तेमाल किया: बहुत

— दरवाज़े

शुक्रिया! इसे लिखते समय मैं मदहोश हो गया होगा। :)

— Fors

Answer 3

पर्ल 34 (+1) वर्ण

$\++,$_*=$_&1?3+1/$_:.5while$_>1}{

$\हमेशा की तरह, अंतिम आउटपुट के लिए दुर्व्यवहार करना। -pकमांड लाइन विकल्प के साथ चलाएं , इनपुट से लिया गया है stdin।

इलायस वान ओओटगेम के कारण एक बाइट को बचाया । विशेष रूप से, प्रेक्षक कि निम्नलिखित दो समतुल्य हैं:

$_=$_*3+1
$_*=3+1/$_

हालांकि एक बाइट अब, यह कम करके दो बाइट्स की बचत होती है $_/2बस .5।

नमूना उपयोग:

$ echo 176 | perl -p collatz.pl
18

---

PHP 54 बाइट्स

<?for(;1<$n=&$argv[1];$c++)$n=$n&1?$n*3+1:$n/2;echo$c;

इस चुनौती के लिए लकड़ी के चम्मच पुरस्कार के लिए जावास्क्रिप्ट का आर्कषण थोड़ा कम हो गया है। इस समस्या के साथ रचनात्मकता के लिए बहुत अधिक जगह नहीं है, हालांकि। इनपुट को कमांड लाइन तर्क के रूप में लिया जाता है।

नमूना उपयोग:

$ php collatz.php 176
18

Comments

मुझे यह जानने में थोड़ी देर लगी कि बेजोड़ कोष्ठक क्या कर रहे हैं :)

— marinus

$_टर्नरी में दोहराव व्यर्थ लगता है, आप *=इस तरह का उपयोग करके किसी अन्य चरित्र को दाढ़ी कर सकते हैं $\++,$_*=$_&1?3+1/$_:.5while$_>1}{:। गुणा करने का 1/$_प्रभाव उतना ही होता है +1, जितना $_*=3+1/$_कि ठीक काम करता है

— एलियास वान ओटगेम

@EliasVanOotegem $_*=3+1/$_शानदार है, धन्यवाद!

— प्रिमो

Answer 4

गणितज्ञ (35)

If[#>1,#0@If[OddQ@#,3#+1,#/2]+1,0]&

उपयोग:

If[#>1,#0[If[OddQ@#,3#+1,#/2]]+1,0]&@16
>> 4

Comments

यह एक वैध कार्य नहीं है, 10.3 अंत में एक बदमाश के बारे में शिकायत करता है

— कैलक्यूलेटरफिलीन

@ तर्क को बुला रहा है, मुझे नहीं पता कि यह वहां क्यों था, बस एक त्वरित संपादन

— मील

समझदार होना चाहिए :)

— कैलक्यूलेटरफैनलाइन

Answer 5

जैसा कि मैं आमतौर पर करता हूं, मैं खुद से जवाब देना शुरू करूंगा।

जावास्क्रिप्ट, 46 44 वर्ण (कंसोल पर चलाएँ)

for(n=prompt(),c=1;n>1;n=n%2?n*3+1:n/2,++c)c

Comments

अगर आपने कहा कि अगर यह नॉन-पूर्णांक है, तो आउटपुट ~ ~ प्रांप्ट की बात क्या है? आप ~~ से छुटकारा पाकर दो पात्रों को बचा सकते हैं।

— रेसोरथ

पी धन्यवाद: @Resorath आह, जे एस ऑटो कास्टिंग के बारे में भूल

— दरवाज़े

Answer 6

जावा, 165, 156, 154,134,131,129,128 , 126 ( क्रिया भाषाओं को कुछ प्यार की भी ज़रूरत है)

class a{public static void main(String[]a){for(int x=Short.valueOf(a[0]),y=0;x>1;x=x%2<1?x/2:x*3+1,System.out.println(++y));}}

सभी अंदर के लिए किया जाता है

for(int x=Short.valueOf(a[0]),y=0;x>1;x=x%2<1?x/2:x*3+1,System.out.println(++y))

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

मैंने इंटीजर को शॉर्ट में बदल दिया।

Comments

आप की लंबाई को आसानी से बचा सकते हैं i(,++y)। के <बजाय का उपयोग करके आप दो और बचा सकते हैं ==।

— पीटर टेलर

@PeterTaylor आप सही हैं, मेरी तुलना <के साथ कम होगी, लेकिन मैं पूर्व वेतन वृद्धि के हिस्से को नहीं समझता

— jsedano

आपकी दूसरी टर्नरी के दो पहलू संरचनात्मक रूप से समान हैं, इसलिए आप टर्नरी को पुनरावर्ती कॉल के पहले तर्क में धकेल सकते हैं।

— पीटर टेलर

ओह

— माय गॉड थेट ब्रिलियंट

मैं जानता हूँ कि यह करीब 3.5 साल हो गया है, लेकिन आप अभी भी द्वारा गोल्फ यह कर सकते हैं 5 बाइट्स : class a{public static void main(String[]a){for(int x=new Short(a[0]),y=0;x>1;System.out.println(++y))x=x%2<1?x/2:x*3+1;}}किए गए परिवर्तन: 1) बदला Short.valueOf(...)के साथ new Short(...)के लिए -4 बाइट्स और 2) मैं डाल दिया है x=x%2<1?x/2:x*3+1;के शरीर में for-loop से छुटकारा पाने के -1 बाइट के लिए अल्पविराम ।

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

Answer 7

रेम्बु : 28

u[++jE1 AeEV?a[d2A][a1M3a]]j

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

हालांकि REBOL के अपने निर्माता कार्ल सासेनराथ मुझसे कहा था उन्होंने पाया Rebmu 'पढ़ने योग्य नहीं ", वह व्यस्त है और समय वास्तव में के माध्यम से सुअर-लैटिन की तरह परिवर्तन अभ्यास करने के लिए नहीं है unmushing । यह वास्तव में केवल रूपांतरित होता है:

u [
    ++ j
    e1 a: e ev? a [
        d2 a
    ] [
        a1 m3 a
    ]
]
j

ध्यान दें कि अंतरिक्ष एक पाने के लिए आवश्यक था एक: एक के बजाय एक । यह एक "सेट-शब्द है!" और मूल्यांकनकर्ता ने संकेत दिया कि प्रतीक असाइनमेंट को ट्रिगर करने के लिए टाइप करता है।

अगर यह बिना लिखा हुआ (अभी तक अजीब-सा लिखा हुआ), तो आपको मिलेगा:

until [
    ++ j
    1 == a: either even? a [
        divide a 2
    ] [
        add 1 multiply 3 a
    ]
 ]
 j

रूबी की तरह, Rebol, ब्लॉक को उनके अंतिम मूल्य का मूल्यांकन करता है। UNTIL लूप लूप की एक जिज्ञासु रूप है जो लूप की स्थिति नहीं लेता है, यह सिर्फ लूपिंग बंद कर देता है जब इसका ब्लॉक FALSE या NONE नहीं है। तो इस बिंदु पर कि 1 ==Collatz सशर्त के परिणाम में A (असाइन करने के लिए तर्क) का परिणाम (या तो एक IF-ELSE है जो उस शाखा का मूल्यांकन करता है जो इसे चुनता है) ... लूप टूट जाता है।

J और K को Rebmu में पूर्णांक मान शून्य पर आरंभीकृत किया गया है। और जैसा कि पूर्वोक्त, पूरी बात अंतिम मूल्य का मूल्यांकन करती है। तो कार्यक्रम के अंत में एक जे संदर्भ का मतलब है कि आपको पुनरावृत्तियों की संख्या मिलती है।

उपयोग:

>> rebmu/args [u[++jE1 AeEV?a[d2A][a1M3a]]j] 16
== 4

Answer 8

पायथन उत्तर, 48

मुझे यकीन नहीं है कि इससे छोटी अभिव्यक्ति नहीं है n=3*n+1;n/=1+n%2*5;। मुझे संभवतः एक ही लंबाई के एक दर्जन अलग-अलग अभिव्यक्ति मिलीं ...

i=0
n=input()
while~-n:n=3*n+1;n/=1+n%2*5;i+=1
i

संपादित करें: मैंने एक और समाधान पाया है जो कभी भी संघर्ष नहीं करेगा, लेकिन साझा नहीं करने के लिए बहुत मजेदार है।

s='s'
i=s
n=i*input()
while 1:
 while n==n[::2]+n[::2]:i+=s;n=n[::2]
 if n==s:i.rindex(s);break
 n=3*n+s
 i+=s

Comments

मेरा दिमाग अब दर्द करता है।

— डानिएरो

@daniero दूसरा समाधान सिर्फ आपके लिए है।

— बूथ

ओह वाह। मैं सम्मानित हूँ!

— डानिएरो

(n//2,n*3+1)[n%2]छोटा है।

— Evpok

@ ईवोक n/2काम नहीं करेगा साथ ही हमें पता है कि यह भी है?

— जॉर्ज

Answer 9

एपीएल (31)

A←0⋄A⊣{2⊤⍵:1+3×⍵⋄⍵÷2}⍣{⍺=A+←1}⎕

Comments

पुराना उत्तर, फिर भी, 27:{1=⍵:0⋄2|⍵:1+∇1+3×⍵⋄1+∇⍵÷2}

— उरियेल

{1=⍵:0⋄1+∇⊃⍵⌽0 1+.5 3×⍵}

— ngn

Answer 10

जे, 30 अक्षर

<:#-:`(1+3&*)`]@.(2&|+1&=)^:a:

वांछित की तुलना में काफी लंबा निकला

उपयोग:

   <:#-:`(1+3&*)`]@.(2&|+1&=)^:a:2
1
   <:#-:`(1+3&*)`]@.(2&|+1&=)^:a:16
4
   <:#-:`(1+3&*)`]@.(2&|+1&=)^:a:5
5
   <:#-:`(1+3&*)`]@.(2&|+1&=)^:a:7
16
   <:#-:`(1+3&*)`]@.(2&|+1&=)^:a:27
111

• -:`(1+3&*)`]तीन क्रियाओं से बना एक गेरुंड है, जिसका उपयोग तीन अवसरों पर किया जाता है। -:का अर्थ है "आधा", (1+3&*)या (1+3*])गुणा कदम और ](पहचान) एड्स समाप्ति को एन्कोड करता है।

• 2&|+1&=गेरुंड के लिए एक सूचकांक बनाता है। सचमुच, "विभाजन के बाद शेष दो से अधिक है कि क्या यह एक के बराबर है"।

• #verb^:a:फ़ंक्शन को तब तक पुनरावृत्त करता है जब तक कि परिणाम स्थिर नहीं होता है (यहां, स्पष्ट रूप से मजबूर किया गया), चरणों को इकट्ठा करते समय, फिर उन्हें गिनता है। @ जेबी से चोरी । <:प्रश्न आवश्यकताओं के साथ संरेखित करने के लिए एक-एक करके चरण गणना को घटाएं।

Comments

जब भी मैं एक J प्रस्तुत करता हूं, तो मैं स्माइली गिनता हूं। यह एक बहुत अच्छी तरह से करता है: <:, #-:, :`(, &*), =), )^:।

— प्रिमो

@primo अच्छा; उनकी व्याख्या चाहते हैं? :-) का <:अर्थ है "घटाव" या "कम या बराबर", #जिसका अर्थ है "या" n बार "की गिनती, -:जिसका अर्थ है" आधा "या" एप्सिलॉन-समानता ", :`(जिसका अर्थ है" हलवे " के अंत में, बीच में टाई। एक गेरुंड और एक बाएं कोष्ठक में दो क्रिया (समूहन के लिए प्रयुक्त)। &*)का अर्थ है "sth गुणा के बंधुआ" (गुणन के साथ 3 बंध "" तीन तीन "ऑपरेटर बनाता है) और समूहीकरण का अंत। =समानता की जाँच करता है या, एकात्मक अर्थ में, स्व-वर्गीकरण। ^:शक्ति संयोजन (क्रिया पुनरावृत्ति) है। चूंकि बहुत सारे जे क्रिया एक बृहदान्त्र के साथ समाप्त होते हैं, ... :-)

— जॉन ड्वोरक

वर्षों बाद ... बेहतर लूप ब्लॉक: '- & 2 # (> & 1 * -: + 2 & | * +: +>: @ -:) ^: a:' -> -1 char। : पी

— यादृच्छिक

अधिक वर्षों बाद ... <:#a:2&(<*|+|6&*%~)19 बाइट्स (-11)

— मील

Answer 11

गैम्बिट योजना, 106 98 वर्ण, 40 कोष्ठक

(let((f(lambda(x)(cond((= x 1) 0)((odd? x)(+ 1(f(+ 1(* 3 x)))))(else(+ 1(f(/ x 2))))))))(f(read)))

91 89 वर्ण सीधे परिभाषित करने के साथ

(define(f x)(cond((= x 1)0)((odd? x)(+ 1(f(+ 1(* 3 x)))))(else(+ 1(f(/ x 2))))))(f(read))

Comments

मैं लंबे समय से आसपास नहीं रहा हूं, लेकिन मेरा ध्यान है कि आमतौर पर लोग प्रति प्रोग्रामिंग भाषा में 1 उत्तर देते हैं।

— जेदानो

क्षमा करें, मुझे उस बारे में पता नहीं था :)

— वैलेंटाइन क्लिंट

पायथन को हटाने के लिए संपादित किया गया।

— वैलेंटाइन क्लेमेंट

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

— ब्रेडबॉक्स

@breadbox सच नहीं है। मैं प्रति भाषा एक उत्तर देता हूं यदि प्रत्येक समाधान दूसरे की तुलना में अपने आप में दिलचस्प है। यदि दोनों समाधान उन दोनों के समान दिलचस्प हैं (एक ही एल्गोरिदम, कोई दिलचस्प भाषा ट्रिक्स नहीं), तो मैं उन्हें एक के रूप में पोस्ट करता हूं। आम तौर पर मैं कई समाधानों को पोस्ट नहीं करता क्योंकि मैं पहले एक भाषा चुनता हूं, फिर उस भाषा में समस्या का समाधान करता हूं - फिर मैं आमतौर पर एक अलग भाषा में एक ही लिखने के लिए बहुत आलसी हूं - या मैं अभी तक एक और प्रोग्रामिंग सीखने के लिए यात्रा पर निकलता हूं भाषा: हिन्दी।

— जॉन ड्वोरक

Answer 12

पॉवरशेल: 77 74 71 70 61

गोल्फ कोड:

for($i=(read-host);$i-ne1;$x++){$i=(($i/2),(3*$i+1))[$i%2]}$x

---

टिप्पणियाँ:

मैंने मूल रूप से उपयोगकर्ता इनपुट को एक पूर्णांक के लिए मजबूर किए बिना लेने की कोशिश की, लेकिन यह एक दिलचस्प तरीके से टूट गया। कोई भी अजीब इनपुट गलत प्रक्रिया करेगा, लेकिन यहां तक ​​कि इनपुट ठीक काम करेगा। मुझे यह महसूस करने में एक मिनट लगा कि क्या चल रहा है।

गुणा या जोड़ प्रदर्शन करते समय, PowerShell पहले स्ट्रिंग के रूप में अन-टाइप किए गए इनपुट का व्यवहार करता है। तो, '5'*3+116 के बजाय '5551' बन जाता है। यहां तक ​​कि इनपुट भी ठीक व्यवहार करते हैं क्योंकि पावरशेल में स्ट्रिंग्स के खिलाफ विभाजन के लिए डिफ़ॉल्ट कार्रवाई नहीं है। यहां तक ​​कि विषम संख्याओं के माध्यम से प्रगति करने वाले इनपुट भी ठीक काम करते हैं, क्योंकि जब तक पॉवरशेल लूप में एक विषम संख्या में हो जाता है, तब तक चर पहले से ही गणित के संचालन से पूर्णांक के लिए मजबूर था।

Danko Durbic को इंगित करने के लिए धन्यवाद कि मैं गुणा गुणन को उल्टा कर सकता हूं, और read-hostपहले ही ऑब्जेक्ट पर PowerShell के संचालन के बाद से इंट कास्ट नहीं करना है ।

पॉवरशेल गोल्फर की युक्ति: कुछ परिदृश्यों के लिए, जैसे यह switchधड़कता है if/else। यहाँ, अंतर 2 वर्ण था।

डैंको डर्बिक के प्रोटिप सौजन्य : इस विशेष परिदृश्य के लिए, switch8 और वर्णों को सहेजने के बजाय एक सरणी का उपयोग किया जा सकता है !

गैर-पूर्णांक मानों या दो से कम पूर्णांक के लिए कोई त्रुटि जाँच नहीं है।

यदि आप स्क्रिप्ट का ऑडिट करना चाहते हैं, तो स्क्रिप्ट ;$iमें आखिरी क्लोज ब्रेस से ठीक पहले डालें ।

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

---

टिप्पणियों के साथ अघोषित कोड:

# Start for loop to run Collatz algorithm.
# Store user input in $i.
# Run until $i reaches 1.
# Increment a counter, $x, with each run.
for($i=(read-host);$i-ne1;$x++)
{
    # New $i is defined based on an array element derived from old $i.
    $i=(
        # Array element 0 is the even numbers operation.
        ($i/2),
        # Array element 1 is the odd numbers operation.
        (3*$i+1)
    # Array element that defines the new $i is selected by $i%2.
    )[$i%2]
}

# Output $x when the loop is done.
$x

# Variable cleanup. Don't include in golfed code.
rv x,i

---

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

नीचे ऑडिटिंग सक्षम के साथ कुछ नमूने दिए गए हैं। मैंने इनपुट और अंतिम गणना में लेबल जोड़कर और Collatz मानों को अलग करने के लिए रिक्ति में डालकर, आउटपुट को स्पष्टता के लिए कुछ संपादित किया है।

---
Input: 2

1

Steps: 1

---
Input: 16

8
4
2
1

Steps: 4

---
Input: 5

16
8
4
2
1

Steps: 5

---
Input: 7

22
11
34
17
52
26
13
40
20
10
5
16
8
4
2
1

Steps: 16

---
Input: 42

21
64
32
16
8
4
2
1

Steps: 8

---
Input: 14

7
22
11
34
17
52
26
13
40
20
10
5
16
8
4
2
1

Steps: 17

---
Input: 197

592
296
148
74
37
112
56
28
14
7
22
11
34
17
52
26
13
40
20
10
5
16
8
4
2
1

Steps: 26

---
Input: 31

94
47
142
71
214
107
322
161
484
242
121
364
182
91
274
137
412
206
103
310
155
466
233
700
350
175
526
263
790
395
1186
593
1780
890
445
1336
668
334
167
502
251
754
377
1132
566
283
850
425
1276
638
319
958
479
1438
719
2158
1079
3238
1619
4858
2429
7288
3644
1822
911
2734
1367
4102
2051
6154
3077
9232
4616
2308
1154
577
1732
866
433
1300
650
325
976
488
244
122
61
184
92
46
23
70
35
106
53
160
80
40
20
10
5
16
8
4
2
1

Steps: 106

---
Input: 6174

3087
9262
4631
13894
6947
20842
10421
31264
15632
7816
3908
1954
977
2932
1466
733
2200
1100
550
275
826
413
1240
620
310
155
466
233
700
350
175
526
263
790
395
1186
593
1780
890
445
1336
668
334
167
502
251
754
377
1132
566
283
850
425
1276
638
319
958
479
1438
719
2158
1079
3238
1619
4858
2429
7288
3644
1822
911
2734
1367
4102
2051
6154
3077
9232
4616
2308
1154
577
1732
866
433
1300
650
325
976
488
244
122
61
184
92
46
23
70
35
106
53
160
80
40
20
10
5
16
8
4
2
1

Steps: 111

---
Input: 8008135

24024406
12012203
36036610
18018305
54054916
27027458
13513729
40541188
20270594
10135297
30405892
15202946
7601473
22804420
11402210
5701105
17103316
8551658
4275829
12827488
6413744
3206872
1603436
801718
400859
1202578
601289
1803868
901934
450967
1352902
676451
2029354
1014677
3044032
1522016
761008
380504
190252
95126
47563
142690
71345
214036
107018
53509
160528
80264
40132
20066
10033
30100
15050
7525
22576
11288
5644
2822
1411
4234
2117
6352
3176
1588
794
397
1192
596
298
149
448
224
112
56
28
14
7
22
11
34
17
52
26
13
40
20
10
5
16
8
4
2
1

Steps: 93
---

इनपुट संख्या के बारे में दिलचस्प बिट्स जो प्रश्न के परीक्षण मामलों से नहीं हैं:

• 14और 197कर रहे हैं कीथ नंबर
• 31एक मेर्सेन प्राइम है
• 6174है Kaprekar के लगातार
• और अंत में, मुझे पसंद है 8008135। और नंबरफिल , जाहिर है।

Comments

अच्छा! आप अभी भी इसे कुछ हद तक छोटा कर सकते हैं, switchसाथ में$i=(($i/2),($i*3+1))[$i%2]

— Danko Durbić

इसके अलावा, आप कन्वर्ट करने के लिए की जरूरत नहीं है read-hostबस बदलने - नंबर करने के लिए $i*3करने के लिए 3*$i।

— डैंको डर्बिएक

स्विच के बजाय एक सरणी? प्रतिभाशाली! और $i*3चारों ओर स्वैपिंग - मैंने पहले से ही क्यों नहीं सोचा?

— इज़ी

param($i)for(;$i-ne1;$x++){$i=(($i/2),(3*$i+1))[$i%2]}$x- 56 बाइट पाने के लिए एक पैरामीटर के लिए रीड-होस्ट को स्वैप करें । इसे ऑनलाइन लिंक आज़माएं

— TessellatingHeckler

Answer 13

80386 विधानसभा, 16 बाइट्स

यह उदाहरण AT & T सिंटैक्स का उपयोग करता है और फास्टकल कॉल कन्वेंशन, तर्क में जाता है ecx:

collatz:
        or $-1,%eax              # 3 bytes, eax = -1;
.Loop:  inc %eax                 # 1 byte,  eax += 1;
        lea 1(%ecx,%ecx,2),%edx  # 4 bytes, edx = 3*ecx + 1;
        shr %ecx                 # 2 bytes, CF = ecx & 1;
                                 #          ecx /= 2;
                                 #          ZF = ecx == 0;
        cmovc %edx,%ecx          # 3 bytes, if (CF) ecx = edx;
        jnz .Loop                # 2 bytes, if (!ZF) goto .Loop;
        ret                      # 1 byte,  return (eax);

यहां मशीन कोड के परिणामी 16 बाइट्स दिए गए हैं:

83 c8 ff 40 8d 54 49 01 d1 e9 0f 42 ca 75 f4 c3

Answer 14

ब्रेकीलॉग , 16 बाइट्स

1b|{/₂ℕ|×₃+₁}↰+₁

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

व्याख्या

         Either:
  1        The input is 1.
  b        In which case we unify the output with 0 by beheading the 1
           (which removes the leading digit of the 1, and an "empty integer"
           is the same as zero).
|        Or:
  {        This inline predicate evaluates a single Collatz step on the input.
           Either:
    /₂       Divide the input by 2.
    ℕ        And ensure that the result is a natural number (which is
             equivalent to asserting that the input was even).
  |        Or:
    ×₃+₁     Multiply the input by 3 and add 1.
  }
  ↰        Recursively call the predicate on this result.
  +₁       And add one to the output of the recursive call.

एक ही बाइट गिनती पर एक वैकल्पिक समाधान:

;.{/₂ℕ|×₃+₁}ⁱ⁾1∧

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

;.          The output of this is a pair [X,I] where X is the input and
            I will be unified with the output.
{/₂ℕ|×₃+₁}  This is the Collatz step predicate we've also used above.
ⁱ⁾          We iterate this predicate I times on X. Since we haven't actually
            specified I, it is still a free variable that Brachylog can backtrack
            over and it will keep adding on iterations until the next
            constraint can be satisfied.
1           Require the result of the iteration to be 1. Once this is
            satisfied, the output variable will have been unified with
            the minimum number of iterations to get here.
∧           This AND is just used to prevent the 1 from being implicitly
            unified with the output variable as well.

Answer 15

गोल्फस्क्रिप्ट (23 वर्ण)

~{.1&{.3*)}*.2/.(}do;],

ऑनलाइन टेस्ट

Answer 16

एफ # - 65 चार्ट

let rec c n=function 1->n|i->c(n+1)(if i%2=0 then i/2 else i*3+1)

Answer 17

पायथन 68 58 54 52 चार

f=lambda n:1+(n-2and f((n/2,3*n+1)[n%2]));f(input())

सुझावों के लिए बकुरीउ और बूथबी को धन्यवाद :)

Comments

आप n%2and 3*n+1or n/25 अक्षरों को बचाने के लिए उपयोग कर सकते हैं । इसके अलावा python2 में आप कॉल intको 58 बाइट्स तक कम कर सकते हैं ।

— बकुरीउ

ओह, तुम भी उससे छोटा हो सकता है [n/2,3*n+1][n%2]:।

— बूथबी

यह निफ्टी है!

— वैलेंटाइन क्लेमेंट

क्या यह अजगर 2.7 है? मुझे पायथन 3.5.1 में कोई त्रुटि मिलती है? unsupported operand type(s) for -: 'str' and 'int'

— जॉर्ज

Answer 18

रेटिना , 43 बाइट्स

11
2
(2+)1
$1$1$0$0$0$0
2.*
$0x
)`2
1
1?x
1

इनपुट लेता है और आउटपुट को प्रिंट करता है।

प्रत्येक पंक्ति को अपनी फ़ाइल पर जाना चाहिए। 1 बाइट प्रति अतिरिक्त फ़ाइल बाइट-काउंट में जोड़ी गई।

आप -sध्वज के साथ कोड को एक फ़ाइल के रूप में चला सकते हैं । उदाहरण के लिए:

> echo -n 1111111|retina -s collatz
1111111111111111

एल्गोरिथ्म एक गैर-संख्या के साथ Collatz कदम करने का एक लूप है और xस्ट्रिंग के अंत में एक नया चरण-मार्कर जोड़ना है यदि संख्या 1 नहीं है।

जब लूप समाप्त होता है 1, तो हम मार्करों को एक्री संख्या (अग्रणी को हटाते हुए 1) में बदल देते हैं जो वांछित आउटपुट है।

Answer 19

जेली , गैर-प्रतिस्पर्धात्मक

12 बाइट्स यह जवाब गैर-प्रतिस्पर्धात्मक है, क्योंकि चुनौती जेली के निर्माण से पहले की है।

×3‘$HḂ?ß0’?‘

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

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

×3‘$HḂ?ß0’?‘  Main link. Argument: n (integer)

     Ḃ?       Yield the last bit of n is 1:
   $            Evaluate the three links to the left as a monadic chain:
×3                Multiply n by 3.
  ‘               Increment the product by 1.
    H           Else, halve n.
         ’?   If n-1 is non-zero:
       ß        Recursively call the main link.
        0     Else, yield 0.
           ‘  Increment the result by 1.

Answer 20

डीसी, 27 वर्ण

लागू करने boothby के काला जादू :

?[d3*1+d2%5*1+/d1<x]dsxxkzp

या - मैं वास्तव में यकीन है कि अगर मैं समझता हूँ कि कैसे नहीं कर रहा हूँ कि - यह काम करता है।

उपयोग:

$ dc collatz.dc <<< 7
16

डीसी, 36 अक्षर

मेरी अपनी रचना; कुछ हद तक एक और अधिक परंपरागत दृष्टिकोण, यहां तक कि यद्यपि मैं एक की कमी दूर करने के लिए एक निष्पक्ष बिट भाषा के साथ लड़ाई के लिए किया था elseके लिए भाग ifबयान:

?[2/2Q]se[dd2%[0=e3*1+]xd1<x]dsxxkzp

आंतरिक रूप से यह अनुक्रम के सभी नंबरों का उत्पादन करता है और उन्हें स्टैक पर संग्रहीत करता है, फिर फाइनल को पॉप 1करता है और स्टैक की ऊंचाई प्रदर्शित करता है।

Comments

समानता काला जादू नहीं है।

— बूथबीज

नहीं, लेकिन यह एक बहुत साफ चाल है! मैंने वास्तव में इसी तरह का सामान खुद किया है, मैंने इस मामले में इसके बारे में सिर्फ सोचा नहीं था। मुझे एक सेकंड के लिए ठोकर खाई थी, लेकिन मैं इसे प्राप्त करता हूं: आप छह से विभाजित करते हैं, पहले ऑपरेशन (* = 3, + = 1) को दूसरे के साथ जोड़कर यदि समता गलत थी, और पूर्णांक विभाजन के कारण जोड़ जाता है दूर भी, और हमने मूल रूप से / = 2 किया है। बहुत चालाक :)

— daniero

+1। मुझे लगा कि मैं डीसी के साथ इस चुनौती को कुचलने जा रहा हूं, लेकिन केवल 40 तक ही पहुंच पाया हूं। मैंने आपका 27 उत्तर देखा। ओह अच्छा।

— डिजिटल ट्रामा

मैंने इस चुनौती को नहीं देखा था, लेकिन कुछ समय पहले dc में Collatz अनुक्रम को छापने के बारे में ब्लॉग किया था। मेरा दृष्टिकोण आपके समान है लेकिन एक बाइट से हार जाता है इसलिए मुझे वास्तव में इसे पोस्ट करने का कोई कारण नहीं दिखता है। हालाँकि, जब मैं देख रहा था कि प्रत्येक चरण को मुद्रण से आसानी से जाने के लिए कदमों की संख्या को कैसे प्रिंट किया जाए, तो मैंने कुछ ऐसा देखा, जो आपके लिए एक बाइट को गोल कर सकता है ... क्योंकि Collatz अनुक्रम हमेशा 2 से 1 तक जाएगा। आप अपनी स्थिति को बदल सकते हैं 2<xऔर इससे छुटकारा पा सकते हैं k। बस अगर आप चार साल बाद एक बाइट वापस चाहते हैं। : D

— brhfl

Answer 21

ब्रेनफक , 59 56 बाइट्स

,-[<->[[>]+<[-<]>>]>[-<<[++>+<]>->]<<[+>+++<]<<+>>>]<<<.

इसे ऑनलाइन आज़माएं! (उपयोग में आसानी के लिए थोड़ा संशोधित)

चरित्र कोड के रूप में इनपुट और आउटपुट। यह मनमाने ढंग से आकार की कोशिकाओं के साथ अधिक उपयोगी है, लेकिन अभी भी सीमित सेल आकार में छोटे मूल्यों के साथ काम कर सकता है।

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

Tape Format:
Counter 0 Copy Number Binary...
^End           ^Start

,-[ Get input, decrement by 1 and start loop
  <->                  Initialises the copy of the value at -1
  [[>]+<[-<]>>]        Converts the input to binary while preserving a negative copy
  <+>>[-<<[++>+<]>->] If the last digit of the binary is 1 (n-1 is odd), divide by 2 and decrement
  <<[+>+++<]            If the last digit of the binary is 0 (n-1 is even), multiply by 3
  <<+>>>               Increment counter and end on n-1
]<<<.                 End loop and print counter

Answer 22

हेक्सागोनी , 48 44 बाइट्स

?(]$_)"){{?{*')}/&!/={:<$["/>&_(.<@2'%<>./>=

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

विस्तारित:

     ? ( ] $ _
    ) " ) { { ?
   { * ' ) } / &
  ! / = . { < $ [
 " / > & _ ( . < @
  2 ' % < > : / >
   = . . . . . .
    . . . . . .
     . . . . .

ध्यान दें कि यह 1उह के लिए विफल रहता है ... कारण । ईमानदारी से, मुझे यकीन नहीं है कि यह कैसे काम करता है। मुझे पता है कि विषम संख्याओं के लिए कोड पीछे की संख्याओं के लिए भी चलाया जाता है? जैसे तैसे?

नया संस्करण पहले की तुलना में बहुत अधिक साफ है, लेकिन इसकी तुलना में कुछ अधिक दिशा-निर्देश हैं और यह विभाजन-दर-शून्य त्रुटि में भी समाप्त होता है। एकमात्र मामला यह त्रुटि नहीं करता है जब यह वास्तव में 1सही ढंग से संभालता है।

Comments

If a number < 2 is input ... output does not matter.: ओ)

— सोक

@ सोक येप, इसीलिए मैंने इसे ठीक करने की कोशिश में पागल होने के बजाय इसे पोस्ट किया

— जो किंग

Answer 23

सी, 70 69 चरस

काफी सरल, कोई चाल नहीं।
स्टड से इनपुट पढ़ता है।

a;
main(b){
    for(scanf("%d",&b);b-1;b=b%2?b*3+1:b/2)a++;
    printf("%d",a);
}

Answer 24

क्यू, 46

{i::0;{x>1}{i+:1;$[x mod 2;1+3*x;(_)x%2]}\x;i}

Comments

32 बाइट्स(#)1_(1<){(1+3*x;x%2)0=x mod 2}\

— स्ट्रीटस्टर

Answer 25

रूबी 1.9, 49 वर्ण

रूबी लैन्डडा सिंटैक्स का उपयोग करते हुए, वैलेंटाइन क्लेमेंट के पाइथन का उत्तर दें। जोड़ा अपठनीयता के लिए इसे एक बयान में बदल दिया।

(f=->n{n>1&&1+f[[n/2,3*n+1][n%2]]||0})[gets.to_i]

कुछ उपरि क्योंकि पाइथन के विपरीत रूबी, बूलियन के साथ संख्याओं को मिलाकर खुश नहीं है।

Answer 26

C ++ ( 51 48)

यह एक पुनरावर्ती कार्य है जो ऐसा करता है; इनपुट रीडिंग अलग से आती है।

int c(n){return n==1?0:1+(n%2?c(n*3+1):c(n/2));}

मुझे यकीन है कि मैं == 0सामान के साथ कुछ "और / या" चाल कर सकता हूं, लेकिन मुझे नहीं पता कि कैसे।

Comments

आप को दूर कर सकता है ==0और सशर्त के पक्षों स्वैप

— दरवाज़े

इसके अलावा, संभाल करने के लिए कोई जरूरत नहीं n==1है क्योंकि मैं प्रश्न में निर्दिष्ट किया है कि नंबर हमेशा 1 से अधिक

— दरवाज़े

समस्या यह है कि n==1आधार पुनरावृत्ति मामला है। n==2वहां डालने से स्कोर में कोई सुधार नहीं होगा।

— जो जेड।

: आह, तो आप बस इसे इस के साथ बदल सकते return~-n?और स्वैप सशर्त पक्षों

— दरवाज़े

। n==1== n<2।

— कैलक्यूलेटरफैनलाइन

Answer 27

~ - ~! (कोई टिप्पणी नहीं) - 71 53

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

'=|*;~~[*,~~~-~]*/~~|:''=|'''==~[*]'''='&''':''&*+~|:

सबसे पहले, '''अपने इनपुट पर सेट करें। फ़ंक्शन ''को तब %इनपुट के साथ बुलाया जा सकता है क्योंकि यह इनपुट है और इस तरह से उत्तर देगा:

'''=~~~~~:''&%:

यह लौट आएगा ~~~~~। यह वास्तव में काम करता है n==1(यह हमेशा के लिए बंद हो जाता है n==0)।

हमेशा की तरह इस भाषा के साथ, निष्कलंक।

Answer 28

जावास्क्रिप्ट (ईएस 6) - 29 वर्ण

f=x=>x>1?f(x%2?x*3+1:x/2)+1:0

एक फ़ंक्शन बनाता है fजो एकल तर्क को स्वीकार करता है और पुनरावृत्तियों की संख्या देता है।

जावास्क्रिप्ट - 31 वर्ण

for(c=0;n>1;n=n%2?n*3+1:n/2)++c

मान लेता है कि इनपुट चर में है nऔर एक चर बनाता है cजिसमें पुनरावृत्तियों की संख्या होती है (और cअंतिम कमांड के रूप में कंसोल में आउटपुट भी होगा )।

Comments

28 बाइट्स

— झबरा

Answer 29

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

वैलेन्टिन क्लेमेंट और डेनियरो के अनुसार, रिकर्सिव फंक्शन विधि : 40 अक्षर

sub f(\n){n>1&&1+f n%2??3*n+1!!n/2}(get)

आलसी सूची विधि: 32 वर्ण

+(get,{$_%2??$_*3+1!!$_/2}...^1)

Answer 30

> <>, 27 26 23 बाइट्स

\ln;
\::2%:@5*1+2,*+:2=?

अन्य> <> जवाबों की तरह, यह स्टैक पर अनुक्रम बनाता है। एक बार अनुक्रम 2 तक पहुंचने के बाद, स्टैक का आकार उठाए गए चरणों की संख्या है।

@Hohmannfan के लिए धन्यवाद, अगले मूल्य को सीधे गणना करने की एक बहुत ही चतुर विधि द्वारा 3 बाइट्स को बचाया गया। अनुक्रम में अगले मूल्य की गणना करने के लिए सूत्र का उपयोग किया जाता है:

$$f(n)=n\cdot\frac{5(n\bmod2)+1}{2}+(n\bmod2)$$

अंश मैप संख्या 0.5 तक, और विषम संख्या 3 से 3. गुणा करके nऔर जोड़कर n%2गणना पूरी करता है - सभी के लिए अगला मूल्य चुनने की आवश्यकता नहीं है!

2 संपादित करें: यहाँ पूर्व- @ Hohmannfan संस्करण है:

\ln;
\:::3*1+@2,@2%?$~:2=?

चाल यहाँ है कि दोनों है 3n+1और n/2अनुक्रम में हर कदम, और एक पर गणना अनुक्रम से बाद में चुन लिया जाता है गिरा दिया जाना। इसका मतलब है कि कोड को 1 तक पहुंचने के लिए शाखा की आवश्यकता नहीं है, और अनुक्रम की गणना कोड की एक पंक्ति पर रह सकती है।

संपादित करें: यह महसूस करने के बाद कि एक और सकारात्मक पूर्णांक 1 को जन्म दे सकता है, के बाद किसी अन्य वर्ण को गला दिया है। जैसा कि कार्यक्रम का आउटपुट इनपुट <2 के लिए कोई फर्क नहीं पड़ता, अनुक्रम पीढ़ी समाप्त हो सकती है जब 2 पहुंच जाता है, तो स्टैक का आकार छोड़कर आवश्यक चरणों की सटीक संख्या होने के नाते।

पूर्व संस्करण:

\~ln;
\:::3*1+@2,@2%?$~:1=?

Comments

आप इसे 23 को गोल्फ कर सकते हैं यदि आप दूसरी पंक्ति को और भी अधिक \::2%:@5*1+2,*+:2=?

— खोल देते हैं