18

इस पुनरावर्तन संबंध को एक ऐसे फ़ंक्शन या प्रोग्राम के रूप में लागू करें जो गैर-नकारात्मक पूर्णांक को इनपुट और आउटपुट करता है:

एफ (0) = 0
F (N) = F (N-1) से बड़ा सबसे छोटा पूर्णांक है, जैसे कि इसके आधार -10 अंकों का योग और उत्पाद N है

N आपके प्रोग्राम का इनपुट है और F (N) इसका आउटपुट है।

स्पष्ट होने के लिए, 913 जैसी संख्याओं में अंकों का योग 9 + 1 + 3 = 13 है। उत्पाद 9 × 1 × 3 = 27 है। एकल-अंकीय संख्याओं के लिए, योग और उत्पाद एक ही संख्या है। संख्या जिसमें निश्चित रूप से 0 होता है, उत्पाद 0 होता है।

एफ (70) के माध्यम से परिणाम हैं:

N F(N)
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 19
11 29
12 34
13 49
14 59
15 69
16 79
17 89
18 92
19 199
20 225
21 317
22 499
23 599
24 614
25 799
26 899
27 913
28 1147
29 2999
30 3125
31 4999
32 5999
33 6999
34 7999
35 8999
36 9114
37 19999
38 29999
39 39999
40 41125
41 59999
42 61117
43 79999
44 89999
45 91115
46 199999
47 299999
48 311128
49 499999
50 511125
51 699999
52 799999
53 899999
54 911116
55 1999999
56 2111147
57 3999999
58 4999999
59 5999999
60 6111125
61 7999999
62 8999999
63 9111117
64 11111188
65 29999999
66 39999999
67 49999999
68 59999999
69 69999999
70 71111125

बाइट्स में सबसे छोटा कोड जीतता है। कुडोस यदि आप दिखा सकते हैं कि आपका कोड कुछ दक्षता का लाभ उठाता है।

— केल्विन के शौक
स्रोत

1

OEIS अनुक्रम

— MildlyMilquetoast

1

बिल्कुल सही क्रम नहीं।

— केल्विन के शौक

4

05AB1E , 20 12 बाइट्स

सहेजे गए 8 बाइट्स ओसेबल के लिए धन्यवाद !

µNSDOsP‚¾>å½

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

क्या लंबाई परीक्षण आवश्यक है? मैं साथ आ गया µNSDOsP‚¾>å½। यह बेतरतीब ढंग से चुने गए नंबरों के लिए काम करने लगता है।

— 13

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

— अदनान

कमाल है कि आप अचानक 20 बाइट्स प्रोग्राम को 40% तक कैसे कम कर सकते हैं ...

— निकोनिराह

3

गणितज्ञ, 71 बाइट्स, 68 वर्ण

