सबसे छोटा Zeroless Base

Question

एक सकारात्मक पूर्णांक को देखते हुए n, सबसे छोटा आधार आउटपुट होता है b >= 2जहां बिना किसी अग्रणी शून्य के nआधार के प्रतिनिधित्व bमें ए नहीं होता है 0। आप b <= 256सभी इनपुट के लिए मान सकते हैं ।

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

1 -> 2 (1)
2 -> 3 (2)
3 -> 2 (11)
4 -> 3 (11)
5 -> 3 (12)
6 -> 4 (12)
7 -> 2 (111)
10 -> 4 (22)
17 -> 3 (122)
20 -> 6 (32)
50 -> 3 (1212)
100 -> 6 (244)
777 -> 6 (3333)
999 -> 4 (33213)
1000 -> 6 (4344)
1179360 -> 23 ([12, 9, 21, 4, 4])
232792560 -> 23 ([15, 12, 2, 20, 3, 13, 1])
2329089562800 -> 31 ([20, 3, 18, 2, 24, 9, 20, 22, 2])
69720375229712477164533808935312303556800 -> 101 ([37, 17, 10, 60, 39, 32, 21, 87, 80, 71, 82, 14, 68, 99, 95, 4, 53, 44, 10, 72, 5])
8337245403447921335829504375888192675135162254454825924977726845769444687965016467695833282339504042669808000 -> 256 ([128, 153, 236, 224, 97, 21, 177, 119, 159, 45, 133, 161, 113, 172, 138, 130, 229, 183, 58, 35, 99, 184, 186, 197, 207, 20, 183, 191, 181, 250, 130, 153, 230, 61, 136, 142, 35, 54, 199, 213, 170, 214, 139, 202, 140, 3])

Comments

आपके द्वारा उपयोग किए जा रहे उच्च आधारों में दस, ग्यारह आदि के लिए क्या मूल्य हैं? क्या उनमें शून्य हैं?

— स्टीफन

@ स्टेपेन उपरोक्त अंकों के लिए चुने गए मान 9मायने नहीं रखते, क्योंकि वे नहीं हैं 0।

— Mego

यह OEIS A106370 है ।

— इंजीनियर टोस्ट

@ टिट्स यह एक अच्छी बात है। मैं आधार को कुछ उचित तक सीमित करूँगा।

— मैगो

@Mego: 232792560 आज़माएं। यह 2,3, ..., 20 का Lcm है, इसलिए प्रत्येक आधार में <= 20 इसमें 0 सबसे कम महत्वपूर्ण अंक है।

— नैट एल्ड्रेडगे

Answer 1

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

f*FjQT

सभी परीक्षण मामलों की जाँच करें।

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

च * FjQT ~ पूर्ण कार्यक्रम।

f ~ पहला सकारात्मक पूर्णांक जहां स्थिति सत्य है।
   jQT ~ वर्तमान तत्व के आधार में परिवर्तित इनपुट।
 * एफ ~ उत्पाद। यदि सूची में 0 है, तो यह 0 है, अन्यथा यह सख्ती से सकारात्मक है।
          0 -> झूठी; > ० -> सत्य।
        ~ परिणाम का परिणाम अनुमानित रूप से।

हालाँकि पाइथ (1 पर शुरू) fपर चल रहा है 1, 2, 3, 4, ..., पाइथ ज़ीरोस के एक समूह के रूप में बेस 1 (एकरी) में संख्याओं का इलाज करता है, इसलिए आधार 1 को अनदेखा किया जाता है।

Comments

इस तथ्य का अच्छा दुरुपयोग है कि पायथ का आधार -1 प्रतिनिधित्व सभी शून्य है।

— आउटगोल्फर

@EriktheOutgolfer धन्यवाद! मैं इस बारे में स्पष्टीकरण जोड़ूंगा।

— श्री एक्सकोडर

Pyth केवल भाषा जिसका एकल प्रतिनिधित्व अंकों के रूप में शून्य का उपयोग करता है नहीं है संकेत पी:

— Mego

आपने लिखा 0 -> Falsy; > 0 -> Truthy। क्या वह जानबूझकर और उस स्थिति में 0दोनों है? TruthyFalsy

