Un numero pandigitale è un numero intero che contiene ogni cifra da 0 a 9 almeno una volta. 1234567890, 1902837465000000 e 9023289761326634265 sono tutti pandigitali. Ai fini di questa sfida, numeri come 123456789 non sono pandigitali, poiché non contengono uno 0, anche se 123456789 = 0123456789.

Una diversa coppia di numeri interi è una coppia di numeri interi tale che è pandigitale. è chiamato esponente diversificatore .$(a, b)$$a^b$$b$

Sfida: dato un numero intero , trova l' esponente di diversificazione corrispondente più piccolo . Questo è un codice-golf , quindi vince il programma più breve in byte.$a$$b$

(Puoi presumere che esista un tale esponente, cioè al tuo programma non verrà dato un input non valido, come una potenza di 10.)

La soluzione deve essere in grado di gestire almeno i casi di test indicati, ma teoricamente dovrebbe gestire tutti gli input validi.

Questo è A090493 su OEIS.

Casi 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 byte

;.≜^dl10∧

Provalo online!

Questa è una presentazione di funzione. Il collegamento TIO contiene un wrapper che trasforma una funzione in un programma completo.

Spiegazione

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

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

L'input deve essere lungo, poiché ​`k`​si comporta in modo diverso per long e ints.

Provalo online!

Perl 6 , 32 byte

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

Provalo online!

Abbastanza autoesplicativo.

Spiegazione

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

Accetta input come un letterale BigInt. Restituisce vero invece di 1 .

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

Provalo online!

Rubino , 41 byte

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

Provalo online!

Haskell, 50 byte

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

Provalo online!

Stesso numero di byte:

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

J , 25 byte

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

Provalo online!

Verbo monadico singolo. L'input deve essere un numero intero di precisione estesa (ad es 2x.).

Come funziona

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

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

Provalo online!

Racchetta , 110 96 byte

-14 byte grazie a UltimateHawk!

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

Provalo online!

Python 3 , 52 47 byte

grazie a @BMO

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

Provalo online!

05AB1E (legacy) , 10 9 byte

Salvato 1 byte grazie a Mr. Xcoder

XµINmÙgTQ

Provalo online!

Spiegazione

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

Carbone , 19 byte

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

Provalo online!Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

Spingere ripetutamente la stringa vuota nell'elenco vuoto fino a quando non vi sono cifre che la potenza dell'input per la lunghezza dell'elenco non contiene.

ＩＬυ

Stampa la lunghezza dell'elenco.

K (ngn / k) , 76 byte

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

Provalo online!

{ } funzione con argomento x

|(99#10)\x rappresentiamo i numeri come elenchi invertiti di 99 cifre decimali - fatelo per l'argomento

a::assegnare alla variabile globale a(k non ha chiusure. dobbiamo aessere globali in modo da poterlo utilizzare nelle funzioni secondarie)

{ }{ }\ mentre la prima funzione restituisce falsey, continua ad applicare la seconda funzione (aka ciclo while), preservando risultati intermedi

a*\:xognuna delle acifre moltiplicata per ciascuna dix cifre ("prodotto esterno")

99 99#a*\:x,0 aggiungi una colonna aggiuntiva di 0s e rimodella di nuovo a 99x99, questo sposta l'i-esima riga di i elementi a destra, inserendo 0s a sinistra (funziona per i test, per input più grandi 99x99 potrebbe portare a overflow)

+/ somma

{+/2 99#,/|0 10\x,0}/ propagare trasportare:

• { }/ continuare ad applicare fino alla convergenza

• 0 10\x divmod per 10 (una coppia di liste)

• |0 10\x moddiv di 10

• 2 99#,/|0 10\x,0 moddiv di 10, con la parte "div" spostata di 1 cifra verso destra

• +/ somma

{10>#?(+/|\0<|x)#x} - verifica (non) pandigitale:

• |x inverso x

• 0< quali cifre sono diverse da zero

• |\ massimi parziali

• +/ somma: conta il numero di 0 iniziali in x

• 10> sono meno di 10?

# lunghezza della sequenza di poteri - questo è il risultato

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

Provalo online!

Abbastanza semplice, solo un peccato che dobbiamo usare [bigint]ovunque. Prendiamo l'input $a, quindi impostiamo un forloop con l'inizializzatore $b=1.

Ogni iterazione viene incrementato $bdopo aver verificato $a ^ $b(via pow) inviato toCharArra y, sortED con la -ubandiera nique, poi -joinEd insieme in una stringa è -not equal alla gamma 0..9anche -joinEd in una stringa.

È un boccone. Ad esempio, questo sarebbe confrontare 7 ^ 5 = 16807 --> "01678"contro "0123456789", determinare non sono uguali, e continuare il ciclo.

Una volta che siamo fuori dal giro, abbiamo determinato quale si $badatta al nostro input e quindi lo lasciamo sulla pipeline. L'output è implicito.

Java, 108 byte

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

Provalo online!

Spiegazione

Forza bruta, facendo un ciclo a ^ b fino a quando non trova una stringa con 10 (o più, ma è impossibile in quanto ci saranno solo da 0 a 9) caratteri unici.

BigDecimalè richiesto sia perché Math.pownon è abbastanza preciso (fallisce nel caso 11), sia perché la conversione Doubledi una stringa in modo predefinito mostra una notazione scientifica, che interrompe questo metodo di ricerca di un numero pandigitale.

Pyth, 10 8 byte

fq;l{`^Q

Provalo online qui .

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

Salvato 2 byte grazie a FryAmTheEggman, codice precedente fq;l{j^QT;

Gelatina , 12 11 byte

1*@ṾØDfƑʋ1#

Provalo online!

Come funziona

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.

Pulito , 107 101 byte

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

Provalo online!

Accetta input come Integer, restituisceInt

Wolfram Language (Mathematica) , 48 byte

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

Provalo online!

Attache , 27 byte

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

Provalo online!

Spiegazione

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

alternative

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

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

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

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

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

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

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