सबसे छोटा विविध घातांक

Question

एक पंडित संख्या एक पूर्णांक है जिसमें प्रत्येक अंक 0 से 9 तक कम से कम एक बार होता है। 1234567890, 1902837465000000, और 9023289761326634265 सभी पंडितजी हैं। इस चुनौती के उद्देश्यों के लिए, 123456789 जैसे नंबर पंडित नहीं हैं, क्योंकि उनके पास 0 नहीं है, भले ही 123456789 = 0123456789।

एक विविध पूर्णांकों की जोड़ी पूर्णांकों की एक जोड़ी है $(a, b)$ ऐसी है कि $a^b$ Pandigital है। को विविधीकरण घातांक कहा जाता है ।$b$

चुनौती: पूर्णांक को देखते हुए , सबसे छोटी संगत विविध घातांक ज्ञात । यह एक कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है।$a$$b$

(आप मान सकते हैं कि इस तरह के एक एक्सपोनेंट मौजूद है, अर्थात, आपके प्रोग्राम को अमान्य इनपुट नहीं दिया जाएगा, जैसे कि 10. की शक्ति।)

आपका समाधान न्यूनतम दिए गए परीक्षण मामलों को संभालने में सक्षम होना चाहिए, लेकिन यह सैद्धांतिक रूप से सभी मान्य इनपुट को संभालना चाहिए।

यह OEIS पर A090493 है।

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

2 -> 68
3 -> 39
4 -> 34
5 -> 19
6 -> 20
7 -> 18
8 -> 28
9 -> 24
11 -> 23
12 -> 22
13 -> 22
14 -> 21
15 -> 12
16 -> 17
17 -> 14
18 -> 21
19 -> 17
20 -> 51
21 -> 17
22 -> 18
23 -> 14
24 -> 19
25 -> 11
26 -> 18
27 -> 13
28 -> 11
29 -> 12
30 -> 39
31 -> 11
32 -> 14
33 -> 16
34 -> 14
35 -> 19
36 -> 10
1234567890 -> 1

Comments

मैं एक विशेष मामले को इंगित करना चाहता हूं 1234567890 -> 1।

— बब्लर

@ बबलर जोड़ा गया।

— कॉनर ओ'ब्रायन

क्या नकारात्मक प्रतिपादक सीमाएं हैं?

— सुडो rm -rf स्लैश

क्या 123456789पंडितजी की तरह कुछ गिना जाता है? यह बराबर है 0123456789, जो निश्चित रूप से पंडितजी है।

— wastl

@wastl नहीं, ऐसा नहीं है।

— कॉनर ओ'ब्रायन

Answer 1

ब्रेकीलॉग (v2), 9 बाइट्स

;.≜^dl10∧

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

यह एक फंक्शन सबमिशन है। टीआईओ लिंक में एक आवरण होता है जो एक पूर्ण कार्यक्रम में एक फ़ंक्शन बनाता है।

व्याख्या

;.≜^dl10∧
 .≜        Brute-force all integers, outputting the closest to 0
;  ^         for which {the input} to the power of the number
    d        has a list of unique digits
     l10     of length 10
        ∧  (turn off an unwanted implicit constraint)

Answer 2

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

f=lambda n,k=1:11>len(set(`k`))and-~f(n,n*k)

इनपुट एक लंबा होना है, क्योंकि लॉन्ग ​`k`​और इनट्स के लिए अलग-अलग व्यवहार होता है।

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

Answer 3

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

{first ($_** *).comb.Set>9,1..*}

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

बहुत आत्म-व्याख्यात्मक।

व्याख्या

{                              }  # Anonymous code block
first                     ,1..*   # First positive number that
      ($_** *)    # When the input is raised to that power
              .comb.Set    # The set of digits
                       >9  # Is longer than 9

Answer 4

जावास्क्रिप्ट (Node.js) ,  51 46  43 बाइट्स

BigInt शाब्दिक के रूप में इनपुट लेता है। 1 के बजाय सही देता है ।

f=(n,k=n)=>new Set(n+'').size>9||1+f(n*k,k)

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

Comments

मैं भूल रहा हूं कि जेएस के पास अब बिगिन है: डी

— कॉनर ओ'ब्रायन