— ब्रायन जे

@ ब्रायनज सेकेंड के >सामने एक संकेत है 0, जिसका अर्थ है कि 0 से अधिक सब कुछ सत्य है।

— श्री Xcoder

Answer 2

सी,  52  50 बाइट्स

i,k;f(n){for(i=2,k=n;k;)k=k%i++?k/--i:n;return i;}

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

सी (जीसीसी),  47  45 बाइट्स

i,k;f(n){for(i=2,k=n;k;)k=k%i++?k/--i:n;n=i;}

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

---

@ केविन क्रूज़सेन के जवाब पर @ नेवे के सुझाव के लिए दो बाइट्स ने बचा लिया!

Comments

बाद वाला संस्करण केवल यादृच्छिक भाग्य से काम करता है, भले ही आप एक विशिष्ट संकलक पर जोर देते हों। और, ज़ाहिर है, न तो संस्करण वास्तव में सी है

— एएनटी

@AnT यह C है .. यह बहुत सारी चेतावनी देगा लेकिन यह संकलन करेगा। जब तक आपको एक कंपाइलर मिल जाता है जो आपके कोड के लिए काम करता है, आप ठीक हैं

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

@Blacksilver k%iयहाँ एक टर्नरी-चेक है। एक अधिक पठनीय संस्करण होगा k=(k%i?k:n*++i);या उससे भी अधिक स्पष्ट रूप से if(k%i){k=k;}else{k=n*++i;}:।

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

इसके अलावा, आप दोनों को 2 बाइट्स में गोल्फ कर सकते हैं: i,k;f(n){for(i=2,k=n;k;)k=k%i++?k/--i:n;return i;}और i,k;f(n){for(i=2,k=n;k;)k=k%i++?k/--i:n;n=i;}। सारा श्रेय @ नवीन को जाता है जिन्होंने इस सुझाव को मेरे पोर्टेड जावा 8 उत्तर पर पोस्ट किया था ।

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

@ फेलिप नार्डी बतिस्ता: मैं इस तथ्य से अवगत हूं कि कोडगुल्फ नियम कहते हैं "जब तक यह संकलन करता है" और इसी तरह। हालांकि, यह तथ्य कि यह "संकलन करता है" किसी भी तरह से यह साबित नहीं करता है कि यह सी है। यह सी नहीं है। सी (के एंड आर) के प्राचीन संस्करणों में मौजूद i, k;और f(n)अस्तित्व में है, लेकिन केवल उस युग में जब returnइसके चारों ओर आवश्यक गोल कोष्ठक होते हैं। तर्क। यदि आप K & R का उपयोग करना चाहते हैं i,k;, तो आपको भी उपयोग करना होगा return(i);। ऊपर gnuc हो सकता है, लेकिन नहीं सी

— चींटी

Answer 3

हास्केल , 56 52 48 बाइट्स

b#n=n<1||mod n b>0&&b#div n b
f n=until(#n)(+1)2

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

सुंदर बुनियादी लेकिन इसे छोटा करने के किसी भी अच्छे तरीके के बारे में नहीं सोच सकते

संपादित करें: मुझे 4 बाइट बचाने के लिए लकोनी के लिए धन्यवाद! पता नहीं क्यों मैंने कभी नहीं सोचा था !!0। मुझे शायद उन कोष्ठकों को हटाने की कोशिश करनी चाहिए थी, लेकिन मेरे पास कुछ अजीब त्रुटि की अस्पष्ट यादें हैं जब आप उपयोग करने की कोशिश करते हैं ||और &&एक साथ। शायद मैं इसे समानता ऑपरेटरों के साथ भ्रमित कर रहा हूं।

संपादित 2: एक और 4 बाइट्स शेविंग के लिए धन्यवाद @Lynn! पता नहीं कैसे मैं untilअब से पहले के बारे में कभी नहीं पता था ।

Comments

आपने मुझे लगभग एक ही समाधान के साथ एक मिनट तक हराया। :) !!0की तुलना में कम है headऔर मुझे लगता है कि आप कोष्ठक को अंदर छोड़ सकते हैं #।

