सबसे अच्छा आधार 10 है ... चलो इसे तक पहुँचने!

Question

इनपुट:

एक सकारात्मक पूर्णांक n श्रेणी 0-9 में अंकों से मिलकर बनता है ।

चुनौती:

यदि पूर्णांक में d उच्चतम अंक है, तो मान लें कि संख्या का आधार d + 1 है । उदाहरण के लिए यदि पूर्णांक 1256 है तो आप मान लेंगे कि यह आधार -7 में है , यदि यह 10110 है तो आप मान लेंगे कि यह आधार -2 (बाइनरी) है, और यदि यह 159 है तो यह दशमलव है।

अब, जब तक आप या तो निम्न न करें, 1: बेस -10 पूर्णांक तक पहुंचें , या 2: एकल अंक पूर्णांक तक पहुंचें।

1. पूर्णांक को आधार- (d + 1) से आधार -10 में बदलें
2. इस नए पूर्णांक के आधार को खोजें (फिर से, आधार- (d + 1) जहां d नई संख्या में उच्चतम अंक है)
3. चरण 1 पर जाएं ।

---

उदाहरण:

मान लें कि इनपुट n = 413574 है । उच्चतम अंक d = 7 , इसलिए यह आधार -8 (अष्टक) है। इसे दशमलव में बदलें और 137084 प्राप्त करें । उच्चतम अंक d = 8 , इसलिए यह आधार -9 है । इसे दशमलव में परिवर्तित करें और 83911 प्राप्त करें । उच्चतम अंक 9 है , इसलिए यह एक दशमलव संख्या है और हम रोकते हैं। आउटपुट 83911 होगा ।

मान लें कि इनपुट n = 13552 है । उच्चतम अंक d = 5 है , इसलिए यह आधार -6 है । इसे दशमलव में परिवर्तित करें और 2156 प्राप्त करें । उच्चतम अंक d = 6 है , इसलिए यह बेस -7 है । इसे दशमलव में परिवर्तित करें और 776 प्राप्त करें । उच्चतम अंक d = 7 है , इसलिए यह आधार -8 है । इसे दशमलव में बदलें और 510 प्राप्त करें । उच्चतम अंक d = 5 है इसलिए यह बेस -6 है । इसे दशमलव में परिवर्तित करें और 186 प्राप्त करें । उच्चतम अंक 8 है , इसलिए यह आधार -9 है । इसे दशमलव में बदलें और 159 प्राप्त करें। उच्चतम अंक 9 है , इसलिए यह एक दशमलव संख्या है और हम रोकते हैं। आउटपुट 159 होगा ।

मान लें कि इनपुट n = 17 है । यह हमें 15 , फिर 11 , फिर 3 देगा , जिसे हम एक अंक के बाद से आउटपुट करेंगे।

---

परीक्षण के मामलों:

5
5

17
3

999
999

87654321  (base-9 -> 42374116 in decimal -> base-7 -> 90419978 in decimal) 
9041998

41253  (5505 -> 1265 -> 488 -> 404 -> 104 -> 29)
29

---

टिप्पणियाँ:

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

---

जाहिर है, यह OEIS A091047 है ।

Comments

जाहिर तौर पर मुझे मैट्रिसेस पसंद हैं , इसलिए मैंने सोचा कि मैं इसके बजाय बेस-कन्वर्जन चैलेंज करूंगा ।

— स्टिव ग्रिफिन

"सर्वश्रेष्ठ आधार 10 है" ... "10" किस आधार में लिखा गया है?

— ओलिवियर ग्रेजायर

@ OlivierGrégoire यह चतुर बात है ... हम जो भी आधार के साथ समाप्त होते हैं, वह अभी भी एक वैध बयान होगा!

— स्टीवी ग्रिफिन

@StewieGriffin लेकिन आप इसे कैसे पढ़ते हैं? प्रत्येक बेस में "10" का एक अलग नाम है।

— user11153

खैर, यह आधार पर निर्भर करता है ... या जैसा कि मेघन यह कहेंगे "यह सब उस आधार के बारे में है, 'लेकिन उस आधार के बारे में, कोई परेशानी नहीं" ;-)

— स्टीवी ग्रिफिन

Answer 1

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

#//.x_/;(b=Max[d=IntegerDigits@x]+1)<11:>d~FromDigits~b&

इसे ऑनलाइन आज़माएं! (गणित का उपयोग करना।)

