अंक उत्पाद अनुक्रम

Question

यहाँ एक दिलचस्प अनुक्रम पॉल लूमिस द्वारा खोजा गया है, जो ब्लूम्सबर्ग विश्वविद्यालय के गणितज्ञ हैं। इस क्रम पर उनके पेज से :

आधार 10 में लिखे किसी भी सकारात्मक पूर्णांक के
f(n) = f(n-1) + (the product of the nonzero digits of f(n-1))
f(0) = xसाथ परिभाषित करें x।

तो, f(0)=1आप के साथ शुरू , आप निम्नलिखित अनुक्रम मिलता है
1, 2, 4, 8, 16, 22, 26, 38, 62, 74, 102, 104, ...

अब तक, इतने मानक। जब आप किसी अन्य पूर्णांक को प्रारंभिक बिंदु के रूप में लेते हैं, तो दिलचस्प संपत्ति चलन में आ जाती है , अंततः अनुक्रम उपरोक्त x=1क्रम में एक बिंदु में परिवर्तित हो जाता है । उदाहरण के लिए, x=3पैदावार से शुरू
3, 6, 12, 14, 18, 26, 38, 62, 74, 102, ...

यहां कुछ और अनुक्रम हैं, प्रत्येक को केवल तब तक दिखाया जाता है जब तक वे नहीं पहुंचते 102:

5, 10, 11, 12, 14, 18, 26, 38, 62, 74, 102, ...
7, 14, 18, 26, 38, 62, 74, 102, ...
9, 18, 26, 38, 62, 74, 102, ...
13, 16, 22, 26, 38, 62, 74, 102, ...
15, 20, 22, 26, 38, 62, 74, 102, ...
17, 24, 32, 38, 62, 74, 102, ...
19, 28, 44, 60, 66, 102, ...

उन्होंने अनुमान लगाया, और अनुभवजन्य रूप से साबित हुआ x=1,000,000, कि यह संपत्ति (यानी, कि सभी इनपुट नंबर एक ही अनुक्रम में परिवर्तित होते हैं) सही है।

चुनौती

एक सकारात्मक इनपुट पूर्णांक को देखते हुए 0 < x < 1,000,000, उस संख्या को आउटपुट करें जहां f(x)अनुक्रम अनुक्रम में परिवर्तित f(1)होता है। उदाहरण के लिए, उदाहरण के लिए x=5, यह 26दोनों अनुक्रमों के लिए आम में पहला नंबर है।

 x output
 1 1
 5 26
19 102
63 150056

नियम

• यदि लागू हो, तो आप मान सकते हैं कि इनपुट / आउटपुट आपकी भाषा के देशी पूर्णांक प्रकार में फिट होगा।
• इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Answer 1

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

@ L4m2 के लिए 1 बाइट का धन्यवाद सहेजा गया

f=(n,x=1)=>x<n?f(x,n):x>n?f(+[...n+''].reduce((p,i)=>p*i||p)+n,x):n

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

टिप्पणी की गई

f = (n,                   // n = current value for the 1st sequence, initialized to input
        x = 1) =>         // x = current value for the 2nd sequence, initialized to 1
  x < n ?                 // if x is less than n:
    f(x, n)               //   swap the sequences by doing a recursive call to f(x, n)
  :                       // else:
    x > n ?               //   if x is greater than n:
      f(                  //     do a recursive call with the next term of the 1st sequence:
        +[...n + '']      //       coerce n to a string and split it
        .reduce((p, i) => //       for each digit i in n:
          p * i || p      //         multiply p by i, or let p unchanged if i is zero
        ) + n,            //       end of reduce(); add n to the result
        x                 //       let x unchanged
      )                   //     end of recursive call
    :                     //   else:
      n                   //     return n

Comments

`` `` एफ = (एन, एक्स = 1) => एक्स <एन? एफ (एक्स, एन): एक्स> एन? एफ (+ [... एन + '']। कम करें (पी, आई) = > p * i || p) + n, x): n `` ``

— l4m2

Answer 2

जेली , 18 14 बाइट्स

ḊḢDo1P+Ʋ;µQƑ¿Ḣ

इनपुट एक सिंगलटन ऐरे है।

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

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

ḊḢDo1P+Ʋ;µQƑ¿Ḣ  Main link. Argument: [n]

            ¿   While...
          QƑ      all elements of the return value are unique...
         µ          execute the chain to the left.
Ḋ                     Dequeue; remove the first item.
 Ḣ                    Head; extract the first item.
                      This yields the second item of the return value if it has
                      at least two elements, 0 otherwise.
       Ʋ              Combine the links to the left into a chain.
  D                     Take the decimal digits of the second item.
   o1                   Perform logical OR with 1, replacing 0's with 1's.
     P                  Take the product.
      +                 Add the product with the second item.
        ;             Prepend the result to the previous return value.
             Ḣ  Head; extract the first item.