मैं 1 के बजाय सच लौटने के बारे में थोड़ा संदिग्ध हूं। यह कोडगुल्फ.मेटा.स्टैकएक्सचेंज

— questions

@ सपर यहाँ वर्तमान सहमति है।

— अरनौलड

धन्यवाद। मैंने अपने लिंक पर एक नया उत्तर दिया है।

— 2

Answer 5

रूबी , 41 बाइट्स

->n{i=0;i+=1until(n**i).digits.uniq[9];i}

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

Answer 6

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

f a=until(\b->all(`elem`show(a^b))['0'..'9'])(+1)1

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

एक ही बाइट गिनती:

f a=[b|b<-[1..],all(`elem`show(a^b))['0'..'9']]!!0

Answer 7

जे , 25 बाइट्स

>:@]^:(10>#@~.@":@^)^:_&1

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

एकल मोनडिक क्रिया। इनपुट एक विस्तारित-सटीक पूर्णांक (जैसे 2x) होना चाहिए ।

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

>:@]^:(10>#@~.@":@^)^:_&1    Monadic verb. Input: base a
    ^:              ^:_      Good old do-while loop.
                       &1    Given 1 as the starting point for b,
>:@]                         increment it each step
      (            )         and continue while the condition is true:
               ":@^          Digits of a^b
            ~.@              Unique digits
          #@                 Count of unique digits
       10>                   is less than 10

Comments

(]+10>#@=@":@^)^:_*

— FrownyFrog

Answer 8

Tcl , 82 बाइट्स

proc X d {while {[llength [lsort -u [split [expr $d**[incr i]] ""]]]-10} {}
set i}

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

Comments

आप llength 82 बाइट्स के

— david

कुछ बाइट्स सहेजे, फिर @david

— sergiol को दिए

Answer 9

रैकेट , 110 96 बाइट्स

-14 बाइट्स अल्टीमेटहॉक का धन्यवाद!

(define(f n[b 1])(if(= 10(length(remove-duplicates(string->list(~v(expt n b))))))b(f n(+ b 1))))

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

Comments

इसके बजाय इस समारोह में उलटफेर करके 96 बाइट्स को छोटा किया जा सकता है(define(f n[b 1])(if(= 10(length(remove-duplicates(string->list(~v(expt n b))))))b(f n(+ b 1))))

— परम हॉक

@UltimateHawk धन्यवाद! मैं डिफ़ॉल्ट मापदंडों के बारे में भूल गया ... (हालांकि हेल्पर फ़ंक्शन ने डिफ़ॉल्ट पैरामीटर b का भी इस्तेमाल किया ...)

— गैलेन इवानोव

Answer 10

पायथन 3 , 52 47 बाइट्स

@BMO को धन्यवाद

f=lambda n,i=1:len({*str(n**i)})>9or 1+f(n,i+1)

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

Comments

बस एक सिर है, लेकिन आप सिर्फ पुराने कोड को हटा सकते हैं और हेडर लाइन में "<s> 52 </ s> 47" डाल सकते हैं। अगर कोई जिज्ञासु है तो एडिट लॉग पुराने संस्करणों को बनाए रखेगा

— Veskah

Answer 11

05AB1E (विरासत) , 10 9 बाइट्स

श्री एक्सकोडर को 1 बाइट का धन्यवाद दिया

XµINmÙgTQ

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

व्याख्या

Xµ           # find the first positive integer N that
  INm        # when the input is raised to N
     Ù       # and duplicate digits are removed
      g      # has a length
       TQ    # equal to 10

Comments

विरासत 1 बाइट बचाता है: 1µINmÙgTQ- यह ऑनलाइन कोशिश करो!

— मिस्टर एक्सकोडर

@ Mr.Xcoder: ओह, हाँ, हम तब के निहित उत्पादन किया था N। धन्यवाद!

— एमिग्ना

Answer 12

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

ＷΦχ¬№ＩＸＩθＬυＩκ⊞υωＩＬυ

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

ＷΦχ¬№ＩＸＩθＬυＩκ⊞υω

बार-बार रिक्त स्ट्रिंग को खाली सूची में तब तक धकेलें जब तक कि कोई अंक न हो कि सूची की लंबाई तक इनपुट की शक्ति शामिल नहीं है।

ＩＬυ

सूची की लंबाई प्रिंट करें।

Comments