मैंने सोचा कि मैं जाँच करूँगा कि अनुक्रम कैसा दिखता है:

और यहां परिणाम खोजने के लिए उठाए जाने वाले कदमों की संख्या है:

^{(बड़े संस्करणों के लिए क्लिक करें। केवल n = 1000 तक के भूखंडों के लिए संशोधन इतिहास देखें ।)}

बड़े पैमाने पर संरचना और ठीक पैमाने की अराजकता का एक बहुत ही दिलचस्प मिश्रण जैसा दिखता है। मुझे आश्चर्य है कि 30,000 और 60,000 के आसपास के व्यापक अंतराल के साथ क्या हो रहा है।

Comments

@StewieGriffin बाईं ओर होना चाहिए। छोटे अंतराल होते हैं, क्योंकि 10 की शक्ति के कई के लिए अग्रणी संख्या में एक होते हैं 9, इसलिए वे पहले से ही आधार 10 में हैं। लेकिन 30k और 60k के लिए ऐसा लगता है कि संख्या 8 या 7 के साथ है (और करना होगा) जांच) कि 9 के स्थान पर हमेशा एक कदम के बाद बेस 10 हो जाते हैं।

— मार्टिन एंडर

@StewieGriffin सटीक होने के लिए, रेंज [28051, 28888] में सभी संख्याएँ आधार 9 हैं और फॉर्म 19xxx की संख्या में अनुवाद करें, इस प्रकार यह अंतर दोगुना हो जाता है।

— सेमीस्टर

आह, मिल गया ... :) रिकॉर्ड के लिए: मुझे पता था कि 10 की शक्तियों के बाईं ओर अंतराल क्यों थे ... यह केवल डबल आकार के अंतराल थे जो अजीब थे (30/60 क्यों, और 20 / नहीं) 40/50)। मैं अब देख रहा हूँ कि संख्या 28xxx -> 19xxx में है, लेकिन 38xxx -> 26xxx, 29xxx नहीं है।

— स्टीवी ग्रिफिन

Answer 2

जावा 8, 172 166 163 152 151 140 138 116 114 99 बाइट्स

s->{for(Integer b=0;b<10&s.length()>1;s=""+b.valueOf(s,b=s.chars().max().getAsInt()-47));return s;}

इनपुट के रूप में लेता है String।

-64 बाइट्स का धन्यवाद @ ओलिवियरग्रेगायर । और यहाँ मुझे लगा कि मेरा शुरुआती 172 बहुत बुरा नहीं था ..;)

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

स्पष्टीकरण:

s->{                    // Method with String as parameter and return-type
  for(Integer b=0;b<10  //  Loop as long as the largest digit + 1 is not 10
      &s.length()>1;    //  and as long as `s` contains more than 1 digit
    s=""+               //   Replace `s` with the String representation of:
         b.valueOf(s,   //    `s` as a Base-`b` integer
          b=s.chars().max().ge‌tAsInt()-47)
                        //     where `b` is the largest digit in the String + 1
  );                    //  End of loop
  return s;             //  Return result-String
}                       // End of method

Comments

शांत रहने का वादा? : पी ठीक है ... चलो चलते हैं s->{for(Integer b=0;b<10&s.length()>1;)s=""+b.valueOf(s,b=s.chars().max().getAsInt()-47);return s;}:। साथ ही मैंने अपनी अधिकांश टिप्पणियों को हटा दिया क्योंकि वे अब पूरी तरह अप्रासंगिक हैं ( bआधार है, आपका a; और sवह संख्या है जिस पर हम काम कर रहे हैं)।

— ओलिवियर ग्रेगोइरे

मैंने इसे कुछ बाइट्स से दाढ़ी बनाने के लिए इसे पुन: बनाने की कोशिश की है: Integer b;return(b=s.chars().max().getAsInt()-47)>9|s.length()<2?s:c(""+b.valueOf(s,b));(88), लेकिन मैं गोल्फ को कोड करने के लिए बिल्कुल नया हूं। यह एक स्निपेट है, है ना? क्या इसे जोड़ने की आवश्यकता के बिना एक विधि के रूप में घोषित करने का एक तरीका है public String c(String s)?

— भगवान फ़रक्वाड

