सभी चुनौतियाँ
आसान 0 हल किए गए 0% स्वीकृति

कोलात्ज़ अनुक्रम

आधा करें या तीन गुणा करके एक जोड़ें वाले नियम का पालन करें जब तक 1 न आ जाए।

n से शुरू करें। यदि यह सम है, तो इसे 2 से भाग दें; यदि यह विषम है, तो इसे 3 से गुणा करें और 1 जोड़ें। यह प्रक्रिया तब तक दोहराएं जब तक मान 1 न हो जाए। अपने उत्तर में प्रारंभिक मान और अंतिम 1 दोनों शामिल करें।

collatz_sequence(n) को लागू करें।

इनपुट

n: प्रारंभिक धनात्मक पूर्णांक।

आउटपुट

क्रम को उसी क्रम में पूर्ण रूप से लौटाएँ।

सीमाएँ

1 ≤ n ≤ 10,000। इस सीमा के सभी इनपुट इस नियम के अनुसार 1 तक पहुँचते हैं; अनुक्रम के सभी मान signed 64-bit integer में समा जाते हैं।

उदाहरण

उदाहरण 1
इनपुट:
n = 6

अपेक्षित आउटपुट:
expected = [6, 3, 10, 5, 16, 8, 4, 2, 1]
इनपुट:
long long n = 6;

अपेक्षित आउटपुट:
std::vector<long long> expected = {6, 3, 10, 5, 16, 8, 4, 2, 1};
इनपुट:
long n = 6;

अपेक्षित आउटपुट:
long[] expected = new long[] {6, 3, 10, 5, 16, 8, 4, 2, 1};

व्याख्या

6 सम है, इसलिए यह 3 बनता है। फिर 3, 10 बनता है। इसी तरह नियम को 1 तक लागू करते रहें।

उदाहरण 2
इनपुट:
n = 1

अपेक्षित आउटपुट:
expected = [1]
इनपुट:
long long n = 1;

अपेक्षित आउटपुट:
std::vector<long long> expected = {1};
इनपुट:
long n = 1;

अपेक्षित आउटपुट:
long[] expected = new long[] {1};

व्याख्या

प्रारंभिक मान पहले से ही 1 है, इसलिए कोई परिवर्तन आवश्यक नहीं है।

संदर्भ

यह चुनौती CodeUtility के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।

दूसरों से सीखें

समुदाय समाधान

अभी तक कोई प्रकाशित समाधान नहीं। पहला साझा करने के लिए इस चुनौती को हल करें।