Answer 3

पायथन 2 , 111 95 93 बाइट्स

replace(*'01')@Ryn उत्तर
-18 बाइट्स में @Lynn को धन्यवाद के रूप में अनपैकिंग का उपयोग करना

l=[1,input()]
while cmp(*l):l[0]+=eval('*'.join(`l[0]`.replace(*'01')));l.sort()
print l[0]  

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

Comments

आह, और पाश हालत while cmp(*l)भी हो सकता है !

— लिन

@ लीन हाँ! धन्यवाद फिर से

— मृत पोसुम

Answer 4

हास्केल , 65 बाइट्स

(!1)
a!b|a>b=b!a|a<b=(a+product[read[d]|d<-show a,d>'0'])!b|1<2=a

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

Answer 5

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

f=lambda a,b=1:a*(a==b)or f(*sorted([a+eval('*'.join(`a`.replace(*'01'))),b]))

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

Comments

मैं लैम्ब्डा के साथ समाधान पर काम कर रहा था, लेकिन कुछ मिनटों के लिए शॉर्टक्रिक्टिंग के साथ अटक गया, अच्छी नौकरी!

— मृत पोस्सम

Answer 6

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

→UΞm¡S+ȯΠf±dΘ

एक एकल सूची के रूप में इनपुट लेता है।

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

व्याख्या

                 Implicit input, e.g 5
            Θ    Prepend a zero to get  [0,5]
   m             Map the following over [0,5]
    ¡              Iteratatively apply the following function, collecting the return values in a list
           d         Convert to a list of digits
         f±          keep only the truthy ones
       ȯΠ            then take the product
     S+              add that to the original number
                After this map, we have [[0,1,2,4,8,16,22,26,38,62...],[5,10,11,12,14,18,26,38,62,74...]]
  Ξ             Merge the sorted lists:  [0,1,2,4,5,8,10,11,12,14,16,18,22,26,26,38,38,62,62,74...]
 U              Take the longest unique prefix: [0,1,2,4,5,8,10,11,12,14,16,18,22,26]
→               Get the last element and implicitely output: 26

Answer 7

पायथन 3 , 126 125 बाइट्स

m=[1]
n=[int(input())]
while not{*m}&{*n}:
 for l in m,n:l+=l[-1]+eval('*'.join(str(l[-1]).replace(*'01'))),
print({*m}&{*n})

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

इनपुट को स्ट्रिंग के रूप में लें

Answer 8

जावा (JDK 10) , 99 बाइट्स

n->{for(int x=1;x!=n;n+=(""+n).chars().reduce(1,(a,b)->a*(b>48?b-48:1)))x^=x<n?n^(n=x):0;return n;}

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

ज्यादातर अरनुल्ड के जावास्क्रिप्ट उत्तर का एक पुनरावृत्त बंदरगाह है , इसलिए उसे ऊपर ले जाएं!

Answer 9

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

ð⁹1,Dḟ0P+Ʋ⁸С€f/©µ1#ṛ®Ḣ

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

Answer 10

जे , 50 बाइट्स

tacit स्टाइल फंक्शन परिभाषा

[:{.@(e.~#])/[:(+[:*/@(*#])(#~10)&#:)^:(<453)"0,&1

यदि तर्क (63 का कहना है) को एक REPL अभिव्यक्ति में चिपकाया गया, तो यह 45 हो सकता है

{.(e.~#])/(+[:*/@(*#])(#~10)&#:)^:(<453)"0]1,63

• ,&1 तर्क क्रम के साथ ही खोज क्रम उत्पन्न करने के लिए 1 को जोड़ें
• ^:(<453)"0 1Mio के अनुक्रम में पहुंचने तक प्रत्येक को पुनरावृत्त करता है
• + [: */@(*#]) (#~10)&#: कांटा हुक में जोड़ता है जो अंकों का उत्पाद करता है
• (e.~ # ])/ सूचियों के प्रतिच्छेदन प्राप्त करने के लिए मौजूद आइटम का उपयोग करता है
• {. केवल पहला सामान्य मूल्य लौटाएं

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

Answer 11

आर , 110 86 बाइट्स

o=c(1,1:9);o=o%o%o%o%o;o=c(o%o%o)
x=c(1,n);while((x=sort(x))<x[2])x[1]=(x+o[x+1])[1]
x

TIO

पिछला संस्करण 110:

f=function(x){if((x[1]=x[1]+(c((y=(y=c(1,1:9))%o%y%o%y)%o%y))[x[1]+1])==x[2]){x[1]}else{f(sort(x))}}
f(c(1,n))

TIO