9 को अभिसार करते हैं!

21

एक पूर्णांक n> 2 को देखते हुए , सबसे छोटे गैर-ऋणात्मक पूर्णांक k को ऐसे प्रिंट करें या वापस लौटाएं (n, k) = 9 , जहां a (n, k) द्वारा परिभाषित किया गया है:

  • a (n, 0) = n
  • a (n, k + 1) =
    • a (n, k) / 2 + 1 यदि a (n, k) सम है
    • a (n, k) in (आधार 10 में) के अंकों का योग यदि a (n, k) विषम है

उदाहरण

के लिए एन = 5 , अपेक्षित आउटपुट है कश्मीर = 4 :

a(5, 0) = 5
a(5, 1) = 7  (5² = 25 and 2 + 5 = 7)
a(5, 2) = 13 (7² = 49 and 4 + 9 = 13)
a(5, 3) = 16 (13² = 169 and 1 + 6 + 9 = 16)
a(5, 4) = 9  (16 / 2 + 1)

के लिए एन = 40 , अपेक्षित आउटपुट है कश्मीर = 2 :

a(40, 0) = 40
a(40, 1) = 21 (40 / 2 + 1)
a(40, 2) = 9  (21² = 441 and 4 + 4 + 1 = 9)

स्पष्टीकरण और नियम

  • इनपुट 2 से अधिक होने की गारंटी है।
  • आपका कार्यक्रम सैद्धांतिक रूप से n के किसी भी मूल्य के लिए काम करना चाहिए । (व्यवहार में, यह आपकी भाषा द्वारा समर्थित अधिकतम पूर्णांक आकार तक सीमित हो सकता है।)
  • k या तो 0-अनुक्रमित या 1-अनुक्रमित हो सकता है। कृपया इसे अपने उत्तर में बताएं।
  • यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

पहला मान

नीचे से पहले मान हैं n = 3 करने के लिए एन = 422 के साथ, कश्मीर 0 अनुक्रमित। ( 1इन -इंडेक्सिंग के लिए, बस इन मूल्यों को जोड़ें ।)

 1  2  4  3  3  5  0  4  3  4  2  6  1  1  6  5  5  4  1  5  2  3  3  7  6  2  3  2  2  7
 6  6  5  6  6  5  1  2  2  6  6  3  1  4  3  4  4  8  1  7  6  3  5  4  6  3  2  3  3  8
 7  7  3  7  4  6  6  7  5  7  6  6  6  2  4  3  3  3  6  7  3  7  2  4  7  2  6  5  6  4
 7  5  2  5  6  9  6  2  3  8  2  7  1  4  6  6  6  5  1  7  4  4  3  3  7  4  3  4  2  9
 6  8  6  8  6  4  6  8  2  5  3  7  6  7  3  8  2  6  7  8  6  7  5  7  6  7  4  3  3  5
 6  4  3  4  4  4  6  7  6  8  3  4  6  8  7  3  6  5  6  8  3  3  2  7  6  6  5  7  6  5
 7  8  2  6  3  3  6  6  6  7  4 10  6  7  3  3  6  4  1  9  2  3  3  8  7  2  6  5  2  7
 7  7  6  7  3  6  7  2  4  8  3  5  6  5  6  4  2  4  6  8  3  5  6  4  7  5  2  3  6 10
 7  7  3  9  2  7  1  9  5  7  6  5  6  7  4  9  6  3  6  6  3  4  2  8  7  7  6  8  6  4
 7  9  4  3  3  7  7  8  3  9  4  7  6  8  3  6  6  8  7  7  7  8  6  5  7  4  6  4  2  6
 7  7  6  5  3  4  7  5  4  5  3  5  7  7  6  8  2  7  1  9  6  4  6  5  7  7  2  9  6  8
 7  4  3  7  4  6  6  7  6  9  3  4  6  4  2  3  3  8  1  7  6  7  2  6  7  8  3  7  5  6
 7  8  2  9  3  3  6  7  6  4  4  4  6  7  6  7  6  7  6  8  7  5  6 11  7  7  3  8  4  4
 7  4  6  7  3  5  6  2  2 10  6  3  6  4  3  4  4  9  7  8  3  3  6  7  7  6  4  3  6  8
