Exponente diversificador más pequeño

20

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 .abb

Desafío: dado un número entero , encuentre el exponente diversificador correspondiente más pequeño . Este es un , por lo que gana el programa más corto en bytes.abb

(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
Conor O'Brien
fuente
3
Quiero señalar un caso especial 1234567890 -> 1.
Bubbler
@Bubbler agregado.
Conor O'Brien
¿están los exponentes negativos fuera de los límites?
sudo rm -rf slash
1
¿Algo como 123456789contar como pandigital? Es igual a 0123456789, que definitivamente es pandigital.
wastl
1
@ wastl no, no lo hace.
Conor O'Brien

Respuestas:

9

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)
ais523
fuente
7

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!

Dennis
fuente
5

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
Jo King
fuente
4

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!

Arnauld
fuente
2
Sigo olvidando que JS tiene bigint's ahora: D
Conor O'Brien
Estoy un poco dudoso con respecto a volver verdadero en lugar de 1. Eso no parece coincidir con nada descrito en codegolf.meta.stackexchange.com/questions/9263/…
Sparr
3
@Sparr Aquí está el consenso actual.
Arnauld
Gracias. Puse una nueva respuesta en mi enlace en referencia a eso.
Sparr
4

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
nimi
fuente
3

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
Bubbler
fuente
(]+10>#@=@":@^)^:_*
FrownyFrog
2

Tcl , 82 bytes

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

Pruébalo en línea!

sergiol
fuente
Puede guardar algunos bytes más con llength 82 bytes
david
Guardado algunos bytes, luego gracias a @david
sergiol
2

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!

Galen Ivanov
fuente
1
Esto se puede acortar a 96 bytes recurriendo a la función en su lugar(define(f n[b 1])(if(= 10(length(remove-duplicates(string->list(~v(expt n b))))))b(f n(+ b 1))))
Ultimate Hawk
@UltimateHawk ¡Gracias! Olvidé los parámetros predeterminados ... (aunque la función auxiliar también utilizó el parámetro predeterminado b ...)
Galen Ivanov
2

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!

david
fuente
Solo un aviso, pero puede eliminar el código antiguo y poner "<s> 52 </s> 47" en la línea del encabezado. El registro de edición conservará las versiones anteriores si alguien tiene curiosidad
Veskah
2

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
Emigna
fuente
1
Legacy ahorra 1 byte: 1µINmÙgTQ- ¡ Pruébalo en línea!
Sr. Xcoder
@ Mr.Xcoder: Oh, sí, tuvimos la salida implícita de Nentonces. ¡Gracias!
Emigna
1

Carbón de leña , 19 bytes

WΦχ¬№IXIθLυIκ⊞υωILυ

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

WΦχ¬№IXIθLυIκ⊞υω

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.

ILυ

Imprime la longitud de la lista.

Neil
fuente
¿Por qué el voto negativo?
Luis Mendo
1

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

ngn
fuente
1

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.

AdmBorkBork
fuente
1

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.

Hypino
fuente
¿Los vars de Java no comienzan en 0 por defecto? Podría ahorrar 2 bytes al eliminar la inicialización.
Darrel Hoffman
@DarrelHoffman Las variables de instancia sí, sí. Las variables de ámbito local no lo hacen.
Hypino
Ah bien. Hace tiempo que trabajé en Java, olvidé ese tecnicismo.
Darrel Hoffman
Puede guardar 6 bytes cambiando new java.math.BigDecimal(a).pow(++b).toString()a (new java.math.BigDecimal(a).pow(++b)+"")(y el punto y coma final no tiene que contarse para las funciones lambda). Pruébelo en línea
Kevin Cruijssen
1

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;

Sok
fuente
Puede usar la tecla de retroceso para convertir el número en una cadena en lugar de hacer una conversión de base que le permitirá omitir la Toperación de energía.
FryAmTheEggman
0

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.
Dennis
fuente
0

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

Οurous
fuente
0

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

Conor O'Brien
fuente