Un nombre pandigital est un entier qui contient chaque chiffre de 0 à 9 au moins une fois. 1234567890, 1902837465000000 et 9023289761326634265 sont tous pandigital. Pour les besoins de ce défi, les nombres tels que 123456789 ne sont pas pandigital, car ils ne contiennent pas de 0, même si 123456789 = 0123456789.

Une paire diversifiée d'entiers est une paire d'entiers tels que est pandigital. est appelé l' exposant de diversification .$(a, b)$$a^b$$b$

Défi: étant donné un entier , trouver le plus petit exposant de diversification correspondant . Il s'agit d'un code-golf , donc le programme le plus court en octets l'emporte.$a$b$b$

(Vous pouvez supposer qu'il existe un tel exposant, c'est-à-dire que votre programme ne recevra pas d'entrée invalide, telle qu'une puissance de 10.)

Votre solution doit être capable de gérer au minimum les cas de test donnés, mais elle doit théoriquement gérer toutes les entrées valides.

C'est A090493 sur OEIS.

Cas de test

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 octets

;.≜^dl10∧

Essayez-le en ligne!

Ceci est une soumission de fonction. Le lien TIO contient un wrapper qui transforme une fonction en programme complet.

Explication

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

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

L'entrée doit être longue, car elle ​`k`​se comporte différemment pour les longs et les entiers.

Essayez-le en ligne!

Perl 6 , 32 octets

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

Essayez-le en ligne!

Assez explicite.

Explication

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

Prend l'entrée comme un littéral BigInt. Renvoie vrai au lieu de 1 .

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

Essayez-le en ligne!

Rubis , 41 octets

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

Essayez-le en ligne!

Haskell, 50 octets

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

Essayez-le en ligne!

Même nombre d'octets:

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

J , 25 octets

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

Essayez-le en ligne!

Verbe monadique unique. L'entrée doit être un entier à précision étendue (par exemple 2x).

Comment ça fonctionne

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

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

Essayez-le en ligne!

Raquette , 110 96 octets

-14 octets grâce à UltimateHawk!

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

Essayez-le en ligne!

Python 3 , 52 47 octets

merci à @BMO

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

Essayez-le en ligne!

05AB1E (hérité) , 10 9 octets

1 octet enregistré grâce à M. Xcoder

XµINmÙgTQ

Essayez-le en ligne!

Explication

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

Fusain , 19 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

Poussez à plusieurs reprises la chaîne vide dans la liste vide jusqu'à ce qu'il n'y ait pas de chiffres que la puissance de l'entrée sur la longueur de la liste ne contienne pas.

ＩＬυ

Imprimez la longueur de la liste.

K (ngn / k) , 76 octets

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

Essayez-le en ligne!

{ } fonction avec argument x

|(99#10)\x nous représentons les nombres sous forme de listes inversées de 99 chiffres décimaux - faites cela à l'argument

a::assigner à une variable globale a(k n'a pas de fermetures. nous devons aêtre globaux pour pouvoir l'utiliser dans des sous-fonctions)

{ }{ }\ tandis que la première fonction renvoie falsey, continuez à appliquer la deuxième fonction (aka boucle while), en préservant les résultats intermédiaires

a*\:xchacun des achiffres multiplié par chacun des xchiffres ("produit extérieur")

99 99#a*\:x,0 ajouter une colonne supplémentaire de 0 et remodeler à 99x99, cela déplace la i-ème ligne de i éléments vers la droite, en insérant 0 à gauche (cela fonctionne pour les tests, pour des entrées plus grandes, 99x99 peut entraîner des débordements)

+/ somme

{+/2 99#,/|0 10\x,0}/ propager le portage:

• { }/ continuer à postuler jusqu'à la convergence

• 0 10\x divmod par 10 (une paire de listes)

• |0 10\x moddiv par 10

• 2 99#,/|0 10\x,0 moddiv par 10, avec la partie "div" décalée d'un chiffre vers la droite

• +/ somme

{10>#?(+/|\0<|x)#x} - vérifier (pas) pandigital:

• |x sens inverse x

• 0< dont les chiffres sont différents de zéro

• |\ maxima partiels

• +/ somme - cela compte le nombre de 0 en tête dans x

• 10> sont-ils moins de 10?

# longueur de la séquence de pouvoirs - c'est le résultat

PowerShell , 107 octets

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

Essayez-le en ligne!

Assez simple, juste une honte que nous devons utiliser [bigint]partout. Nous prenons des informations $a, puis configurons une forboucle avec un initialiseur $b=1.

Chaque itération on incrémente $baprès avoir vérifié si $a ^ $b(via pow) envoyé toCharArra y, sorted avec le -udrapeau nique, puis -joined ensemble dans une chaîne est -not equal à la gamme 0..9également -joined dans une chaîne.

C'est une bouchée. Par exemple, il comparerait 7 ^ 5 = 16807 --> "01678"contre "0123456789", déterminer ils ne sont pas égaux, et continuer la boucle.

Une fois que nous sommes sortis de la boucle, nous avons déterminé ce qui $bconvient à notre entrée, et donc laisser cela sur le pipeline. La sortie est implicite.

Java, 108 octets

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

Essayez-le en ligne!

Explication

Force brute, boucle un ^ b jusqu'à ce qu'il trouve une chaîne avec 10 (ou plus, mais c'est impossible car il n'y aura que 0 à 9) caractères uniques.

BigDecimal est nécessaire à la fois parce que Math.pow n'est pas assez précis (échoue dans le cas 11), et aussi parce que la conversion d'un Doubleen une chaîne par défaut affiche une notation scientifique, ce qui rompt cette méthode de recherche d'un nombre pandigital.

Pyth, 10 8 octets

fq;l{`^Q

Essayez-le en ligne ici .

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

Enregistré 2 octets grâce à FryAmTheEggman, code précédent fq;l{j^QT;

Gelée , 12 11 octets

1*@ṾØDfƑʋ1#

Essayez-le en ligne!

Comment ça fonctionne

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.

Nettoyer , 107 101 octets

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

Essayez-le en ligne!

Prend l'entrée comme Integer, retourneInt

Wolfram Language (Mathematica) , 48 octets

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

Essayez-le en ligne!

Attaché , 27 octets

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

Essayez-le en ligne!

Explication

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

Alternatives

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

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

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

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

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

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

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