@LordFarquaad आपको इसकी आवश्यकता नहीं है public, लेकिन मुझे डर है कि आपको वास्तव में String c(String s){}पुनरावर्ती-कॉल्स के लिए उपयोग करना पड़ेगा , यहां तक ​​कि जावा 8. में भी। जब आप लैम्बडा का उपयोग करते हुए java.util.function.Function<String, String> c=s->{Integer b;return(b=s.chars().max().getAsInt()-47)>9|s.length()<2?s:c‌.apply​(""+b.valueOf(s,b));}या इंटरफ़ेस का उपयोग करते हुए बनाते हैं, तो interface N{String c(String s);}N n = s->{Integer b;return(b=s.chars().max().getAsInt()-47)>9|s.length()<2?s:n.c‌​(""+b.valueOf(s,b));};यह "एक शुरुआती में स्व-संदर्भ " देगा। त्रुटि "दोनों मामलों में। लेकिन फिर भी बहुत अच्छा तरीका!

— केविन क्रूज़सेन

आह, मुझे लगता है कि मैं इसे कुछ बाइट्स ungolfed तब। लेकिन मदद के लिए धन्यवाद! मैं आगे बढ़ने के लिए इसे ध्यान में रखूंगा।

— लॉर्ड फरक्वाड

Answer 3

अजगर, 9 बाइट्स

ui`GhseS`

परीक्षण सूट

स्पष्टीकरण:

ui`GhseS`
ui`GhseS`GQ    Implicit variable introduction
u         Q    Repeatedly apply the following function until the value repeats,
               starting with Q, the input.
        `G     Convert the working value to a string.
      eS       Take its maximum.
     s         Convert to an integer.
    h          Add one.
 i`G           Convert the working value to that base

Comments

यह थोड़ा अजीब है कि आपने एक चर का उपयोग करते हुए दो-चर वाले लैम्ब्डा का उपयोग कैसे किया ... और यह त्रुटि (ओं) को फेंक नहीं दिया। ओह, दो चर हैं Qऔर Q, मुझे मिल गया।

— आउटगॉल्फ

@EriktheOutgolfer बिल्कुल नहीं। uइसके तीसरे इनपुट के बिना पुनरावृत्ति तक लागू किया जाता है, जबकि तीसरे इनपुट के साथ यह निश्चित संख्या में लागू होता है। uलैम्ब्डा Gऔर है H, लेकिन आपको उपयोग करने की आवश्यकता नहीं है H।

— ईसैक

वास्तव में के Gसाथ बदल रहा है Hएक ही परिणाम होगा ... btw अंतर्निहित चर है G?

— आउटगोल्फर

@EriktheOutgolfer निहित चर है G, हाँ। Hप्रत्येक पुनरावृत्ति के साथ 0 से गिना जाता है, इसलिए यह पूरी तरह से अलग है। मैं वास्तव में निश्चित नहीं हूं कि आप किस बारे में बात कर रहे हैं। यहाँ एक उदाहरण कार्यक्रम आपको दिखाने के लिए है कि क्या चल रहा है: pyth.herokuapp.com/…

— isaacg

Answer 4

जावास्क्रिप्ट (ईएस 6), 63 57 54 53 बाइट्स

f=a=>a>9&(b=Math.max(...a+""))<9?f(parseInt(a,b+1)):a

झबरा और डोम हेस्टिंग्स की बदौलत 8 बाइट्स बचाए

f=a=>a>9&(b=Math.max(...a+""))<9?f(parseInt(a,b+1)):a;

console.log(f("413574"))

Comments

मुझे इससे हराएं। मुझे लगता है कि आप +a>9||b<9टर्नरी को उलट कर कुछ बाइट्स बचा सकते हैं ।

— झबरा

@ शैगी संपादित करें: मैं गूंगा हूं

— टॉम

अपने आप पर इतना मुश्किल मत बनो टॉम! आप गूंगे नहीं हैं ,,,, लेकिन आप निश्चित रूप से @Shaggy जितना स्मार्ट नहीं हैं!

— स्टिव ग्रिफिन

55 बाइट्स के लिए वैकल्पिकf=n=>n>9&&(k=Math.max(...n+"")+1)<10?f(parseInt(n,k)):n

— डोम हेस्टिंग्स

@DomHastings सुधार के लिए धन्यवाद! :)

— टॉम

Answer 5

पायथन 3 , 91 78 76 75 73 बाइट्स

@ ईमनिगा ने 5 बाइट से मुंडन किया। @FelipeNardiBatista ने 1 बाइट बचाई। @ RomanGräf ने 2 बाइट्स बचाए