±0=0;±n_:=(For[x=±(n-1),FreeQ[{+##,1##}&@@IntegerDigits@x,n],x++];x)

सिर्फ 4 और बाइट्स के लिए, यहां एक संस्करण दिया गया है जो ±nनिम्न मूल्यों को संग्रहीत करता है :

±0=0;±n_:=(For[x=±(n-1),FreeQ[{+##,1##}&@@IntegerDigits@x,n],x++];±n=x)

बाद के संस्करण के साथ, इससे पहले कि आप का मूल्यांकन ±n, PlusMinusदो नीचे मान होगा:

In[2]:= DownValues@PlusMinus
Out[2]= {HoldPattern[±0] :> 0, HoldPattern[±n_] :> (For[x=±(n-1),FreeQ[{+##,1##}&@@IntegerDigits@x,n],x++];±n=x)}

अब अगर हम मूल्यांकन करें ±20:

In[3]:= ±20
In[3]:= 225

In[4]:= DownValues@PlusMinus
Out[4]= {HoldPattern[±0] :> 0, HoldPattern[±1] :> 1, HoldPattern[±2] :> 2, HoldPattern[±3] :> 3, HoldPattern[±4] :> 4, HoldPattern[±5] :> 5, HoldPattern[±6] :> 6, HoldPattern[±7] :> 7, HoldPattern[±8] :> 8, HoldPattern[±9] :> 9, HoldPattern[±10] :> 19, HoldPattern[±11] :> 29, HoldPattern[±12] :> 34, HoldPattern[±13] :> 49, HoldPattern[±14] :> 59, HoldPattern[±15] :> 69, HoldPattern[±16] :> 79, HoldPattern[±17] :> 89, HoldPattern[±18] :> 92, HoldPattern[±19] :> 199, HoldPattern[±20] :> 225, HoldPattern[±n_] :> (For[x=±(n-1),FreeQ[{+##,1##}&@@IntegerDigits@x,n],x++];±n=x)}

यह नाटकीय रूप से भविष्य की गणना को गति देता है क्योंकि गणितज्ञ अब 0और 20पुनरावर्ती के बीच के मूल्यों की गणना नहीं करेगा । बचाया गया समय अधिक नाटकीय हैn बढ़ता है:

In[5]:= Quit[]

In[1]:= ±0=0;±n_:=(For[x=±(n-1),FreeQ[{+##,1##}&@@IntegerDigits@x,n],x++];±n=x)

In[2]:= AbsoluteTiming[±60]
Out[2]= {23.0563, 6111125}

In[3]:= AbsoluteTiming[±60]
Out[3]= {9.89694*10^-6, 6111125}

— ngenisis
स्रोत

यह F (N - 1) के बजाय F (N - 1) + 1 से शुरू होता है; पुनरावृत्ति सख्ती से बढ़नी चाहिए।

— लीजनमोनमाल 978

2

सी #, 155 159 135 बाइट्स

a=n=>{if(n<1)return 0;int i=n,s=0,p=1,N=a(n-1);for(;;){s=0;p=1;foreach(var c in++i+""){s+=c-48;p*=c-48;}if(i>N&(s==n|p==n))return i;}};

सुपर अक्षम, बस के लिए एक लंबा समय लगता है N>=14। गोना अधिक कुशल, लेकिन लंबे समय तक समाधान प्राप्त करने की कोशिश करता है।

ठीक है, अब बहुत बेहतर है, लेकिन 4 बाइट्स लंबे समय तक। ओह ठीक है, मैं N<=50अब बहुत जल्दी कर सकता हूं । 24 बाइट बचाने के लिए @milk धन्यवाद!

— Yodle
स्रोत

-2 बाइट्स के साथ for(;;)और फॉरच के साथ को बदलने के लिए foreach(var c in++i+"")। -22 बाइट्स के int.Parse(c+"")साथ बदलने के लिए c-48।

— दूध

2

पायथ - 18 17 बाइट्स

एक बाइट @Jakube के लिए धन्यवाद बचा लिया!

पुनरावर्ती कार्य करने के लिए उपयोग कम करता है।

uf}HsM*FBjT;hGSQZ

टेस्ट सूट ।

— Maltysen
स्रोत

sM*FBjT;अंक योग और उत्पाद भी उत्पन्न करता है और 1 बाइट छोटा होता है।

— जकूबे

@ जाकुब ऊँ अच्छी चाल

— माल्टीसेन

1

आर, 124 112 बाइट्स

f=function(N){y=x=`if`(N-1,f(N-1),0);while(N!=prod(y)&N!=sum(y)){x=x+1;y=as.double(el(strsplit(c(x,""),"")))};x}

N = 45 पर विफल रहता है क्योंकि R 1e + 05 के रूप में 10.000 लिखने पर जोर देता है, जो कि सराहना नहीं करता है as.numeric(), यह as.integer()12 बाइट्स की लागत से उपयोग करने योग्य है:

f=function(N){y=x=`if`(N-1,f(N-1),0);while(N!=prod(y)&N!=sum(y)){x=x+1;y=as.double(el(strsplit(c(as.integer(x),""),"")))};x}

एक सांख्यिकीय प्रोग्रामिंग भाषा के रूप में, आर अंकों की एक सदिश में संख्याओं को विभाजित करने के तरीके से परेशान है। विशेष रूप से क्योंकि सब कुछ स्पष्ट रूप से संख्यात्मक मूल्यों के लिए स्ट्रिंग से वापस परिवर्तित किया जाना है।

12 बाइट्स बिलीवोब के लिए धन्यवाद बचाए।

— JAD
स्रोत

1

आप as.double(el(strsplit(c(x,""),"")))एक पूर्णांक को उसके अंकों के वेक्टर में विभाजित करने के लिए उपयोग कर सकते हैं । हालाँकि, आप अभी भी प्रारूपण मुद्दे में भागते हैं, लेकिन आपके उत्तर के अनुसार हल किया जा सकता हैas.integer()

— बिलीवोब

ओह, एक स्ट्रिंग में एक्स को मजबूर करने का चतुर तरीका: ओ

— जेएडी

आप sprintf()इसके बजाय पूर्णांक में एक स्ट्रिंग के साथ पूर्णांक को प्रारूपित करने के बजाय सीधे उपयोग कर सकते हैं: as.double(el(strsplit(sprintf("%1.f",x),"")))और as.integer()

— बिलीवोब

@ LegionMammal978 पहली बात यह है कि यह लूप में है x=x+1और यह एक बार मूल्यांकन करने की गारंटी है, क्योंकि शुरुआत में y=F(N-1)जो निश्चित रूप से नहीं के बराबर है N।

— JAD

@JarkoDubbeldam वूप्स, इसे गलत समझें: पी

— लीजनमैमल 978

1

जावास्क्रिप्ट (ईएस 6) 109 107 105 91 89 बाइट्स

f=n=>n&&eval(`for(i=f(n-1);++i,${x="[...i+''].reduce((r,v)=>"}+r+ +v)-n&&${x}r*v)-n;);i`)



console.log(f.toString().length + 2); 
console.log(f(25));
console.log(f(13));
console.log(f(8));

स्निपेट का विस्तार करें

— Lmis
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 84 86

संपादित करें: 2 बाइट्स ने thx @Arnauld को बचाया

f=n=>eval("for(v=n&&f(n-1),p=s=n+1;s&&p-1;)[...++v+''].map(d=>(p/=d,s-=d),p=s=n);v")

50 से ऊपर का टेस्ट नोट यह आपके CPU का बहुत अधिक उपयोग करेगा, बहुत देर होने से पहले रोकने के लिए 'परिणाम छिपाएं' पर क्लिक करें

f=n=>eval("for(v=n&&f(n-1),p=s=n+1;s&&p-1;)[...++v+''].map(d=>(p/=d,s-=d),p=s=n);v")

out=x=>O.textContent=x+'\n'+O.textContent

i=0
step=_=>out(i+' '+f(i),++i,setTimeout(step,i*10))

step()

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

मुझे लगता है कि for(v=n&&f(n-1),p=s=n+1;s&&p-1;)[...++v+''].map(d=>(p/=d,s-=d),p=s=n);v2 बाइट्स बचाना चाहिए। मुझे संदेह है कि इसे कुछ और छोटा किया जा सकता है, लेकिन मैं अभी तक इसका पता नहीं लगा सका।

— अरनुलद

@ अरनल्ड मैं उम्मीद करता हूं कि बार-बार फ्लोटिंग पॉइंट डिवीजन के साथ कुछ समस्या होगी

— edc65

हमारी एकमात्र आवश्यकता यह है कि वास्तव में एक विभाजक p /= dहोने पर एक सटीक परिणाम उत्पन्न होता dहै p। जब तक मैं गलत नहीं हूँ, यह किसी के लिए भी सच है d <= p <= Number.MAX_SAFE_INTEGER। हमें फ़्लोटिंग पॉइंट राउंडिंग एरर मिलेगा जब p % d != 0, लेकिन वह सुरक्षित होना चाहिए।

— अरनुलद

@darrylyeo ऐसे सुझाव न दें जिन्हें आपने स्वयं नहीं आज़माया (कोशिश करें eval`1+1` ) (यहाँ क्यों कोडगुल्फ़.स्टैकएक्सचेंज.com / a / 52204 / 21348 : पहली टिप्पणी पढ़ें)

— edc65

1

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

a@0=0;a@b_:=NestWhile[#+1&,a[b-1]+1,+##!=b&&1##!=b&@*IntegerDigits]

फंक्शन, नाम दिया गया a। नंबर को इनपुट के रूप में लेता है और आउटपुट के रूप में एक नंबर देता है। पिछले Mathematica समाधान से प्रेरित है, लेकिन एक अलग लूपिंग तंत्र का उपयोग करता है।

— LegionMammal978
स्रोत

1

सी, 240 बाइट्स

int f(char n){int q[19],i=19,r=n%9,j=9,*p=q,c=n/9;while(i)q[--i]=0;if(c){if(!r){r=9;c--;}q[9]=c;if(!(n%r)){n/=r;while((j-1)*(n-1)*c){if(n%j)j--;else{c--;q[9+j]++;n/=j;}}q[10]=c;if(1==n)p+=9;}while(++i<10){while(p[i]--)r=r*10+i;}}return(r);}

अनुक्रम के कुछ गणित गुणों का फायदा उठाने की कोशिश कर रहा है।

— bernaf
स्रोत

0

PowerShell v3 +, 114 बाइट्स

param($n)$i=,0;$l=1;1..$n|%{for(;$_-notin((($b=[char[]]"$l")-join'+'|iex)),(($b-join'*'|iex))){$l++}$i+=$l};$i[$n]

Iterative solution, किसी संख्या को अपने अंकों के योग / उत्पाद में बदलने का कोई आसान तरीका नहीं है, इसलिए यह जावास्क्रिप्ट उत्तरों की तुलना में काफी लंबा है।

इनपुट लेता है $n, सेट $iसिर्फ साथ एक सरणी के लिए 0(इस का संग्रह है F(), और सेट $lके बराबर 1(इस नवीनतम है Fसे ऊपर की ओर तो)। हम पाश 1करने के लिए $n, प्रत्येक यात्रा को क्रियान्वित करने के लिए एकfor पाश।

forपाश की सशर्त लेता $latest संख्या, एक स्ट्रिंग में "$l", फिर डाले है कि एक के रूप में char-array, और दुकानों कि अस्थायी चर में सरणी $b। हम फिर -joinउन अंकों को एक साथ +जोड़ते हैं और पाइप को iex(कम Invoke-Expressionऔर इसी तरह eval)। इसके अतिरिक्त, हम भी इसी तरह के साथ करते हैं *। उन दो नंबरों को पार्न्स में एनकैप्स किया जाता है और बाहरी लूप -notinकी वर्तमान संख्या $_के खिलाफ ऑपरेटर के लिए सरणी तर्क के रूप में माना जाता है (यानी, forलूप या तो लंबे समय तक चलता है+ और इससे *भिन्न होता है $_)। forलूप का शरीर सिर्फ वेतन वृद्धि करता है $l++।

एक बार हम उस भीतर से बाहर आ गए for पाश से , तो हम अपने $lनए तत्व के रूप में जोड़ते हैं $i। एक बार जब हम पूरी तरह से रेंज लूप पूरा कर लेते हैं, तो हम बस $i[$n]पाइप लाइन पर रख देते हैं , और आउटपुट निहित होता है।

एनबी - 20लूप संरचना के कारण, बस के बारे में ऊपर निष्पादित करने के लिए बहुत धीमा हो जाता है । उदाहरण के लिए, N=40मेरी मशीन पर लगभग दो मिनट लगते हैं, और मैंने परीक्षण भी नहीं किया है N>50।

— AdmBorkBork
स्रोत

0

पाइके, 17 बाइट्स

t.fY'Bs]~ohR{Io(e

यहाँ कोशिश करो!

या 13 बाइट्स नॉन-कंपेटिटिव

first_nअब उपयोग में आने वाली वस्तुओं की मात्रा पहले से ही एक से अधिक रखता iहै।

Q.fY'Bs]iR{)e

यहाँ कोशिश करो!

Q.f        )  -  first_n(input, start=1)
   Y          -   digits(^)
    'Bs]      -   [sum(^), product(^)]
         R}   -   V in ^
        i     -    len(results)+1
            e - ^[-1]

— नीला
स्रोत

0

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

f=lambda n,k=0,r=0:-(k>n)or-~f(n,k+(k in[eval(c.join(`r`))for c in'+*']),r+1)

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

— डेनिस
स्रोत

0

आश्चर्य है , 49 बाइट्स

f\.{0\0@(:>@(| =#1sum#0)=#1prod#0)(dp +1f -#0 1)N

पैटर्न मिलान ftw! उपयोग:

f\.{0\0@(:>@(| =#1sum#0)=#1prod#0)(dp +1f -#0 1)N}; f 10

अधिक पठनीय:

f\.{
  0\0
  @(
    find @(or = #1 sum #0) = #1 prod #0
  ) (dp + 1 (f -#0 1)) N
}

यह मूल रूप से ऐनक का केवल शब्द-दर-शब्द कार्यान्वयन है।

— मामा फन रोल
स्रोत

0

BASH, 107 बाइट्स

गुना + पेस्ट + बीसी के साथ

for ((;n<=$1;z++)){
p(){ fold -1<<<$z|paste -sd$1|bc;}
[ `p +` = $n -o `p \*` = $n ]&&((z-->n++))
}
echo $z

— इपोर सिरकिर
स्रोत

0

Befunge, 101 बाइट्स

&20p>:000pv
>\1+^vp011<
| >.@>:55+%:00g+00p10g*v>10g-*
::\$_^#!:/+55p01*!`"~":<^\-g00
< |!-g02
+1< v\

इसे ऑनलाइन आज़माएं! लेकिन ध्यान दें कि उच्च मंचों में आने के बाद यह वास्तव में धीमा होने वाला है। यदि आप पूरी श्रृंखला का परीक्षण करना चाहते हैं, तो आपको वास्तव में एक बेफ़ुंज कंपाइलर का उपयोग करने की आवश्यकता है।

व्याख्या

&20p           Read N and save for later.

>              Start of main loop; current target and test number on stack, initially 0.
:              Duplicate the test number so we can manipulate it.
000p           Initialise the sum to 0.
110p           Initialise the product to 1.

>              Start of inner loop.
:55+%:         Modulo 10 of the test number to get the first digit.
00g+00p        Add to the sum.
10g*           Multiply by the product.
:"~"`!*        If greater than 126, set to 0 to prevent overflows - it'll never match.
10p            Update the product variable.
55+/           Divide the test number by 10 to get the next digit.
:!_            If not zero, repeat the inner loop

$              Drop the zero left over from the loop.
\::00g-\10g-   Compare the sum and product with the current target.
*|             Multiply the two diffs and branch; up if no match, down if either match.
\1+^           On no match, we increment the test number and repeat the main loop.
:>20g-!|       With a match, we compare the current target with the saved N.
1+\v           If that doesn't match, increment the current target and restart main loop.
\>.@           If it does match, we've got our result; output it and exit.

— जेम्स होल्डरनेस
स्रोत

0

PHP , 110 बाइट्स

for(;$c<=$a=$argn;$c=count($r))array_product($s=str_split($n++))!=$c&&array_sum($s)!=$c?:$r[]=~-$n;echo$r[$a];