— लकोनी

आपराधिक रूप से कम किया गया until :: (a → Bool) → (a → a) → a → aचार बाइट्स बचाता है:f n=until(#n)(+1)2

— लिन

Answer 4

वोल्फ्राम भाषा (गणितज्ञ) , 33 बाइट्स

2//.i_/;DigitCount[#,i,0]>0:>i+1&

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

Answer 5

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

→V▼MBtN

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

व्याख्या

→V▼MBtN
     tN    list of natural numbers starting from 2
   MB      convert the (implicit) input to each of those bases
 V▼        find the (1-based) index of the first result where the minimum digit is truthy
→          add 1 to this index

Answer 6

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

n=x=input()
b=2
while x:z=x%b<1;b+=z;x=[x/b,n][z]
print b

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

यह पुनरावर्ती फ़ंक्शन की तुलना में छोटा है:

f=lambda n,b=1,x=1:b*(x<1)or f(n,b+(x%b<1),[x/b,n][x%b<1])

Comments

BTW यह मेरे समाधान के समान है।

— आउटगॉल्फ

Answer 7

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

2b@Ạ¥1#

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

Answer 8

05AB1E , 6 बाइट्स

-4 बाइट्स अदनान को धन्यवाद

1µNвPĀ

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

Comments

10 बाइट्स:[¹NÌDŠвPĀ#

— नील

1µNвPĀ6 बाइट्स के लिए काम करता है

— अदनान

@ अदनान मैं जानता था कि यह बहुत लंबा था

— ओकेएक्स २५'१ it

LB0.å0kपूरी तरह से एक और तरीका है> _>।

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

Answer 9

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

←foΠ`B⁰tN

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

व्याख्या

            -- input N
        tN  -- tail of [1..] == [2..]
←f(    )    -- filter with the following:
    `B⁰     --   convert N to that base
   Π        --   product (0 if it contains 0)
←           -- only keep first element

Answer 10

जावा 8, 61 56 54 बाइट्स

n->{int b=2,t=n;for(;t>0;)t=t%b++<1?n:t/--b;return b;}

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

स्पष्टीकरण:

n->{            // Method with integer as both parameter and return-type
  int b=2,      //  Base-integer, starting at 2
      t=n;      //  Temp-integer, copy of the input
  for(;t>0;)    //  Loop as long as `t` is not 0
    t=t%b++<1?  //   If `t` is divisible by the base `b`
                //   (and increase the base `b` by 1 afterwards with `b++`)
       n        //    Set `t` to the input `n`
      :         //   Else:
       t/--b;   //    Divide `t` by the `b-1`
                //    (by decreasing the base `b` by 1 first with `--b`)
                //  End of loop (implicit / single-line body)
  return b;     //  Return the resulting base
}               // End of method

मुझे लग रहा है कि यह एक अंकगणितीय दृष्टिकोण का उपयोग करके गोल्फ हो सकता है। यह वास्तव में, @Steadybox 'C उत्तर के एक पोर्ट के साथ कर सकता है , और फिर @Nevay के लिए 2 बाइट्स के द्वारा गोल्फिंग की जाती है ।

पुराना ( 61 बाइट्स ) उत्तर:

n->{int b=1;for(;n.toString(n,++b).contains("0"););return b;}

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

स्पष्टीकरण:

n->{         // Method with Integer as both parameter and return-type
  int b=1;   //  Base-integer, starting at 1
  for(;n.toString(n,++b).contains("0"););
             //  Loop as long as the input in base-`b` does contain a 0,
             //  after we've first increased `b` by 1 before every iteration with `++b`
  return b;  //  Return the resulting base
}            // End of method

Comments

54 बाइट्स:n->{int b=2,t=n;for(;t>0;)t=t%b++<1?n:t/--b;return b;}

— नेवई

Answer 11

जाप , 8 बाइट्स

@ìX e}a2

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

व्याख्या

@    }a2

Xसमारोह शुरू करने के लिए पहला नंबर ( ) लौटें2

ìX

आधार- Xअंकों की एक सरणी में इनपुट संख्या में परिवर्तित करें ।

e

