Eine Pandigitalzahl ist eine Ganzzahl, die jede Ziffer von 0 bis 9 mindestens einmal enthält. 1234567890, 1902837465000000 und 9023289761326634265 sind alle pandigital. Für die Zwecke dieser Herausforderung sind Zahlen wie 123456789 nicht pandigital, da sie keine 0 enthalten, obwohl 123456789 = 0123456789.

Ein verschiedenes Paar von ganzen Zahlen ist ein Paar von ganzen Zahlen $(a, b)$ so dass $a^b$ pandigital ist. heißt der diversifizierende Exponent .$b$

Aufgabe: Bestimme mit einer ganzen Zahl den kleinsten entsprechenden diversifizierenden Exponenten b . Dies ist ein Code-Golf , also gewinnt das kürzeste Programm in Bytes.$a$$b$

(Sie können davon ausgehen, dass es einen solchen Exponenten gibt, das heißt, Ihr Programm erhält keine ungültige Eingabe, z. B. eine Potenz von 10).

Ihre Lösung muss in der Lage sein, die angegebenen Testfälle mindestens zu verarbeiten, sollte jedoch theoretisch alle gültigen Eingaben verarbeiten.

Dies ist A090493 bei OEIS.

Testfälle

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

Brachylog (v2), 9 Bytes

;.≜^dl10∧

Probieren Sie es online!

Dies ist eine Funktionsübermittlung. Die TIO-Verknüpfung enthält einen Wrapper, der eine Funktion in ein vollständiges Programm umwandelt.

Erläuterung

;.≜^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)

Python 2 , 44 Bytes

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

Die Eingabe muss ein Long sein, da ​`k`​sich Longs und Ints unterschiedlich verhalten.

Probieren Sie es online!

Perl 6 , 32 Bytes

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

Probieren Sie es online!

Ziemlich selbsterklärend.

Erläuterung

{                              }  # 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

JavaScript (Node.js) ,  51 46  43 Bytes

Übernimmt die Eingabe als BigInt-Literal. Gibt true anstelle von 1 zurück .

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

Probieren Sie es online!

Ruby , 41 Bytes

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

Probieren Sie es online!

Haskell, 50 Bytes

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

Probieren Sie es online!

Gleiche Byteanzahl:

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

J , 25 Bytes

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

Probieren Sie es online!

Einziges monadisches Verb. Die Eingabe sollte eine Ganzzahl mit erweiterter Genauigkeit sein (z 2x. B. ).

Wie es funktioniert

