Un número pandigital es un número entero que contiene cada dígito del 0 al 9 al menos una vez. 1234567890, 1902837465000000 y 9023289761326634265 son todos pandigitales. Para los propósitos de este desafío, números como 123456789 no son pandigitales, ya que no contienen un 0, aunque 123456789 = 0123456789.

Un par diverso de enteros es un par de enteros $(a, b)$ modo que es pandigital. se llama el exponente diversificador .$a^b$$b$

Desafío: dado un número entero , encuentre el exponente diversificador correspondiente más pequeño . Este es un código de golf , por lo que gana el programa más corto en bytes.$a$b$b$

(Puede suponer que existe tal exponente, es decir, su programa no recibirá una entrada no válida, como una potencia de 10).

Su solución debe poder manejar como mínimo los casos de prueba dados, pero en teoría debería manejar todas las entradas válidas.

Este es A090493 en OEIS.

Casos de prueba

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∧

Pruébalo en línea!

Esta es una presentación de función. El enlace TIO contiene un contenedor que convierte una función en un programa completo.

Explicación

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

La entrada debe ser larga, ya que se ​`k`​comporta de manera diferente para longs e ints.

Pruébalo en línea!

Perl 6 , 32 bytes

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

Pruébalo en línea!

Bastante autoexplicativo.

Explicación

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

Toma la entrada como un literal BigInt. Devuelve verdadero en lugar de 1 .

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

Pruébalo en línea!

Ruby , 41 bytes

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

Pruébalo en línea!

Haskell, 50 bytes

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

Pruébalo en línea!

Mismo recuento de bytes:

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

J , 25 bytes

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

Pruébalo en línea!

Solo verbo monádico. La entrada debe ser un número entero de precisión extendida (por ejemplo 2x).

Cómo funciona

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

Pruébalo en línea!

Raqueta , 110 96 bytes

-14 bytes gracias a UltimateHawk!

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

Pruébalo en línea!

Python 3 , 52 47 bytes

gracias a @BMO

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

Pruébalo en línea!

05AB1E (legado) , 10 9 bytes

Guardado 1 byte gracias al Sr. Xcoder

XµINmÙgTQ

Pruébalo en línea!

Explicación

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

Carbón de leña , 19 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

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

Empuje repetidamente la cadena vacía a la lista vacía hasta que no haya dígitos que la potencia de la entrada a la longitud de la lista no contenga.

ＩＬυ

Imprime la longitud de la lista.

K (ngn / k) , 76 bytes

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

Pruébalo en línea!

{ } funcionar con argumento x

|(99#10)\x representamos los números como listas invertidas de 99 dígitos decimales; haga eso con el argumento

a::asignar a variable global a(k no tiene cierres. Necesitamos aser globales para poder usarlo en subfunciones)

{ }{ }\ mientras la primera función devuelve falsey, sigue aplicando la segunda función (también conocida como bucle while), conservando los resultados intermedios

a*\:xcada uno de alos dígitos multiplicado por cada uno de xlos dígitos ("producto externo")

99 99#a*\:x,0 agregue una columna adicional de 0s y vuelva a formar de nuevo a 99x99, esto desplaza la i-ésima fila por i elementos a la derecha, insertando 0s a la izquierda (esto funciona para las pruebas, para entradas más grandes 99x99 podría provocar desbordamientos)

+/ suma

{+/2 99#,/|0 10\x,0}/ propagar llevar:

• { }/ seguir aplicando hasta la convergencia

• 0 10\x divmod por 10 (un par de listas)

• |0 10\x moddiv por 10

• 2 99#,/|0 10\x,0 moddiv por 10, con la parte "div" desplazada 1 dígito a la derecha

• +/ suma

{10>#?(+/|\0<|x)#x} - comprobar para (no) pandigital:

• |x marcha atrás x

• 0< qué dígitos no son cero

• |\ maxima parcial

• +/ sum: esto cuenta el número de ceros iniciales en x

• 10> son menos de 10?

# longitud de la secuencia de poderes: este es el resultado

PowerShell , 107 bytes

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

Pruébalo en línea!

Bastante sencillo, es una pena que necesitemos usar en [bigint]todas partes. Tomamos entrada $a, luego configuramos un forbucle con inicializador $b=1.

Cada iteración que incrementamos $bdespués de verificar si $a ^ $b(vía pow) envió toCharArra y,sort ed con la -ubandera nique, a continuación, -joined juntos en una cadena es -not equal a la gama 0..9también -joined en una cadena.

Eso es un bocado. Por ejemplo, esto compararía7 ^ 5 = 16807 --> "01678" con "0123456789", determinaría que no son iguales y continuaría el ciclo.

Una vez que estamos fuera del ciclo, hemos determinado cuál se $badapta a nuestra entrada, y así lo dejamos en la tubería. La salida es implícita.

Java, 108 bytes

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

Pruébalo en línea!

Explicación

Fuerza bruta, haciendo un bucle a ^ b hasta que encuentre una cadena con 10 (o más, pero eso es imposible ya que solo habrá 0 a 9) caracteres únicos.

BigDecimalse requiere tanto porque Math.powno es lo suficientemente preciso (falla en el caso 11) como porque la conversión Doublede una cadena a una cadena predeterminada muestra notación científica, lo que rompe este método de encontrar un número pandigital.

Pyth, 10 8 bytes

fq;l{`^Q

Pruébelo en línea aquí .

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

Guardado 2 bytes gracias a FryAmTheEggman, código anterior fq;l{j^QT;

Jalea , 12 11 bytes

1*@ṾØDfƑʋ1#

Pruébalo en línea!

Cómo funciona

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.

Limpio , 107 101 bytes

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

Pruébalo en línea!

Toma entrada como Integer, devuelveInt

Wolfram Language (Mathematica) , 48 bytes

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

Pruébalo en línea!

Adjunto , 27 bytes

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

Pruébalo en línea!

Explicación

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

Alternativas

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