क्यों होता है पतन?

— लुइस मेंडू

Answer 13

K (ngn / k) , 76 बाइट्स

{#{10>#?(+/|\0<|x)#x}{{+/2 99#,/|0 10\x,0}/+/99 99#,/a*\:x,0}\a::|(99#10)\x}

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

{ } तर्क के साथ कार्य करें x

|(99#10)\x हम 99 दशमलव अंकों की प्रत्यावर्तित सूचियों के रूप में संख्याओं का प्रतिनिधित्व करते हैं - इस तर्क पर

a::ग्लोबल वैरिएबल को असाइन करें a(k का कोई क्लोजर नहीं है। हमें aग्लोबल होने की जरूरत है इसलिए हम इसे सबफंक्शन में इस्तेमाल कर सकते हैं)

{ }{ }\ जब पहला फ़ंक्शन गलत हो जाता है, तो दूसरे फ़ंक्शन (उर्फ लूप करते समय) को लागू करते रहें, मध्यवर्ती परिणामों को संरक्षित करते हैं

a*\:xप्रत्येक के aअंकों में से प्रत्येक का गुणा x("बाहरी उत्पाद")

99 99#a*\:x,0 0s का अतिरिक्त कॉलम जोड़ें और 99x99 पर फिर से आकार दें, यह i-th पंक्ति को i आइटम द्वारा दाईं ओर स्थानांतरित करता है, बाईं ओर 0s सम्मिलित करता है (यह परीक्षण के लिए काम करता है, बड़े इनपुट के लिए 99x99 ओवरफ्लो हो सकता है)

+/ योग

{+/2 99#,/|0 10\x,0}/ प्रचार करें:

• { }/ अभिसरण तक आवेदन करते रहें

• 0 10\x 10 से divmod (सूचियों की एक जोड़ी)

• |0 10\x 10 से moddiv

• 2 99#,/|0 10\x,0 moddiv 10 से, "div" भाग के साथ 1 अंक दाईं ओर स्थानांतरित हो गया

• +/ योग

{10>#?(+/|\0<|x)#x} - (नहीं) पंडितजी के लिए जाँच करें:

• |x उलटा x

• 0< कौन से अंक गैर-शून्य हैं

• |\ आंशिक मैक्सिमा

• +/ sum - इसमें अग्रणी 0s की संख्या को गिना जाता है x

• 10> क्या वे 10 से कम हैं?

# शक्तियों के अनुक्रम की लंबाई - यह परिणाम है

Answer 14

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

param([bigint]$a)for([bigint]$b=1;-join("$([bigint]::pow($a,$b))"|% t*y|sort -u)-ne-join(0..9);$b=$b+1){}$b

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

बहुत सीधा, बस एक शर्म की बात है जिसे हमें [bigint]हर जगह उपयोग करने की आवश्यकता है। हम इनपुट लेते हैं $a, फिर forइनिशलाइज़र के साथ एक लूप सेटअप करते हैं$b=1 ।

प्रत्येक पुनरावृत्ति जो हम जाँचते हैं $bकि क्या $a ^ $b(के माध्यम से pow) toCharArra y, nique फ्लैग के sortसाथ एड भेजा गया है -u, फिर -joinएक स्ट्रिंग में एक साथ एड की सीमा के लिए -nओ.टी. eयोग्यता है0..9 भी -joinएक स्ट्रिंग में एड।

यह एक कौर है। उदाहरण के लिए, यह तुलना करेगा7 ^ 5 = 16807 --> "01678" करेगा "0123456789", निर्धारित कि वे समान नहीं हैं, और लूप जारी रखें।

एक बार जब हम लूप से बाहर हो जाते हैं, तो हमने निर्धारित किया है कि कौन सा $bहमारे इनपुट के अनुरूप है, और इसलिए इसे पाइपलाइन पर छोड़ दें। आउटपुट निहित है।

Answer 15

जावा, 108 बाइट्स

a->{int b=0;while(new java.math.BigDecimal(a).pow(++b).toString().chars().distinct().count()<10);return b;};

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

व्याख्या

जब तक यह 10 (या अधिक) के साथ एक स्ट्रिंग नहीं पाता है, तब तक ^ b को बल देते हुए क्रूर बल, लेकिन यह असंभव है क्योंकि केवल 9 के माध्यम से 0) अद्वितीय वर्ण होंगे।

BigDecimalदोनों की आवश्यकता है क्योंकि Math.powपर्याप्त सटीक नहीं है (मामले पर विफल रहता है 11), और इसलिए भी कि Doubleडिफ़ॉल्ट रूप से एक स्ट्रिंग को परिवर्तित करना वैज्ञानिक संकेतन दिखाता है, जो एक पंडित संख्या खोजने की इस पद्धति को तोड़ता है।

Comments

क्या जावा संस्करण डिफ़ॉल्ट रूप से 0 से शुरू नहीं होता है? प्रारंभ को समाप्त करके 2 बाइट्स बचा सकता है।

— डारेल हॉफमैन

@DarrelHoffman इंस्टेंस चर करते हैं, हाँ। स्थानीय रूप से स्कैन किए गए चर नहीं हैं।

— हाइपिनो

आह, ठीक है। जावा में काम करने के कुछ समय बाद, मैं उस तकनीकी को भूल गया।

— डारेल हॉफमैन

आप को बदलने के द्वारा 6 बाइट्स बचा सकते हैं new java.math.BigDecimal(a).pow(++b).toString()करने के लिए (new java.math.BigDecimal(a).pow(++b)+"")(और अनुगामी सेमी-कोलन लैम्ब्डा कार्यों के लिए किए जाने के लिए नहीं है)। इसे ऑनलाइन आज़माएं

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

Answer 16

अजगर, 10 8 बाइट्स

fq;l{`^Q

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

fq;l{`^QT   Implicit: Q=eval(input())
            Trailing T inferred
f           Return (and print) the first positive integer where the following is true:
      ^QT     Raise input to the current number-th power
     `        Convert to string
    {         Deduplicate
   l          Take the length
 q            Is the above equal to...
  ;           10

सहेजे गए 2 बाइट्स FryAmTheEggman, पिछले कोड के लिए धन्यवाद fq;l{j^QT;

Comments

आप आधार रूपांतरण करने के बजाय संख्या को स्ट्रिंग में बदलने के लिए बैकटिक का उपयोग कर सकते हैं जो आपको Tपावर ऑपरेशन में बाहर जाने देगा ।

— FryAmTheEggman 15

Answer 17

जेली , 12 11 बाइट्स

1*@ṾØDfƑʋ1#

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

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

1*@ṾØDfƑʋ1#  Main link. Argument: n

1            Set the return value to 1.
         1#  Call the link to the left for k = 1, 2, ... and with right argument n,
             until it returns a truthy value.
        ʋ      Combine the four links to the left into a dyadic chain.
 *@              Compute n**k.
   Ṿ             Convert it to its string representation.
    ØD           Yield "0123456789".
      fƑ         Filter and return 1 is the result is equal to the left argument.

Answer 18

क्लीन , 107 101 बाइट्स

import StdEnv,Data.Integer
$a=hd[b\\b<-[1..]|length(removeDup[c\\c<-:toString(prod(repeatn b a))])>9]

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

इनपुट के रूप में लेता है Integer, रिटर्न करता हैInt

Answer 19

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

(For[n=1,!AllTrue[DigitCount[#^n],#>0&],n++];n)&

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

Answer 20

अटैची , 27 बाइट्स

${Generate{#Unique[x^_]>9}}

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

व्याख्या

${Generate{#Unique[x^_]>9}}
${                        }    lambda, input: x
  Generate{              }     first natural number _ satisfying...
                   x^_             the input to that number
            Unique[   ]          unique digits of ^
           #                   length of ^
                       >9      is greater than 9
                               i.e.: has 10 distinct digits

वैकल्पिक

28 बाइट्स: ${Generate{Unique@S[x^_]@9}}

29 बाइट्स: ${Generate{Unique[S[x^_]]@9}}

30 बाइट्स: ${Generate{#Unique[S[x^_]]>9}}

31 बाइट्स: Generate@${{#Unique[S[x^_]]>9}}

32 बाइट्स: ${Generate[{#Unique[S[x^_]]>9}]}

33 बाइट्स: ${If[#Unique[x^y]>9,y,x&$!-~y]}&0

34 बाइट्स: ${If[#Unique[x^y]>9,y,$[x,y+1]]}&0