गुणक हठ

46

गुणक हठ

  1. किसी संख्या में सभी अंकों को गुणा करें
  2. तब तक दोहराएं जब तक आपके पास एक भी अंक न बचा हो

जैसा कि नंबरफाइल द्वारा समझाया गया है :

उदाहरण

  1. 277777788888899 → 2x7x7x7x7x7x7x8x8x8x8x8x8x9x9 = 4996238671872
  2. 4996238671872 → 4x9x9x6x2x3x8x6x7x1x8x7x2 = 438939648
  3. 438939648 → 4x3x8x9x3x9x6x4x8 = 4478976
  4. 4478976 → 4x4x7x8x9x7x6 = 338688
  5. 338688 → 3x3x8x6x8x8 = 27648
  6. 27648 → 2x7x6x4x8 = 2688
  7. 2688 → 2x6x8x8 = 768
  8. 768 → 7x6x8 = 336
  9. 336 → 3x3x6 = 54
  10. 54 → 5x4 = 20
  11. 20 → 2x0 = 0

यह वर्तमान रिकॉर्ड है, जिस तरह से: सबसे बड़ी संख्या के साथ सबसे छोटी संख्या।

गोल्फ़

एक प्रोग्राम जो इनपुट के रूप में किसी भी पूरे नंबर को लेता है और फिर प्रत्येक चरण के परिणाम को इनपुट के साथ शुरू करता है, जब तक कि हम एक अंक नहीं लेते। 277777788888899 के लिए आउटपुट होना चाहिए

277777788888899
4996238671872
438939648
4478976
338688
27648
2688
768
336
54
20
0

(चरणों की संख्या की गणना उपयोगकर्ता के लिए एक अभ्यास के रूप में छोड़ दी जाती है)।

और ज्यादा उदाहरण

से A003001 :

25
10
0

A003001 से भी:

68889
27648
2688
768
336
54
20
0

से Numberphile वीडियो:

327
42
8

इसलिए Additive Persistence के बारे में एक प्रश्न आया है , लेकिन यह Multiplicative Persistence है। इसके अलावा, यह सवाल आउटपुट के रूप में चरणों की संख्या के लिए पूछता है, जबकि मैं मध्यवर्ती परिणाम देखने में रुचि रखता हूं।

code-golf  math  arithmetic  repeated-transformation 
— SQB
स्रोत
बोनस: एक नया रिकॉर्ड खोजें: सबसे बड़ी संख्या के साथ सबसे छोटी संख्या। कैविएट: अनुमान यह है कि 11 सबसे बड़ा संभव है।
— एसक्यूबी
7
आपको संभवतः कुछ और परीक्षण मामलों को शामिल करना चाहिए जो साथ समाप्त नहीं होते हैं । 0
— अरनुलद
इस पोस्ट को बनाने के लिए, यह पहले से ही मौजूद है, जीजी
— कैट
एकल अंक वैध इनपुट है?
— द्विजिमा
1
नंबरफाइल वीडियो में, मैट पार्कर बताता है कि खोजों को कई सौ अंकों में किया गया है।
— हार्डस्केल

जवाबों:

7

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

DP$Ƭ

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

व्याख्या

D    | convert to decimal digits
 P   | take the product
  $  | previous two links as a monad
   Ƭ | loop until no change, collecting all intermediate results

एक बोनस के रूप में, यहां एक TIO है जो अंकों की संख्याओं की दी गई श्रेणी के लिए सबसे बड़ी संख्या के साथ संख्याओं को खोजेगा। यह TIO पर भी अच्छी तरह से स्कोर करता है।

— निक केनेडी
स्रोत
15

TI-BASIC (TI-84), 30 32 31 बाइट्स

-1 बाइट थैंक्स टू @ सोलोमन्यूको!