जांचें कि क्या सभी अंक सत्य हैं।

Comments

यदि यह सरणी किसी भी प्रकार की नहीं है तो क्या यह विफल नहीं होगा 10?

— झबरा

@ मेरी समझ यह थी कि, ओपी टिप्पणी के अनुसार, कि 9 से ऊपर के आधारों के अंक शून्य के रूप में नहीं गिने जाते हैं।

— जस्टिन मेरिनर

आह, अब मैं देख रहा हूँ। चुनौती का सामना करने के साथ समस्या है, इसलिए (या मैं अभी बहुत थक गया हूँ!)।

— झबरा

Answer 12

जावास्क्रिप्ट (ईएस 6), 43 41 37 बाइट्स

n=>(g=x=>x?g(x%b++?x/--b|0:n):b)(b=1)

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

let f =

n=>(g=x=>x?g(x%b++?x/--b|0:n):b)(b=1)

console.log(f(1   )) // 2 (1)
console.log(f(2   )) // 3 (2)
console.log(f(3   )) // 2 (11)
console.log(f(4   )) // 3 (11)
console.log(f(5   )) // 3 (12)
console.log(f(6   )) // 4 (12)
console.log(f(7   )) // 2 (111)
console.log(f(10  )) // 4 (22)
console.log(f(17  )) // 3 (122)
console.log(f(20  )) // 6 (32)
console.log(f(50  )) // 3 (1212)
console.log(f(100 )) // 6 (244)
console.log(f(777 )) // 6 (3333)
console.log(f(999 )) // 4 (33213)
console.log(f(1000)) // 6 (4344)

Answer 13

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

;.≜ḃ₎¬∋0∧1¬

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

व्याख्या

;.≜ḃ₎           The Input represented in base Output…
     ¬∋0        …contains no 0
        ∧1¬     And Output ≠ 1

Answer 14

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

n=m=input()
b=2
while m:c=m%b<1;b+=c;m=(m/b,n)[c]
print b

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

-1 फेलिप नारदी बतिस्ता को धन्यवाद ।
-2 लिन का धन्यवाद (और अब यह उसके समाधान का एक हिस्सा है: D)

Comments

59 बाइट्स बदलकर a,b=a+c,dकरने के लिएa+=c;b=d

— फेलिप Nardi बतिस्ता

मुझे लगता है कि आप की जगह ले सकता while m>1से while m(और फिर हम बंधे रहे हैं!)

— लिन

@ लियोन यही कारण है कि मैंने आपके समाधान पर टिप्पणी की, यह ठीक उसी समय होगा।

— आउटगॉल्फ

वह ठीक है!

— लिन

@ मुझे पहले से ही पता था: p अन्यथा मैंने आपसे आपका डिलीट करने के लिए कहा होगा।

— आउटगोल्फर

Answer 15

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

1+⍣{~0∊⍺⊥⍣¯1⊢n}≢n←⎕

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

हमेशा की तरह, चैट में मदद करने और TIO में काम करने के लिए कोड प्राप्त करने के लिए @ Adám को धन्यवाद। इसके अलावा, 1 बाइट की बचत।

यह tradfn ( पारंपरिक itional f unctio n ) बॉडी है। इसका उपयोग करने के लिए, आपको इसे एक नाम (जो TIO के हेडर फ़ील्ड में है) निर्दिष्ट करना होगा, इसे ∇s में संलग्न करें (नाम से पहले एक और TIO के पाद लेख फ़ील्ड में), और फिर इसे अपने नाम का उपयोग करके कॉल करें। चूंकि यह ⎕उपयोगकर्ता के इनपुट को लेने के लिए एक क्वाड ( ) का उपयोग करता है , इसलिए इसे f \n inputसामान्य के बजाय कहा जाता हैf input

कैसे?

1+⍣{~0∊⍺⊥⍣¯1⊢n}≢n←⎕  ⍝ Main function.
                  n←⎕ ⍝ Assigns the input to the variable n
1+⍣{           }≢     ⍝ Starting with 1, add 1 until the expression in braces is truthy
    ~0∊               ⍝ returns falsy if 0 "is in"
        ⊥             ⍝ convert
            ⊢n        ⍝ the input
         ⍣¯1          ⍝ to base
       ⍺              ⍝ left argument (which starts at 1 and increments by 1)