code-golf  sequence 
— Arnauld
स्रोत
23
शीर्षक पर 9! ≠ 9
— अप्रचलित नाइटिक
1
शांत क्रम। क्या आपने स्वयं इसकी खोज की थी?
— रॉबर्ट फ्रेजर
@RobertFraser मैंने किया था, लेकिन मुझे यकीन है कि इसी तरह के सीक्वेंस कहीं मौजूद हैं (मुझे एक नहीं मिला, लेकिन मुझे खोज करने में ज्यादा समय नहीं लगा।)
— अरनौल्ड
Collatz अनुमान के बाद, Arnauld का अनुमान! आगे क्या होगा?
— सर्गियोल
@sergiol के अनुसार lmgtfy.com/?q=conjecture एक अनुमान हैan opinion or conclusion formed on the basis of incomplete information.
— रोमन ग्रैफ़

जवाबों:

6

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

€9¡?o→½ȯΣd□¦2

यह 1-अनुक्रमित है। इसे ऑनलाइन आज़माएं!

व्याख्या

यहां कुछ भी नहीं फैंसी।

€9¡?o→½ȯΣd□¦2  Implicit input, say n = 5
  ¡            Iterate the following function:
   ?       ¦2   If divisible by 2,
    o→½         then halve and increment,
       ȯΣd□     else square, take digits and get their sum.
               This gives an infinite sequence: [5,7,13,16,9,9,9,9,9..
€9             1-based index of 9; print implicitly.
— Zgarb
स्रोत
मुझे लगता है कि इसे Lωहल कर दिया जाए तो अच्छा होगा ।
— H.PWiz
10

पर्ल 6 , 41 बाइट्स (40 वर्ण)

{+($_,{$_%2??[+] $_².comb!!$_/2+1}...9)}

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

यह k की 1-इंडेक्सिंग का उपयोग करता है, इसलिए यह ओपी में उदाहरणों की तुलना में 1 उच्चतर उत्तर देता है। यदि यह 1-इंडेक्सिंग का मतलब नहीं है, तो मुझे 1 बाइट और जोड़ना होगा।

स्पष्टीकरण : यह एक अनाम फ़ंक्शन है। हम सिर्फ रिकर्सन का उपयोग करके सूची बनाने के लिए पर्ल 6 की सुविधा का उपयोग करते हैं: यह इस तरह दिखता है (first element),(block that takes the previous element and gives the next)...(end condition):। इस मामले में, पहला तत्व $_(मुख्य फ़ंक्शन का तर्क) है और अंतिम स्थिति है 9(पूरी होती है जब हम 9 उत्पन्न करते हैं)। मध्य खंड में, हम $_इसके तर्क (= अनुक्रम के पिछले तत्व) को संदर्भित करने के लिए उपयोग करते हैं। ?? !!पुराने त्रिगुट ऑपरेटर (बेहतर रूप में जाना जाता है ? :)। अंत में, हम इस सूची की लंबाई को संख्यात्मक संदर्भ के लिए मजबूर करके लेते हैं +(...)।

यहां आखिरी अजीब बात अंकों का योग है। संख्याएँ Cool(स्ट्रिंग और संख्या दोनों की तरह व्यवहार करती हैं), इसलिए हम एक स्ट्रिंग विधि का उपयोग .combकरते हैं $_²(वर्णों की सूची = अंक दें), फिर वर्णों को जोड़ते हुए (जो उन्हें संख्याओं में परिवर्तित करता है)।

— Ramillies
स्रोत
हां, इसका मतलब 1-इंडेक्सिंग है।
— अर्नुलद
7

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

²DSµH‘$Ḃ?ßµ-n9$?‘

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

सीधा-आगे का दृष्टिकोण। 0-आधारित अनुक्रमण का उपयोग करता है।

व्याख्या

²DSµH‘$Ḃ?ßµ-n9$?‘  Input: n
               ?   If
            n9$      n != 9
          µ        Then
        ?            If
       Ḃ               n % 2 == 1
   µ                 Then
²                      Square
 D                     Decimal digits
  S                    Sum
      $              Else
    H                  Halve
     ‘                 Increment
         ß           Call recursively
                   Else
           -         The constant -1
                ‘  Increment
— मील की दूरी पर
स्रोत
1
@Arnauld धन्यवाद, सशर्त एक था do-while n != 9एक के बजायwhile n!= 9
— मील की दूरी पर
7

पायथन 2 , 129 126 76 68 67 64 54 53 बाइट्स

जोनाथन फ्रीच को -3 बाइट्स धन्यवाद। -8 बाइट्स माल्टीसेन को धन्यवाद। -7 बाइट्स जोनाथन एलन को धन्यवाद। -1 बाइट मिस्टर एक्सकोडर की बदौलत।

f=lambda n:n-9and-~f(n%2*sum(map(int,`n*n`))or 1+n/2)

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

किसी ऐसे व्यक्ति से जो शायद पर्याप्त गणित नहीं जानता है, यह पूरी तरह से मनमाना लगता है। : पी

— totallyhuman
स्रोत
1
आप तीन बाइट की बचत के )%2and sumसाथ बदलने में सक्षम हो सकते हैं )%2*sum।
— जोनाथन फ्रेच
1
वहाँ अजगर 3 के लिए एक कारण है? अन्यथा आप str repr के लिए `का उपयोग कर सकते हैं
— माल्टीसेन
1
आप kपूरी तरह से छुटकारा पा सकते हैं और एक और सात बाइट्स बचा
— जोनाथन एलन
8
मैं कबूल करूंगा, मैं पूरी तरह से खो गया कि यह कुछ मिनट पहले कैसे काम करता है। > _ <
— पूरी तरह से
2
— बिटवाइस
6

मैथेमेटिका, 58 बाइट्स

1 अनुक्रमित

If[#!=9,#0@If[OddQ@#,Total@IntegerDigits[#^2],#/2+1]+1,0]&

इसे ऑनलाइन आज़माएं! (मैथिक्स पर काम करने के लिए, Trइसके साथ प्रतिस्थापित किया जाता है Total) @JungHwanMin द्वारा

-1 बाइट संस्करण है (लेकिन यह गणित पर काम नहीं करता है इसलिए मैंने दोनों को रखा)

मैथेमेटिका, 57 बाइट्स

If[#!=9,#0@If[2∣#,#/2+1,Total@IntegerDigits[#^2]]+1,0]&
— J42161217
स्रोत
1
-1 बाइट: 2∣#इसके बजाय का उपयोग करें OddQ@#और के दो भाव स्वैप If।
— जंगवान मिन सिप
6

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

0 अनुक्रमित।

f=n=>n-9&&f(n%2?eval([...""+n*n].join`+`):n/2+1)+1

कोशिश करो

o.innerText=(
f=n=>n-9&&f(n%2?eval([...""+n*n].join`+`):n/2+1)+1
)(i.value=5);oninput=_=>o.innerText=f(+i.value)
<input id=i min=3 type=number><pre id=o>
स्निपेट का विस्तार करें

व्याख्या

पहली चीज जो हम करते हैं वह है गणना n-9। यदि n==9ऐसा है, तो जाहिर है, देता है 0और चीजें बंद हो जाती हैं। यदि n!=9तब n-9कोई शून्य-शून्य मान देगा, जो सत्य होने का मतलब है कि हम तार्किक और के माध्यम से जारी रख सकते हैं। हम फ़ंक्शन को फिर से कॉल करते हैं, nइसे एक नया पास करते हुए, निम्नानुसार गणना की जाती है:

n%2?

तो nसापेक्ष 2truthy है - यानी, nअजीब है।

[...""+n*n]

nअपने आप से गुणा करें , इसे स्ट्रिंग में बदलें और उस स्ट्रिंग को अलग-अलग वर्णों (अंकों) की एक सरणी में नष्ट करें।

 .join`+`

+एक गणितीय अभिव्यक्ति देते हुए , पात्रों को एक स्ट्रिंग में फिर से जोड़ दें।

eval(                   )

उस अभिव्यक्ति का मूल्यांकन करें, जिससे हमें अंकों का योग मिलता है n*n।

:n/2+1

यदि n%2falsey (यानी, है nभी है) तो हम बस को विभाजित nकरके 2और जोड़ने 1।

फ़ंक्शन को फिर से कॉल करने के परिणाम में, हम फिर जोड़ते हैं 1। इसलिए, एक प्रारंभिक इनपुट का उपयोग करते हुए 5, प्रक्रिया इस प्रकार है:

f(5)
= -4&&f(7)+1
= -2&&(f(13)+1)+1
=  4&&((f(16)+1)+1)+1
=  7&&(((f(9)+1)+1)+1)+1
=     (((0+1)+1)+1)+1
= 4
— झबरा
स्रोत
4

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

मील के लिए -1 बाइट धन्यवाद (टेरनेरी का उपयोग यदि)

²DSµH‘µḂ?_9$пL

संख्याओं को लेने और वापस करने का एक विचित्र लिंक।
1 अनुक्रमित

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें (परिणाम 0-अनुक्रमित किए जा सकते हैं और OP कोड-ब्लॉक जैसे प्रारूप)

कैसे?

²DSµH‘µḂ?_9$пL - Link: number, n
            п  - collect results in a list while:
           $    -   last two links as a monad:
         _9     -     subtract nine
        ?       -   if:
       Ḃ        -     bit - current loop input modulo by 2 (1 if odd, 0 if even)
   µ            -   ...then:
²               -     square the current loop input
 D              -     cast to a list of its decimal digits
  S             -     sum
      µ         -   ...else:
    H           -     halve current loop input
     ‘          -     increment
              L - length (get the number of results collected
                -         - this includes the 9, so is 1-indexed w.r.t. k)
— जोनाथन एलन
स्रोत
मेरा मानना ​​है कि यदि आप अपने लूप के साथ उपयोग किए गए इफ-स्टेटमेंट को मिलाकर एक बाइट बचा सकते हैं। ²DSµH‘$Ḃ?n9$пL
— मील
1

VB.NET (.NET 4.5.2), 107 + 20 (आयात) = 117 बाइट्स

आवश्यक है Imports System.Linq

Function A(n)
While n<>9
n=If(n Mod 2=0,n/2+1,CStr(n^2).Sum(Function(c)Val(c)))
A+=1
End While
End Function

फ़ंक्शन जो nपूर्णांक इनपुट के रूप में लेता है और 0-आधारित देता है k।

Ungolfed:

Function A(n) ' input/output types are Object, but we will be casting to integer
    'A = 0 ' VB will create an implicit variable with the same name as the function

    ' loop until a(n, k) = 9
    ' using n as the variable to store a(n, k)
    While n <> 9

        n = If(n Mod 2 = 0, ' equivalent to c# ternary ?: operator

            n / 2 + 1, ' even case

            CStr(n ^ 2).Sum(Function(c) Val(c)))
            ' odd case
            ' cast number to string
            ' then convert each char to the number it represents
            ' and do a linq sum

        A += 1 ' Object + Integer will coerce to an integer
    End While

    ' Where's the return?
    ' That implicit variable with the matching name will get returned if there's no explicit return
End Function
— ब्रायन जे
स्रोत
1

पायथ ,  23  22 बाइट्स

अभी के लिए, यह एक पुनरावर्ती कार्य है लेकिन मैं .Wइसके बजाय बाइट्स को बचाने के लिए (कार्यात्मक समय पर) स्विच करने का प्रयास करूंगा ।

L&-b9hy|*%b2sj^b2Th/b2

यहाँ कोशिश करो! (फ़ंक्शन को कॉल करने के लिए अतिरिक्त कोड के साथ - उपयोग- बिना रिक्त स्थान के)y<your_number>

— श्री Xcoder
स्रोत
1

जावा 8, 110 98 बाइट्स

n->{int k=0,s;for(;n!=9;k++){s=0;for(int c:(n*n+"").getBytes())s+=c-48;n=n%2<1?n/2+1:s;}return k;}

0 अनुक्रमित

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

 n->             // Method with integer as both input and return-type
   int k=0,      //  Result-integer `k` starting at 0
       s;        //  Sum-integer
   for(;n!=9;    //  Loop (1) as long as `n` is not 9
        k++){    //    And increase `k` by 1 after every iteration
     s=0;        //   Reset sum `s` to 0
     for(int c:(n*n+"").getBytes())
                 //   Do `n*n` and inner loop (2) over the digits as characters
       s+=c-48;  //    And increase the sum `s` with these digits
                 //   End of inner loop (2) (implicit / single-line body)
     n=n%2<1?    //   If `n` is even:
        n/2+1    //    Change `n` to `n/2+1`
       :         //   Else:
        s;       //    Change `n` to sum `s`
  }              //  End of loop (1)
  return k;      //  Return the result `k`
}                // End of separated method (2)
— केविन क्रूज़सेन
स्रोत
1

क्लोजर v1.8, 124 113 112 बाइट्स

0 अनुक्रमित

(fn[n](loop[a n k 0](if(= a 9)k(recur(if(even? a)(+(/ a 2)1)(apply +(map #(-(int %)48)(str(* a a)))))(inc k)))))

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

व्याख्या

(loop[a n k 0](if(= a 9)...))  Loop until a=9
(if(even? a)(+(/ a 2)1)...)    If even, a(n, k) / 2 + 1 if a(n, k)
(if(even? a)...(apply +(map #(-(int %)48)(str(* a a)))))  If odd, calculate the sum of digits of a(n, k)²
#(-(int %)48)                  Convert character to number
— क्रिस
स्रोत
1

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

tl.u?%N2sj*NNTh/N2

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

tl.u?%N2sj*NNTh/N2
  .u                 apply the following function to the input, 
                     until it runs into a fixed point
    ?%N2                if value % 2 == 1:
          *NN               value * value
         j   T              convert to digits
        s                   sum
                        else:
               /N2          value / 2
              h              + 1
 l                   get the length of all visited values
t                     - 1
— Jakube
स्रोत
1

जाप, 22 21 बाइट्स

0 अनुक्रमित।

NcUÆ=v ?U/2Ä:U²ìxà b9

कोशिश करो

व्याख्या

पूर्णांक का निहित इनपुट U।

UÆ             Ã

से पूर्णांकों की एक सरणी उत्पन्न 0करने के लिए U-1और एक समारोह के माध्यम से एक गुजरती हैं।

=

का मान निर्धारित करें U।

v ?

यदि U2 से विभाज्य है।

U/2Ä

U2 से विभाजित, 1 ( Ä)।

:U²ìx

Else: U2 की शक्ति ( ²), अंकों की एक सरणी से विभाजित ( ì) और इसके अलावा कम ( x)।

Nc

इनपुट के सरणी में परिणामी सरणी को जोड़ें।

b9

9सरणी में पहली घटना के सूचकांक का पता लगाएं । परिणाम को लागू करें।

— झबरा
स्रोत
डैंग। मुझे लगता है कि एक फ़ंक्शन विधि का उपयोग करना बेहतर होगा, लेकिन मैंने इसे केवल 23 बाइट्स के लिए नीचे कर दिया: @¥9}a@=u ?U²ìx :U/2Ä;°Tयदि केवल एक विधि थी जो पुनरावृत्तियों की संख्या तब तक
— लौटाती है
@ETHproductions: यह 0 के बजाय 9 के लिए 1 आउटपुट देता है, लेकिन यहां एक 22 बाइट संस्करण है (जो अभी भी 9 के लिए विफल रहता है)।
— शगि
मैं कल रात एक 20 बाइट संस्करण के साथ आया था, लेकिन यह एक ही मुद्दा था।
— झबरा
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.