Um número pandigital é um número inteiro que contém todos os dígitos de 0 a 9 pelo menos uma vez. 1234567890, 1902837465000000 e 9023289761326634265 são todos pandigitais. Para os fins deste desafio, números como 123456789 não são pandigitais, pois não contêm um 0, mesmo que 123456789 = 0123456789.

Um par diverso de números inteiros é um par de números inteiros tal que é pandigital. é chamado expoente diversificador .$(a, b)$$a^b$$b$

Desafio: Dado um número inteiro , encontre o menor expoente diversificador correspondente . Este é um código de golfe , portanto o programa mais curto em bytes vence.$a$$b$

(Você pode assumir que existe um expoente, ou seja, seu programa não receberá entrada inválida, como uma potência de 10.)

Sua solução deve poder manipular no mínimo os casos de teste fornecidos, mas teoricamente deve manipular todas as entradas válidas.

Este é o A090493 no OEIS.

Casos de teste

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∧

Experimente online!

Este é um envio de função. O link TIO contém um wrapper que transforma uma função em um programa completo.

Explicação

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

A entrada deve ser longa, pois ​`k`​se comporta de maneira diferente para comprimentos e entradas.

Experimente online!

Perl 6 , 32 bytes

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

Experimente online!

Bastante auto-explicativo.

Explicação

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

Recebe a entrada como um literal BigInt. Retorna true em vez de 1 .

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

Experimente online!

Ruby , 41 bytes

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

Experimente online!

Haskell, 50 bytes

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

Experimente online!

Contagem de mesmos bytes:

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

J , 25 bytes

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

Experimente online!

Único verbo monádico. A entrada deve ser um número inteiro de precisão estendida (por exemplo 2x).

Como 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}

Experimente online!

Raquete , 110 96 bytes

-14 bytes graças ao UltimateHawk!

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

Experimente online!

Python 3 , 52 47 bytes

graças a @BMO

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

Experimente online!

05AB1E (herdado) , 10 9 bytes

Economizou 1 byte graças ao Sr. Xcoder

XµINmÙgTQ

Experimente online!

Explicação

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

Carvão , 19 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

Empurre repetidamente a sequência vazia para a lista vazia até que não haja dígitos que a potência da entrada no comprimento da lista não contenha.

ＩＬυ

Imprima o comprimento da 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}

Experimente online!

{ } função com argumento x

|(99#10)\x representamos números como listas invertidas de 99 dígitos decimais - faça isso com o argumento

a::atribuir à variável global a(k não possui fechamentos. precisamos aser globais para que possamos usá-la em subfunções)

{ }{ }\ enquanto a primeira função retorna falsey, continue aplicando a segunda função (aka loop while), preservando resultados intermediários

a*\:xcada um dos adígitos multiplicado por cada um dos xdígitos ("produto externo")

99 99#a*\:x,0 adicione uma coluna extra de 0s e altere novamente para 99x99, isso muda a i-ésima linha por i itens para a direita, inserindo 0s à esquerda (isso funciona para os testes, para entradas maiores, 99x99 pode levar a estouros)

+/ soma

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

• { }/ continue aplicando até convergência

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

• |0 10\x moddiv by 10

• 2 99#,/|0 10\x,0 moddiv por 10, com a parte "div" deslocada 1 dígito para a direita

• +/ soma

{10>#?(+/|\0<|x)#x} - verifique (não) pandigital:

• |x marcha ré x

• 0< quais dígitos são diferentes de zero

• |\ máximos parciais

• +/ soma - isso conta o número de 0s iniciais em x

• 10> eles são menos de 10?

# comprimento da sequência de poderes - este é o 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

Experimente online!

Bem simples, apenas uma pena que precisamos usar em [bigint]qualquer lugar. Nós recebemos a entrada $ae configuramos um forloop com o inicializador $b=1.

Cada iteração que incrementamos $bapós verificar se $a ^ $b(via pow) enviado toCharArra y, sorted com o -usinalizador nique, e depois -joineditado em uma string é -not equal ao intervalo 0..9também -joined em uma string.

Isso é um bocado. Por exemplo, este seria comparar 7 ^ 5 = 16807 --> "01678"contra "0123456789", determinar que eles não são iguais, e continuar o ciclo.

Uma vez que estamos fora do circuito, determinamos o que melhor se $badequa às nossas informações e, portanto, deixamos isso no pipeline. A saída está implícita.

Java, 108 bytes

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

Experimente online!

Explicação

Força bruta, fazendo um loop a ^ b até encontrar uma sequência com 10 (ou mais, mas isso é impossível, pois haverá apenas 0 a 9) caracteres únicos.

BigDecimalé necessário, porque Math.pownão é preciso o suficiente (falha no caso 11) e também porque converter um Doublepara uma String por padrão mostra notação científica, que quebra esse método de encontrar um número pandigital.

Pitão, 10 8 bytes

fq;l{`^Q

Experimente online aqui .

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

Economizou 2 bytes graças a FryAmTheEggman, código anterior fq;l{j^QT;

Geléia , 12 11 bytes

1*@ṾØDfƑʋ1#

Experimente online!

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

Limpo , 107 101 bytes

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

Experimente online!

Recebe entrada como Integer, retornaInt

Wolfram Language (Mathematica) , 48 bytes

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

Experimente online!

Anexo , 27 bytes

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

Experimente online!

Explicação

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