i=input()
while'9'>max(i)and~-len(i):i=str(int(i,int(max(i))+1))
print(i)

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

---

व्याख्या

i=input()                                  - takes input and assigns it to a variable i
while '9'>max(i)and~-len(i):               - repeatedly checks if the number is still base-9 or lower and has a length greater than 1
    i=str(...)                             - assigns i to the string representation of ...
          int(i,int(max(i))+1)             - converts the current number to the real base 10 and loops back again
print(i)                                   - prints the mutated i

Answer 6

05AB1E , 10 5 बाइट्स

5 बाइट्स जादू ऑक्टोपस Urn के लिए धन्यवाद बचाया

F§Z>ö

चूंकि यह बड़े इनपुट के लिए बहुत तेज़ी से बढ़ता है, इसलिए मैं परीक्षण के लिए पुराने बहुत तेज़ संस्करण को यहां छोड़ रहा हूं। एल्गोरिथ्म एक ही है, केवल पुनरावृत्तियों की संख्या भिन्न होती है।

[©Z>öD®Q#§

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

व्याख्या

[             # start a loop
 ©            # store a copy of the current value in the register
  Z>          # get the maximum (digit) and increment
    ö         # convert the current value to base-10 from this base
     D        # duplicate
      ®Q#     # break loop if the new value is the same as the stored value
         §    # convert to string (to prevent Z from taking the maximum int on the stack)

Comments

इसके अलावा, आप सिर्फ इस्तेमाल नहीं कर सकते тFZ>ö§? पुनरावृत्तियों की संख्या को देखते हुए ( जैसा कि यहां देखा गया है ) पठार प्रतीत होता है? यदि आप तकनीकी प्राप्त करना चाहते हैं, तो जिस दर से पुनरावृत्तियों में वृद्धि होती है, वह है लघुगणक ... तो आप बस कुछ का उपयोग कर सकते हैं जैसे: DFZ>ö§और राज्य यह बड़े पैमाने पर नहीं चलेगा n। या शायद यहां तक ​​कि: T.n>FZ>ö§सीधे पुनरावृत्तियों की संख्या की गणना करना log_10(n)।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: हाँ, अब जब आप इसका उल्लेख करते हैं, जैसा कि निश्चित रूप से अनुक्रम रैखिक की तुलना में धीमा लगता है, F§Z>öतो चाल चलनी चाहिए।

— 21

मुझे लगता है कि आप इसे हटा सकते हैं §।

— 1916

@EriktheOutgolfer: दुर्भाग्य से नहीं। यदि हम हटाते हैं §, Zतो स्टैक के शीर्ष पर संख्या में उच्चतम अंक के बजाय स्टैक पर उच्चतम संख्या ले जाएगा।

— एमिगा

@ ईमनिगा हुह?

— आउटगोल्फ जूल

Answer 7

एपीएल (डायलॉग) , 20 16 बाइट्स

लेता है और एक स्ट्रिंग लौटाता है

((⍕⊢⊥⍨1+⌈/)⍎¨)⍣≡

(… )⍣≡ निम्नलिखित फ़ंक्शन तब तक लागू करें जब तक कि दो लगातार शब्द समान न हों:

 ⍎¨ प्रत्येक वर्ण को निष्पादित करें (स्ट्रिंग को संख्याओं की सूची में बदल देता है)

 (... ) उस के लिए निम्नलिखित tacit फ़ंक्शन लागू करें:

  ⌈/ तर्क का अधिकतम पता लगाएं

  1+ एक जोड़ें

  ⊢⊥⍨ उस आधार में तर्क का मूल्यांकन करें

  ⍕ प्रारूप (कठोर, बाहरी फ़ंक्शन के अन्य अनुप्रयोग के लिए तैयारी में)

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

Answer 8

रूबी , 60 56 बाइट्स

->n{n=(s=n.to_s).to_i(s.bytes.max-47)while/9/!~s&&n>9;n}

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

Answer 9

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

FromDigits[s=IntegerDigits@#,Max@s+1]&~FixedPoint~#&

शुद्ध फ़ंक्शन इनपुट के रूप में एक nonnegative पूर्णांक ले रहा है और एक nonnegative पूर्णांक लौटा रहा है। जेनी_मैथी के जवाब केFromDigits[s=IntegerDigits@#,Max@s+1] रूप में एक ही कोर मैकेनिक का उपयोग करता है , लेकिन पुनरावृत्ति करने के लिए शोषण करता है।FixedPoint

Answer 10

पर्ल 6 , 49 बाइट्स

{($_,{.Str.parse-base(1+.comb.max)}...*==*).tail}

झसे आज़माओ

विस्तारित:

{
  (

    $_,                 # seed the sequence with the input

    {
      .Str
      .parse-base(      # parse in base:
        1 + .comb.max   # largest digit + 1
      )
    }

    ...                 # keep generating values until

    * == *              # two of them match (should only be in base 10)

  ).tail                # get the last value from the sequence
}

Answer 11

PHP , 71 बाइट्स

for(;$b<10&9<$n=&$argn;)$n=intval("$n",$b=max(str_split($n))+1);echo$n;

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

Answer 12

पिप , 17 बाइट्स

Wa>9>YMXaaFB:1+ya

कमांड-लाइन तर्क के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

यह मजेदार था - मुझे पीछा करने वाले तुलना ऑपरेटरों को बाहर निकालने के लिए मिला।

हम तब तक लूप करना चाहते हैं जब तक कि संख्या एकल अंक न हो या जिसमें 9. समान हो, हम लूप करना चाहते हैं, जबकि संख्या कई अंकों की है और इसमें 9. नहीं है। समान रूप से, लूप जबकि संख्या 9 से अधिक है और अधिकतम अंक है। 9 से कम a>9>MXa:।

Wa>9>YMXaaFB:1+ya
                   a is 1st cmdline arg (implicit)
     YMXa          Yank a's maximum digit into the y variable
Wa>9>              While a is greater than 9 and 9 is greater than a's max digit:
         aFB:1+y    Convert a from base 1+y to decimal and assign back to a
                a  At the end of the program, print a

Answer 13

पायथन 2 , 60 59 56 53 बाइट्स

सहेजे गए 4 बाइट धन्यवाद फेलिप नारदी बतिस्ता के लिए
3 बाइट्स ओव्स के लिए धन्यवाद

f=lambda x,y=0:x*(x==y)or f(`int(x,int(max(x))+1)`,x)

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

पिछले पुनरावृत्ति के आधार रूपांतरण के परिणाम की तुलना करते हुए, एक पुनरावर्ती लैम्ब्डा का उपयोग करना।

Comments

क्यों उपयोग नहीं x==y and x or ...के रूप में xकभी नहीं होगा 0(आधार 1)। या यहां तक ​​कि(x==y)*x or ...

— फेलिप नारदी बतिस्ता

@FelipeNardiBatista: धन्यवाद! मैंने कोशिश की x and x==y or ...जो काम नहीं कर रहा था, लेकिन मैं इन चालों के साथ बहुत कुशल नहीं हूं, इसलिए मुझे एहसास नहीं हुआ कि मैं इसे उल्टा कर सकता हूं :)

— Emigna

@ नोव्स: सही आप हैं। धन्यवाद!

— एमिगाना

@FelipeNardiBatista "इनपुट: एक सकारात्मक पूर्णांक n श्रेणी 0-9 में अंकों से बना है।" 0 अभी भी मान्य इनपुट है, और अब कोड इसे अस्वीकार करता है।

— मस्त

@ मैस्ट: सौभाग्य से हमारे लिए, 0 एक सकारात्मक पूर्णांक नहीं है , इसलिए इसे इनपुट के रूप में नहीं दिया जाएगा।

— इमीना

Answer 14

सी #, 257 244 243 244 233 222 बाइट्स

using System.Linq;z=m=>{int b=int.Parse(m.OrderBy(s=>int.Parse(s+"")).Last()+""),n=0,p=0;if(b<9&m.Length>1){for(int i=m.Length-1;i>=0;i--)n+=int.Parse(m[i]+"")*(int)System.Math.Pow(b+1,p++);return z(n+"");}else return m;};

खैर, C # हमेशा बहुत सारे बाइट्स लेता है लेकिन यह सिर्फ हास्यास्पद है। कोई भी अंतर्निहित इन्सान एक मनमाना आधार नहीं संभाल सकता है, इसलिए मुझे स्वयं रूपांतरण की गणना करनी थी। Ungolfed:

using System.Linq;
z = m => {
int b = int.Parse(m.OrderBy(s => int.Parse(s + "")).Last()+""), n = 0, p = 0; //Get the max digit in the string
if (b < 9 & m.Length > 1) //if conditions not satisfied, process and recurse
{
    for (int i = m.Length - 1; i >= 0; i--)
        n += int.Parse(m[i] + "") * (int)System.Math.Pow(b+1, p++); //convert each base-b+1 representation to base-10
    return z(n + ""); //recurse
}
else return m; };

Answer 15

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

f[x_]:=FromDigits[s=IntegerDigits@x,d=Max@s+1];(z=f@#;While[d!=10&&Length@s>1,h=f@z;z=h];z)&

Answer 16

जावास्क्रिप्ट (ईएस 6) 0 तीर फ़ंक्शन, 74 बाइट्स के साथ

function f(a){a>9&&b=Math.max(...a)<9&&f(parseInt(a,b+1));alert(a)}f('11')

Comments

PPCG में आपका स्वागत है! :) यह शायद एक बहुत अच्छा जवाब है, लेकिन मैं एक स्पष्टीकरण के बिना नहीं बता सकता। मैं (और शायद अन्य) कभी भी ऐसे उत्तर नहीं देते हैं जिनमें स्पष्टीकरण न हों।

— स्टिव ग्रिफ़िन

आप f('11')समारोह के बाद क्यों बुला रहे हैं ? जब तक मुझे कुछ याद नहीं है जो केवल उपयोग करना प्रतीत होता है वास्तव में सबमिशन का हिस्सा नहीं है। यदि हां, तो आपको इसे कोड सेक्शन से बाहर ले जाना चाहिए और इसे अपने स्पष्टीकरण में डाल देना चाहिए (जब आप एक जोड़ते हैं) और अपनी बाइट गिनती को 67 तक अपडेट करें।

— PunPun1000

Answer 17

K4 , 19 बाइट्स

समाधान:

{(1+|/x)/:x:10\:x}/

उदाहरण:

q)\
  {(1+|/x)/:x:10\:x}/413574
83911
  {(1+|/x)/:x:10\:x}/13552
159
  {(1+|/x)/:x:10\:x}/17
3
  {(1+|/x)/:x:10\:x}/41253
29    

स्पष्टीकरण:

/:बेस कन्वर्ट करने के लिए बिल्ट-इन का इस्तेमाल करें ।

{(1+|/x)/:x:10\:x}/ / the solution
{                }/ / converge lambda, repeat until same result returned
            10\:x   / convert input x to base 10 (.:'$x would do the same)
          x:        / store in variable x
 (     )/:          / convert to base given by the result of the brackets
    |/x             / max (|) over (/) input, ie return largest
  1+                / add 1 to this

Answer 18

कोटलिन , 97 बाइट्स

fun String.f():String=if(length==1||contains("9"))this else "${toInt(map{it-'0'}.max()!!+1)}".f()

सजा हुआ

fun String.f(): String = if (length == 1 || contains("9")) this else "${toInt(map { it - '0' }.max()!! + 1)}".f()

परीक्षा

fun String.f():String=if(length==1||contains("9"))this else "${toInt(map{it-'0'}.max()!!+1)}".f()
val tests = listOf(
        5 to 5,
        17 to 3,
        999 to 999,
        87654321 to 9041998,
        41253 to 29
)

fun main(args: Array<String>) {
    tests.forEach { (input, output) ->
        val answer = input.toString().f()
        if (answer != output.toString()) {
            throw AssertionError()
        }
    }
}

TIO

TryItOnline

Answer 19

जाप , 25 बाइट्स

>9©(A=Uì rw)<9?ßUs nAÄ):U

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

Answer 20

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

DḅṀ‘$$µÐL

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

Answer 21

सी, 159 157 बाइट्स

#include <stdlib.h>
char b[99];i=0;m=-1;c(n){do{m=-1;sprintf(b,"%d",n);i=0;while(b[i]){m=max(b[i]-48,m);i++;}n=strtol(b,0,++m);}while(b[1]&&m<10);return n;}

Answer 22

स्काला , 119 बाइट्स

if(x.max==57|x.length==1)x else{val l=x.length-1
f((0 to l).map(k=>(((x(k)-48)*math.pow(x.max-47,l-k))) toInt).sum+"")}

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

स्काला , 119 बाइट्स

if(x.max==57|x.length==1)x else f((0 to x.length-1).map(k=>(((x(k)-48)*math.pow(x.max-47,x.length-1-k))) toInt).sum+"")

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

दोनों विधियां उसी तरह से काम करती हैं, लेकिन पहले एक में मैं x.length-1एक चर में रखता हूं , और दूसरे में मैं नहीं।