>:@]^:(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

Tcl , 82 Bytes

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

Probieren Sie es online!

Schläger , 110 96 Bytes

-14 Bytes dank UltimateHawk!

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

Probieren Sie es online!

Python 3 , 52 47 Bytes

danke an @BMO

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

Probieren Sie es online!

05AB1E (Legacy) , 10 9 Bytes

1 Byte gespart dank Mr. Xcoder

XµINmÙgTQ

Probieren Sie es online!

Erläuterung

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

Holzkohle , 19 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Schieben Sie die leere Zeichenfolge wiederholt in die leere Liste, bis es keine Ziffern mehr gibt, die die Potenz der Eingabe zur Länge der Liste nicht enthält.

ＩＬυ

Drucken Sie die Länge der Liste.

K (ngn / k) , 76 Bytes

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

Probieren Sie es online!

{ } Funktion mit Argument x

|(99#10)\x Wir stellen Zahlen als umgekehrte Listen mit 99 Dezimalstellen dar - machen Sie das mit dem Argument

a::Zuweisen zu globaler Variable a(k hat keine Closures. Wir müssen aglobal sein, damit wir es in Unterfunktionen verwenden können.)

{ }{ }\ Während die erste Funktion falsey zurückgibt, wenden Sie weiterhin die zweite Funktion (auch while-Schleife genannt) an, um Zwischenergebnisse zu erhalten

a*\:xjede aZiffer multipliziert mit jeder xZiffer ("äußeres Produkt")

99 99#a*\:x,0 Füge eine zusätzliche Spalte mit 0s hinzu und verändere die Form erneut auf 99x99. Dies verschiebt die i-te Zeile um i Elemente nach rechts und füge 0s nach links ein (dies funktioniert für die Tests, bei größeren Eingaben kann 99x99 zu Überläufen führen).

+/ Summe

{+/2 99#,/|0 10\x,0}/ Übertragen:

• { }/ Bewerben Sie sich bis zur Konvergenz

• 0 10\x DivMod durch 10 (ein Paar Listen)

• |0 10\x moddiv um 10

• 2 99#,/|0 10\x,0 moddiv um 10, wobei der Teil "div" um eine Stelle nach rechts verschoben ist

• +/ Summe

{10>#?(+/|\0<|x)#x} - auf (nicht) pandigital prüfen:

• |x umkehren x

• 0< welche Ziffern ungleich Null sind

• |\ Teilmaxima

• +/ sum - Dies zählt die Anzahl der führenden Nullen in x

• 10> sind sie weniger als 10?

# Länge der Folge von Kräften - das ist das Ergebnis

PowerShell , 107 Byte

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

Probieren Sie es online!

Ziemlich einfach, nur eine Schande, die wir [bigint]überall verwenden müssen. Wir nehmen Eingaben $aund richten dann einfor Schleife mit dem Initialisierer ein $b=1.

Jeder Iteration uns Schritt $bnach dem Prüfen , ob $a ^ $b(über pow) gesendet toCharArra y, sortmit der ed -unique Flagge, dann -joinin einen String ed zusammen ist -not equal auf den Bereich 0..9auch-join in einen String ed.

Das ist ein Schluck. Zum Beispiel würde vergleichen diese 7 ^ 5 = 16807 --> "01678"gegen"0123456789" , bestimmen sie nicht gleich sind, und die Schleife weiter.

Sobald wir die Schleife verlassen haben, haben wir festgestellt, welcher für $bunsere Eingabe geeignet ist, und belassen diesen Wert in der Pipeline. Die Ausgabe ist implizit.

Java, 108 Bytes

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

Probieren Sie es online!

Erläuterung

Brute Force, indem Sie eine Schleife von a ^ b durchlaufen, bis eine Zeichenfolge mit 10 (oder mehr) eindeutigen Zeichen gefunden wird. Dies ist jedoch unmöglich, da nur 0 bis 9 Zeichen vorhanden sind.

BigDecimalDies ist sowohl erforderlich, weil Math.powes nicht genau genug ist (schlägt in Groß- 11und Kleinschreibung fehl ), als auch, weil beim Konvertieren von a Doublein einen String standardmäßig die wissenschaftliche Notation angezeigt wird, die diese Methode zum Ermitteln einer pandigitalen Zahl unterbricht.

Pyth, 10 8 Bytes

fq;l{`^Q

Probieren Sie es hier online aus .

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 Bytes dank FryAmTheEggman, dem vorherigen Code, eingespart fq;l{j^QT;

Jelly , 12 11 Bytes

1*@ṾØDfƑʋ1#

Probieren Sie es online!

Wie es funktioniert

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.

Sauber , 107 101 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe als Integer, kehrt zurückInt

Wolfram Language (Mathematica) , 48 Byte

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

Probieren Sie es online!

Attache , 27 Bytes

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

Probieren Sie es online!

Erläuterung

${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

Alternativen

28 Bytes: ${Generate{Unique@S[x^_]@9}}

29 Bytes: ${Generate{Unique[S[x^_]]@9}}

30 Bytes: ${Generate{#Unique[S[x^_]]>9}}

31 Bytes: Generate@${{#Unique[S[x^_]]>9}}

32 Bytes: ${Generate[{#Unique[S[x^_]]>9}]}

33 Bytes: ${If[#Unique[x^y]>9,y,x&$!-~y]}&0

34 Bytes: ${If[#Unique[x^y]>9,y,$[x,y+1]]}&0