फ़ंक्शन तब परिणामी आधार देता है।

Comments

गोल्फ टिप: चूंकि n←⎕एक साधारण संख्या होगी और आपको 1बाकी कोड के लिए प्रारंभिक तर्क के रूप में आवश्यकता होती है , आप बस n(जिसमें 1 है) में तत्वों की संख्या की गणना कर सकते हैं , के 1⊣साथ बदलकर ≢। इसे ऑनलाइन आज़माएं!

— एडम

Answer 16

प्रोटॉन , 40 बाइट्स

x=>filter(y=>all(digits(y,x)),2..x+3)[0]

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

Comments

यह अमान्य है। 2..xअंतराल में ठिकानों की जांच [2, x), इसलिए यह परीक्षण मामलों के लिए विफल रहता है 1और 2।

— श्री एक्सकोडर

Answer 17

आर , 79 71 66 63 65 बाइट्स

function(n){while(!{T=T+1;all(n%/%T^(0:floor(log(n,T)))%%T)})T
T}

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

यह उत्तर एक एकल लूप में Giuseppe की पुन: व्यवस्था पर आधारित है।

8 बाइट्स JDL के लिए धन्यवाद, और 6 बाइट्स Giuseppe के लिए धन्यवाद।

Comments

आप के bलिए उप को हटा सकते हैं T, जो TRUE == 1की आवश्यकता को हटाते हुए परिभाषित किया गया है b=1। इसी तरह आप उप कर सकते हैं Fके लिए k( Fहै FALSE)

— JDL

आपने वहां क्या किया वह मैने देखा। यह जानना उपयोगी है!

— NofP

66 बाइट्स m%/%T(पूर्णांक विभाजन) के बजाय(m-m%%T)/T

— Giuseppe

65 बाइट्स । यह थोड़ा गड़बड़ था लेकिन मुझे संदेह था कि नेस्टेड छोरों से छुटकारा पाने से कुछ बचा होगा ; मुझे लगा कि यह 1 बाइट से अधिक होगा :(

— Giuseppe

Answer 18

MATL , 13 12 बाइट्स

`G@Q_YAA~}@Q

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

लुइस मेंडो के लिए -1 बाइट धन्यवाद। यह प्रोग्राम 2 ^ 53 ( flintmax, एक फ़्लोटिंग पॉइंट प्रकार द्वारा अधिकतम लगातार पूर्णांक का प्रतिनिधित्व करने योग्य) doubleसे बड़ा टेस्टस्कैस को संभालता नहीं है, क्योंकि डिफ़ॉल्ट डेटाटाइप MATL में है। हालांकि, यह उस संख्या के नीचे किसी भी मनमाने ढंग से शून्य का आधार खोजने में सक्षम होना चाहिए।

`            % Do while
 G           %  Push input
  @ _        %  Outputs the iteration number, negate.
     YA      %  Convert input to base given by the iteration number, the negative number is to instruct MATL we want an arbitrary high base with a integer vector rather than the default character vector we know from hexadecimal
       A~    %  If they're not all ones, repeat
         }   % But if they are equal, we finally
          @  %  Push the last base
   Q       Q %  As base 1 makes no sense, to prevent MATL from errors we always increase the iteration number by one.

Comments

@LuisMendo मुझे वास्तव में डॉक्स को बेहतर पढ़ना शुरू करना चाहिए। धन्यवाद।

— Sanchises

यह बड़े परीक्षण मामलों के लिए काम नहीं करता है, लेकिन मुझे यह जानने के लिए MATL / Matlab के बारे में पर्याप्त नहीं पता है कि यह पूर्णांक सीमाओं के कारण है या नहीं।

— मैगो

@ मेगो मैंने अपने 13 बाइट संस्करण का परीक्षण किया जो कि MATLAB R2018a पर 1e6 तक के वर्तमान संस्करण के बराबर होना चाहिए। क्या परीक्षण सेटअप आपके लिए समस्याओं का कारण बना?

— Sanchises