While Ans>9:Disp Ans:prod(int(10fPart(Ans10^(seq(-X-1,X,0,log(Ans:End:Ans

इनपुट में है Ans।
आउटपुट को चुनौती के अनुरोध के रूप में प्रदर्शित किया जाता है। Ansअंतिम चरण को प्रिंट करने के लिए ट्रेलिंग की आवश्यकता होती है।

मैं स्वीकार करूंगा, मैंने खुद इस फॉर्मूले के बारे में नहीं सोचा था, बल्कि मैंने इसे यहां पाया और इसे चुनौती को बेहतर ढंग से फिट करने के लिए संशोधित किया।

संपादित करें: चुनौती को फिर से जारी करने पर, मुझे एहसास हुआ कि उत्पाद को एक अंक होने पर कार्यक्रम को समाप्त करना होगा। इसलिए, इसके लिए खाते में 2 बाइट्स जोड़े जाने थे।

उदाहरण:

24456756
        24456756
prgmCDGF8
        24456756
          201600
               0
11112
           11112
prgmCDGF8
           11112
               2

स्पष्टीकरण:

While Ans>9               ;loop until the product is one digit
Disp Ans                  ;display the current product
prod(                     ;get the product of...
 int(                     ; the integer part of...
  10fPart(                ; ten times the fractional part of...
  Ans                     ; each element in the following list times the
                          ;  current product
  10^(                    ; multiplied by the list generated by using each
                          ;  element of the following list as an exponent
                          ;  for 10^n
   seq(-X-1),X,0,log(Ans  ; generate a list of exponents from -1 to -L where
                          ;  L = the length of the current product
End
Ans                       ;leave the final product in "Ans" and implicitly
                          ; print it

दृश्य मॉडल: के
Ans रूप में शुरू होता है 125673।
यह मॉडल केवल अंकों को गुणा करने के पीछे के तर्क को शामिल करता है; बाकी सब समझना आसान है।

seq(-X-1,X,0,log(Ans  =>  seq(-X-1,X,0,5.0992
   {-1 -2 -3 -4 -5 -6}
10^(...
   {.1 .01 .001 1E-4 1E-5 1E-6}
Ans...
   {12567.3 1256.73 125.673 12.5673 1.25673 .125673}
fPart(...
   {.3 .73 .673 .5673 .25673 .125673}
10...
   {3 7.3 6.73 5.673 2.5673 1.25673}
int(...
   {3 7 6 5 2 1}
   (the digits of the number, reversed)
prod(...
   1260
   (process is repeated again)

seq(-X-1,X,0,log(Ans  =>  seq(-X-1,X,0,3.1004
   {-1 -2 -3 -4}
10^(...
   {.1 .01 .001 1E-4}
Ans...
   {126 12.6 1.26 .126}
fPart(...
   {0 .6 .26 .126}
10...
   {0 6 2.6 1.26}
int(...
   {0 6 2 1}
prod(...
   0
   (product is less than 10.  loop ends)

टिप्पणियाँ:

TI-BASIC एक टोकन भाषा है। कैरेक्टर काउंट बाइट काउंट नहीं के बराबर होता है ।

10^(है यह एक-बाइट टोकन ।

यह प्रोग्राम TI कैलकुलेटर पर दशमलव परिशुद्धता की सीमाओं के कारण 14 अंकों से अधिक पूर्णांक वाले उत्पादों का सही अनुक्रम प्रदान नहीं करेगा।

— ताउ
स्रोत
क्या आप एक बाइट को 10^(बाहर ले जाकर seq(बंद कोष्ठक को छोड़ कर बचा सकते हैं ?
— सोलोमन उको
हां, मेरा ऐसा मानना ​​है!
— ताऊ
11

के (ngn / k) , 9 बाइट्स

{*/.'$x}\

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

{ }\ फ़ंक्शन को घुंघराले ब्रेसिज़ में तब तक लगाते रहें जब तक कि अनुक्रम परिवर्तित न हो जाए

$x तर्क को एक स्ट्रिंग के रूप में प्रारूपित करें (वर्णों की सूची)

.'प्रत्येक का मूल्यांकन करें (k की अन्य बोलियों के लिए एक बृहदान्त्र की आवश्यकता होती है .:')

*/ समय से अधिक, यानी उत्पाद

— NGN
स्रोत
8

आर , 59 बाइट्स

n=scan();while(print(n)>9)n=prod(n%/%10^(nchar(n):1-1)%%10)

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

चूंकि print invisiblyइसका इनपुट वापस मिलता है, हम लूप का अनुकरण करने के print(n)लिए whileलूप के अंदर उपयोग कर सकते हैं do-while। यह आर में गोल्फ के लिए मेरी युक्तियों से प्रेरित है ।

शीर्षलेख वैज्ञानिक संकेतन में बड़ी संख्या को मुद्रित होने से रोकने में मदद करता है।

— ग्यूसेप
स्रोत
8

05AB1E , 7 4 बाइट्स

Δ=SP

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Δ     # Loop until the number no longer changes:
 =    #  Print the number with trailing newline (without popping the number itself)
      #  (which will be the implicit input in the first iteration)
  SP  #  Convert the number to a list of digits, and calculate its product
— केविन क्रूज़सेन
स्रोत
7

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

-3 धन्यवाद xnor (जंजीर तुलना)

def f(n):print n;n>9>f(eval('*'.join(`n`)))

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

— जोनाथन एलन
स्रोत
के >स्थान पर कर सकते हैं and।
— xnor
@ धन्यवाद धन्यवाद, आसान है कि काम करने के लिए भूल जाएगा।
— जोनाथन एलन
5

पॉवरशेल , 54 बाइट्स

for($a=$args;$a-gt9){$a;$a=("$a"|% t*y)-join"*"|iex}$a

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

Iterative विधि जो पहले इनपुट तर्क लिखती है, फिर इसे एक स्ट्रिंग में परिवर्तित करती है और इसे एक वर्ण सरणी में पाइप करती है। इस सरणी को एकल तारांकन द्वारा जोड़ा जाता है, और आह्वान अभिव्यक्ति उपनाम के साथ एक कमांड के रूप में निष्पादित किया जाता है। चूंकि यह प्रारंभिक संख्या को 0 से अधिक अंतिम संख्या तक कम करता है, (20, दिए गए परीक्षण परिदृश्य में), मैं $aआउटपुट के अंत में एक अंतिम जोड़ता हूं ।

— KGlasier
स्रोत
5

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 79 74 68 बाइट्स

void f(int a){Print(a);if(a>9)f((a+"").Aggregate(1,(j,k)=>k%48*j));}

मैं सी # में पुनरावृत्ति से दूर रहने की कोशिश करता हूं कि विधि की घोषणा कितने समय तक होती है, लेकिन इस मामले में यह लूप की तुलना में बचाता है।

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

— अज्ञान का अवतार
स्रोत
5

PHP , 63 बाइट्स

<?=$n=$argn;while($n>9)echo"
",$n=array_product(str_split($n));

Iterative संस्करण, php -nFसे इनपुट के साथ कॉल करें STDIN।

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

PHP ,72 71 बाइट्स

function h($n){echo"$n
",($n=array_product(str_split($n)))>9?h($n):$n;}

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

फ़ंक्शन के रूप में पुनरावर्ती संस्करण।

इनपुट: 277777788888899

277777788888899
4996238671872
438939648
4478976
338688
27648
2688
768
336
54
20
0

इनपुट: २३

23
6
— 640KB
स्रोत
5

पायथन 2 , 61 62 59 बाइट्स

def f(n):print n;n>9and f(reduce(int.__mul__,map(int,`n`)))

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

-3 बाइट्स, जोनाथन एलन के लिए धन्यवाद

— TFeld
स्रोत
उन इनपुटों के लिए काम नहीं करता है जो अपने अंतिम पुनरावृत्ति पर 0 के साथ समाप्त नहीं होते हैं, उदाहरण के लिए 23
— अज्ञानता का अवतार
int.__mul__तीन बाइट्स से भी कम हैlambda a,b:a*b
— जोनाथन एलन
@JonathanAllan धन्यवाद! मुझे पता था कि ऐसा कुछ होना चाहिए
— TFeld
13 बाइट बचाने के f(reduce(int.__mul__,map(int,`n`)))लिए बदलें f(eval('*'.join(`n`)))।
— मैपरिलियन
@mypetlion ... मैंने पहले ही एक और पोस्ट में किया था।
— जोनाथन एलन
5

पर्ल 5 ( -n -M5.01), 32 30 25 बाइट्स

say$_=eval;s/\B/*/g&&redo

25 बाइट्स

30 बाइट्स

32 बाइट्स

— नहुएल फौलीउल
स्रोत
आपको लगता है कि इस का उपयोग करता है उल्लेख करना चाहिए-lpF//
— ग्रिमी
1
@Grimy मैं 2 बाइट्स को बिना उपयोग किए -lpF//, अपडेट करने से बचा सकता है
— नहुएल फौलीउल
5

मैथॉल्फ , 9 10 बाइट्स

h(ôo▒ε*h(→

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

अब यह सही ढंग से इनपुट्स को हैंडल करता है जो सिंगल अंक हैं। सही नहीं है, लेकिन कम से कम यह सही है।

व्याख्या

h(            check length of input number and decrease by 1
  ö       →   while true with pop using the next 6 operators
   p          print with newline
    ▒         split to list of chars/digits
     ε*       reduce list by multiplication
       h(     length of TOS without popping, subtracted by 1 (exits when len(TOS) == 1)
— maxb
स्रोत
एकल अंक इनपुट के लिए आउटपुट संख्या की एक प्रति होनी चाहिए - टिप्पणियों में स्पष्ट
— dzima
@dzaima मैं इसे देखूंगा, और इसका हल होने पर उत्तर को अपडेट
— करूंगा
4

एपीएल (एनएआरएस), 19 चार्ट, 38 बाइट्स

{⍵≤9:⍵⋄∇×/⍎¨⍕⍵⊣⎕←⍵}

परीक्षा:

   f←{⍵≤9:⍵⋄∇×/⍎¨⍕⍵⊣⎕←⍵}
   f 23     
23
6
   f 27648     
27648
2688
768
336
54
20
0
— RosLuP
स्रोत
4

जाप -R , 9 बाइट्स

बुरी तरह से अक्षम - पहले परीक्षण मामले को चलाने की कोशिश भी मत करो !

_ì ×}hN â

कोशिश करो

_ì ×}hN â     :Implicit input of integer U
      N       :Starting with the array of inputs (i.e., [U])
     h        :Do the following U times, pushing the result to N each time
_             :Take the last element in N and pass it through the following function
 ì            :  Convert to digit array
   ×          :  Reduce by multiplication
    }         :End function
        â     :Deduplicate N
              :Implicitly join with newlines and output
— झबरा
स्रोत
3

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

ẉ?Ḋ|ẹ×↰

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

व्याख्या

ẉ          Write the input followed by a linebreak
 ?Ḋ        If the input is a single digit, then it's over
   |       Otherwise
    ẹ      Split the input into a list of digits
     ×     Multiply them together
      ↰    Recursive call with the result of the multiplication as input
— Fatalize
स्रोत
मैंने इसे खुद आजमाया। के बारे में भूल गए। बाकी मैं वही था।
— क्रॉफेब
3

जावास्क्रिप्ट (बैबेल नोड) , 46 बाइट्स

f=a=>a>9?[a,...f(eval([...a+''].join`*`))]:[a]

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

जावास्क्रिप्ट (बैबेल नोड) , 44 बाइट्स

यदि इनपुट को स्ट्रिंग के रूप में लिया जा सकता है

f=a=>a>9?[a,...f(''+eval([...a].join`*`))]:a

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत
@Arnauld हां, मैंने सिर्फ गलत कोड को संपादित और जोड़ा है। Im अभी भी सरणियों के बजाय केवल तार का उपयोग करके कुछ ढूंढ रहा है
— लुइस फेलिप डी जीसस मुनोज़
3

पॉवरशेल , 64 59 बाइट्स

for($a="$args";9-lt$a){$a;$a="$(($a|% t*y)-join'*'|iex)"}$a

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

Iterative विधि। इनपुट लेता है और इसे स्टोर करता है $a, फिर एक forलूप में प्रवेश करता है जब तक कि लंबाई $aदो या अधिक हो जाती है (यानी, यह उससे बड़ा है 9)। लूप के अंदर हम आउटपुट करते हैं $aऔर फिर इसे toCharArra में परिवर्तित करके पुनर्गणना करते हैं y, joinइसे एक साथ जोड़ते हैं *, और फिर iex(कम Invoke-Expressionऔर इसी तरह eval)। एक बार जब हम लूप से बाहर हो जाते हैं, तो हमारे पास प्रिंट करने के लिए एक ही अंक बचा होता है, इसलिए हम $aफिर से पाइपलाइन पर जगह बनाते हैं ।

-5 बाइट्स केगलसियर को धन्यवाद।

— AdmBorkBork
स्रोत
आप 5 बाइट्स को बचाने के 9-lt$aबजाय तुलना का उपयोग कर सकते हैं $a.length-1। और अगर आप पूरे समय के लिए स्ट्रिंग नहीं गए तो आप एक अच्छा हिस्सा काट सकते हैं। अगर तुम चाहो तो मेरे अधिकार की कोशिश की जाँच करें !
— केजलसियर
3

चारकोल , 13 बाइट्स

θＷ⊖Ｌθ«≔ＩΠθθ⸿θ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

θ

पहली बार इनपुट प्रिंट करें।

Ｗ⊖Ｌθ«

दोहराएं जबकि इनपुट की लंबाई 1 नहीं है।

≔ＩΠθθ

इनपुट को उसके डिजिटल उत्पाद को स्ट्रिंग में बदलें।

⸿θ

इनपुट को एक नई लाइन पर प्रिंट करें।

— नील
स्रोत
3

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

.+~(\`

.
$&$*
^
.+¶$$.(

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+~(\`

प्रत्येक लूप की शुरुआत में अपनी लाइन पर वर्तमान मूल्य प्रिंट करें जब तक कि यह बदलना बंद न हो जाए और अपरिवर्तित मूल्य को दो बार प्रिंट न करें। प्रत्येक लूप के अंत में वर्तमान मूल्य का मूल्यांकन करें।

.
$&$*

*प्रत्येक अंक के बाद जोड़ें ।

^
.+¶$$.(

इनपुट को डिजिटल उत्पाद का मूल्यांकन करने वाली अभिव्यक्ति में बदलना।

सिर्फ रिकॉर्ड के लिए, रेटिना एक लाइन (25 बाइट्स) में ऐसा कर सकता है:

.+"¶"<~[".+¶$.("|'*]'*L`.
— नील
स्रोत
3

सी (जीसीसी) , 58 बाइट्स

f(n,t){for(;n=printf("%d\n",t=n)>2;)for(;n*=t%10,t/=10;);}

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

Iterative दृष्टिकोण 1 बाइट छोटा हो जाता है।

f(n,t){
    for(;n=printf("%d\n",t=n)   //print and update current number
            >2;)                //until only one digit is printed
        for(;n*=t%10,t/=10;);   //n*= product of digits of t (step)
}

सी (जीसीसी) , 61 59 बाइट्स (पुनरावर्ती)

f(n){printf("%d\n",n)>2&&f(p(n));}p(n){n=n?n%10*p(n/10):1;}

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

प्रिंट और स्टेप दोनों के लिए पुनरावृत्ति पुनरावृत्ति से कम लगती है ...

— attinat
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.