Một số kỹ thuật số là một số nguyên chứa mọi chữ số từ 0 đến 9 ít nhất một lần. 1234567890, 1902837465000000, và 9023289761326634265 đều là kỹ thuật số. Đối với mục đích của thử thách này, các số như 123456789 không phải là số, vì chúng không chứa 0, mặc dù 123456789 = 0123456789.

Một đa dạng cặp số nguyên là một cặp số nguyên $(a, b)$ mà $a^b$ là Pandigital. $b$ được gọi là số mũ đa dạng .

Thách thức: Cho một số nguyên $a$ , tìm số mũ b đa dạng tương ứng nhỏ nhất$b$ . Đây là một môn đánh gôn , vì vậy chương trình ngắn nhất tính bằng byte sẽ thắng.

(Bạn có thể cho rằng tồn tại số mũ như vậy, nghĩa là chương trình của bạn sẽ không được cung cấp đầu vào không hợp lệ, chẳng hạn như lũy thừa 10.)

Giải pháp của bạn phải có khả năng xử lý tối thiểu các trường hợp thử nghiệm nhất định, nhưng về mặt lý thuyết nên xử lý tất cả các đầu vào hợp lệ.

Đây là A090493 trên OEIS.

Các trường hợp thử nghiệm

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∧

Hãy thử trực tuyến!

Đây là một đệ trình chức năng. Liên kết TIO chứa một trình bao bọc làm cho một chức năng thành một chương trình đầy đủ.

Giải trình

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

Đầu vào phải dài, vì ​`k`​hành vi khác nhau trong thời gian dài và số nguyên.

Hãy thử trực tuyến!

Perl 6 , 32 byte

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

Hãy thử trực tuyến!

Khá tự giải thích.

Giải trình

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

Đưa đầu vào là một chữ BigInt. Trả về true thay vì 1 .

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

Hãy thử trực tuyến!

Ruby , 41 byte

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

Hãy thử trực tuyến!

Haskell, 50 byte

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

Hãy thử trực tuyến!

Cùng một số byte:

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

J , 25 byte

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

Hãy thử trực tuyến!

Động từ đơn âm. Đầu vào phải là một số nguyên có độ chính xác mở rộng (ví dụ 2x).

Làm thế nào nó hoạt động

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

Hãy thử trực tuyến!

Vợt , 110 96 byte

-14 byte nhờ UltimateHawk!

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

Hãy thử trực tuyến!

Python 3 , 52 47 byte

cảm ơn @BMO

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

Hãy thử trực tuyến!

05AB1E (di sản) , 10 9 byte

Đã lưu 1 byte nhờ Mr. Xcoder

XµINmÙgTQ

Hãy thử trực tuyến!

Giải trình

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

Than , 19 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

Lặp đi lặp lại đẩy chuỗi trống vào danh sách trống cho đến khi không có chữ số nào mà sức mạnh của đầu vào theo chiều dài của danh sách không chứa.

ＩＬυ

In độ dài của danh sách.

K (ngn / k) , 76 byte

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

Hãy thử trực tuyến!

{ } chức năng với đối số x

|(99#10)\x chúng tôi biểu thị các số dưới dạng danh sách đảo ngược gồm 99 chữ số thập phân - thực hiện điều đó cho đối số

a::gán cho biến toàn cục a(k không có bao đóng. chúng ta cần aphải là toàn cục để chúng ta có thể sử dụng nó trong các hàm con)

{ }{ }\ trong khi hàm đầu tiên trả về falsey, hãy tiếp tục áp dụng hàm thứ hai (còn gọi là vòng lặp while), giữ nguyên kết quả trung gian

a*\:xmỗi achữ số nhân với mỗi xchữ số ("sản phẩm bên ngoài")

99 99#a*\:x,0 thêm một cột 0s và định hình lại một lần nữa thành 99x99, điều này làm dịch chuyển hàng thứ i sang i bên phải, chèn 0 ở bên trái (điều này hoạt động cho các thử nghiệm, đối với đầu vào lớn hơn 99x99 có thể dẫn đến tràn)

+/ tổng

{+/2 99#,/|0 10\x,0}/ tuyên truyền mang:

• { }/ tiếp tục áp dụng cho đến khi hội tụ

• 0 10\x divmod by 10 (một cặp danh sách)

• |0 10\x moddiv bằng 10

• 2 99#,/|0 10\x,0 moddiv bằng 10, với phần "div" đã dịch 1 chữ số sang phải

• +/ tổng

{10>#?(+/|\0<|x)#x} - kiểm tra (không) pandigital:

• |x đảo ngược x

• 0< chữ số nào khác không

• |\ cực đại một phần

• +/ tổng - số này đếm số 0 hàng đầu trong x

• 10> họ có ít hơn 10 không?

# độ dài của chuỗi quyền hạn - đây là kết quả

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

Hãy thử trực tuyến!

Khá đơn giản, chỉ là một sự xấu hổ chúng ta cần sử dụng [bigint]ở mọi nơi. Chúng tôi nhận đầu vào $a, sau đó thiết lập một forvòng lặp với trình khởi tạo$b=1 .

Mỗi increment lặp chúng tôi $bsau khi kiểm tra liệu $a ^ $b(thông qua pow) gửi toCharArra y, sorted với -ucờ nique, sau đó -joined với nhau thành một chuỗi được -not equal đến phạm vi0..9 cũng-join ed vào một chuỗi.

Đó là một câu nói miệng. Ví dụ, điều này sẽ so sánh 7 ^ 5 = 16807 --> "01678"với"0123456789" , xác định chúng không bằng nhau và tiếp tục vòng lặp.

Khi chúng tôi ra khỏi vòng lặp, chúng tôi đã xác định cái nào $bphù hợp với đầu vào của chúng tôi và vì vậy hãy để nó trên đường ống dẫn. Đầu ra là ẩn.

Java, 108 byte

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

Hãy thử trực tuyến!

Giải trình

Brute force, lặp a ^ b cho đến khi tìm thấy một chuỗi có 10 (hoặc nhiều hơn, nhưng điều đó là không thể vì sẽ chỉ có 0 đến 9) ký tự duy nhất.

BigDecimalđược yêu cầu cả bởi vì Math.powkhông đủ chính xác (không thành công trong trường hợp 11) và bởi vì việc chuyển đổi Doublemột chuỗi thành mặc định cho thấy ký hiệu khoa học, phá vỡ phương pháp tìm số này.

Bình thường, 10 8 byte

fq;l{`^Q

Hãy thử trực tuyến tại đây .

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

Đã lưu 2 byte nhờ FryAmTheEggman, mã trước đó fq;l{j^QT;

Thạch , 12 11 byte

1*@ṾØDfƑʋ1#

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Sạch , 107 101 byte

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

Hãy thử trực tuyến!

Lấy đầu vào là Integer, trả vềInt

Ngôn ngữ Wolfram (Mathicala) , 48 byte

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

Hãy thử trực tuyến!

Tùy viên , 27 byte

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

Hãy thử trực tuyến!

Giải trình

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

Lựa chọn thay thế

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