पिछले 2 परीक्षण मामलों में त्रुटियां होती हैं।

— मीगो

@Mego आह मैं पहले उन testcases नहीं देखा था। यह YAआंतरिक रूप से डबल्स का उपयोग करके MATLs के कार्यान्वयन के कारण है , इसलिए यह केवल एक डबल (देखें flintmax) द्वारा प्रतिनिधित्व करने वाले अधिकतम लगातार पूर्णांक तक इनपुट को संभाल सकता है । क्या यह उत्तर को अमान्य करता है? सिद्धांत रूप में एल्गोरिथ्म मनमाना आधार के लिए काम करता है, मैंने स्पष्ट रूप से एक और कमांड के आसपास काम किया है जो केवल बेस 36 तक करेगा।

— Sanchises

Answer 19

PHP, 59 + 1 बाइट्स

बिल्डरों का उपयोग करते हुए , अधिकतम आधार 36:

for($b=1;strpos(_.base_convert($argn,10,++$b),48););echo$b;

कोई बिलिन नहीं, 63 60 + 1 बाइट्स , कोई भी आधार:

for($n=$b=1;$n&&++$b;)for($n=$argn;$n%$b;$n=$n/$b|0);echo$b;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया उन्हें आज़माएं ।

Answer 20

दरअसल ,  12  11 बाइट्स

╗1⌠╜¡m'0<⌡╓

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

इस आम सहमति का उपयोग करता है । चैट में बाइट-सेविंग मदद के लिए मीगो को धन्यवाद ।

Answer 21

जे, 26 बाइट्स

]>:@]^:(0 e.]#.inv[)^:_ 2:

यह जानना बेहतर होगा कि क्या इसमें सुधार किया जा सकता है।

मुख्य क्रिया एक डायडिक वाक्यांश है:

>:@]^:(0 e.]#.inv[)^:_

जिसे बाईं ओर इनपुट और दाईं ओर स्थिर 2 दिया गया है। यह मुख्य क्रिया वाक्यांश तब J के Do.hile निर्माण का उपयोग करता है, जब तक y तर्क सही होता है, जब तक 0 e.मूल y में मूल तर्क का एक तत्व होता है।

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

Answer 22

लूआ , 77 76 बाइट्स

b=2n=...N=n
while~~N>0 do
if N%b<1then
b=b+1N=n
else
N=N//b
end
end
print(b)

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

Answer 23

मिल्की वे , 38 बाइट्स

^^'%{255£2+>:>R&{~^?{_>:<;m_+¡}}^^^}

उपयोग: ./mw base.mwg -i 3

---

व्याख्या

code                                 explanation                    stack layout

^^                                   clear the preinitialized stack []
  '                                  push the input                 [input]
   %{                              } for loop
     255£                             push next value from 0..254   [input, base-2]
         2+                           add 2 to the get the base     [input, base]
           >                          rotate stack right            [base, input]
            :                         duplicate ToS                 [base, input, input]
             >                        rotate stack right            [input, base, input]
              R                       push 1                        [input, base, input, 1]
               &{~             }      while ToS (=remainder) is true ...
                  ^                    pop ToS                      [input, base, number]
                   ?{         }        if ToS (=quotient) ...
                     _>:<;              modify stack                [input, base, number, base]
                           m            divmod                      [input, base, quotient, remainder]
                           _+¡         else: output ToS (0) + SoS and exit
                                ^^^   pop everything but the input.

मुझे यकीन है कि यह लूप के बजाय एक समय-लूप का उपयोग करके छोटा किया जा सकता है, लेकिन मुझे यह काम करने के लिए नहीं मिला।

Answer 24

स्टैक्ड , 23 बाइट्स

{!2[1+][n\tb all]until}

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

यह वेतन वृद्धि ( [1+]) J दो से शुरू होती है ( 2) जबकि इनपुट के आधार _J प्रतिनिधित्व में कोई शून्य ( allऔर until) नहीं है।

Answer 25

पर्ल 5 , 52 + 2 ( -pa) = 54 बाइट्स

$\=1;while($_&&=$F[0]){$\++;$_=int$_/$\while$_%$\}}{

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