Một số nguyên dương có thể được biểu diễn trong một cơ sở số nguyên 1 <= b < inf.

Khi được chuyển đổi sang cơ sở đó, nó có một số chữ số riêng biệt.

Bất kỳ số nguyên dương trong cơ sở 1có 1chữ số riêng biệt.

Hầu hết các số nguyên dương trong cơ sở 2có 2các chữ số riêng biệt, ngoại lệ là các số có dạng 2^n - 1, chỉ có 1.

Vì vậy, số nguyên dương đầu tiên có thể được biểu diễn trong một cơ sở số nguyên có 1chữ số duy nhất là 1và số nguyên đầu tiên có thể được biểu thị bằng 2các chữ số riêng biệt là 2.

Có thể nói đó 1là số nguyên đầu tiên có phân tập số 1và 2là số nguyên đầu tiên có phân tập số 2.

Thử thách:

Cho một số nguyên dương ntrả về số nguyên dương đầu tiên (trong cơ sở mười *) có đa dạng kỹ thuật số là n.

* nếu ngôn ngữ của bạn chỉ hỗ trợ một cơ sở cụ thể (ví dụ: đơn nguyên hoặc nhị phân) thì bạn có thể xuất ra trong cơ sở đó.

Thuật toán của bạn phải hoạt động trên lý thuyết cho bất kỳ đầu vào số nguyên dương nào: nó có thể thất bại vì độ chính xác của số nguyên ngôn ngữ của bạn quá nhỏ so với đầu ra; nhưng có thể không thất bại vì chuyển đổi cơ sở chỉ được xác định tối đa một số giới hạn.

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

input  output
   1     1
   2     2
   3     11
   4     75
   5     694
   6     8345
   7     123717
  17     49030176097150555672
  20     5271200265927977839335179
  35     31553934355853606735562426636407089783813301667210139
  63     3625251781415299613726919161860178255907794200133329465833974783321623703779312895623049180230543882191649073441
 257     87678437238928144977867204156371666030574491195943247606217411725999221158137320290311206746021269051905957869964398955543865645836750532964676103309118517901711628268617642190891105089936701834562621017362909185346834491214407969530898724148629372941508591337423558645926764610261822387781382563338079572769909101879401794746607730261119588219922573912353523976018472514396317057486257150092160745928604277707892487794747938484196105308022626085969393774316283689089561353458798878282422725100360693093282006215082783023264045094700028196975508236300153490495688610733745982183150355962887110565055971546946484175232

Đây là code-golf , giải pháp ngắn nhất trong byte thắng.

OEIS: A049363 - cũng là số số nhỏ nhất trong cơ sở n.

Thạch , 4 byte

ṖaWḅ

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm

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

ṖaWḅ  Main link. Argument: n

Ṗ     Pop; yield [1, 2, 3, ..., n-1].
  W   Wrap; yield [n].
 a    Logical AND; yield [n, 2, 3, ..., n-1].
   ḅ  Convert the result from base n to integer.

Python, 40 byte

f=lambda n,k=1:n*(n<k+2)or-~f(n,k+1)*n-k

Kiểm tra nó trên Ideone .

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

Một số có n chữ số riêng biệt phải được thể hiện rõ ràng trong cơ sở b ≥ n . Vì mục tiêu của chúng tôi là giảm thiểu số lượng, b cũng nên càng nhỏ càng tốt, vì vậy b = n là lựa chọn hợp lý.

Điều đó khiến chúng ta sắp xếp các chữ số 0, Nhận, n-1 để tạo ra một số càng nhỏ càng tốt, điều đó có nghĩa là các chữ số có ý nghĩa nhất phải được giữ càng nhỏ càng tốt. Vì chữ số đầu tiên không thể là 0 trong biểu diễn chính tắc, nên số nhỏ nhất là
(1) (0) (2) ... (n-2) (n-1) _n = n ^n-1 + 2n ^n-3 + Cáp + (n-2) n + (n-1) , mà f tính toán đệ quy.

Python 2, 54 46 byte

Đây là một rất rất rất rất ! giải pháp nhanh, lặp đi lặp lại.

n=r=input();k=2
while k<n:r=r*n+k;k+=1
print r

Dùng thử trực tuyến

Không có đệ quy, vì vậy nó hoạt động cho đầu vào lớn. Đây là kết quả của n = 17000(mất 1-2 giây):

http://pastebin.com/UZjgvUSW

JavaScript (ES6), 29 byte

f=(b,n=b)=>n>2?f(b,--n)*b+n:b

J, 9 byte

#.],2}.i.

Dựa trên phương pháp của @Dennis .

Sử dụng

   f =: #.],2}.i.
   (,.f"0) >: i. 7
1      1
2      2
3     11
4     75
5    694
6   8345
7 123717
   f 17x
49030176097150555672

Giải trình

#.],2}.i.  Input: n
       i.  Get range, [0, 1, ..., n-1]
    2}.    Drop the first 2 values, [2, 3, ...., n-1]
  ]        Get n
   ,       Prepend it, [n, 2, 3, ..., n-1]
#.         Convert that to decimal from a list of base-n digits and return

Có một giải pháp thay thế dựa trên việc sử dụng chỉ số hoán vị. Với đầu vào n , tạo danh sách các chữ số [0, 1, ..., n], và tìm ra hoán vị sử dụng một chỉ số của n !, Và chuyển đổi đó như là một danh sách các cơ sở- n chữ số. Giải pháp tương ứng trong J cho 12 byte

#.]{.!A.i.,]  Input: n
        i.    Make range [0, 1, ..., n-1]
           ]  Get n
          ,   Join, makes [0, 1, ..., n-1, n]
     !        Factorial of n
      A.      Permutation index using n! into [0, 1, ..., n]
  ]           Get n
   {.         Take the first n values of that permutation
              (This is to handle the case when n = 1)
#.            Convert that to decimal from a list of base-n digits and return

Ruby, 37 35 34 byte

->n{s=n;(2...n).map{|d|s=s*n+d};s}

Câu trả lời cho một nhình thức 10234...(n-1)trong cơ sở n. Sử dụng n=10làm ví dụ:

Bắt đầu với n:10

Nhân với nvà thêm 2:102

Mutliply bởi nvà thêm 3:1023

Và như thế.

EDIT: Có vẻ ngắn hơn để sử dụng bản đồ.

EDIT 2: Cảm ơn vì tiền boa, m-chrzan!

CJam , 9 byte

ri__,2>+b

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

Giải trình

ri   e# Read input N.
__   e# Make two copies.
,    e# Turn last copy into range [0 1 2 ... N-1].
2>   e# Discard up to two leading values.
+    e# Prepend a copy of N.
b    e# Treat as base-N digits.

CJam (9 byte)

qi_,X2$tb

Bản demo trực tuyến

Mổ xẻ

Rõ ràng là số nhỏ nhất với sự đa dạng kỹ thuật số nđược tìm thấy bằng cách chuyển đổi [1 0 2 3 ... n-1]cơ sở trong cơ sở n. Tuy nhiên, lưu ý rằng chuyển đổi cơ sở tích hợp sẵn không yêu cầu các chữ số nằm trong phạm vi 0 .. n-1.

qi    e# Read integer from stdin
_,    e# Duplicate and built array [0 1 ... n-1]
X2$t  e# Set value at index 1 to n
b     e# Base conversion

Lưu ý rằng trong trường hợp đặc biệt n = 1, chúng tôi được 1 [0] 1 1 tbđưa ra 1 [0 1] bđó là 1.

Haskell, 31 byte

f n=foldl((+).(*n))n[2..n-1]

Chuyển đổi danh sách [n,2,3,...,n-1]thành cơ sở nbằng phương pháp Horner thông qua cách gấp. Một phiên bản ít chơi gôn này được đưa ra trên trang OEIS .

Cảm ơn nimi cho 3 byte!

05AB1E , 9 byte

DL¦¨v¹*y+

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

Giải trình

n = 4 được sử dụng chẳng hạn.

D           # duplicate input
            # STACK: 4, 4
 L          # range(1, a)
            # STACK: 4, [1,2,3,4]
  ¦¨        # remove first and last element of list
            # STACK: 4, [2,3]
    v       # for each y in list
     ¹*     # multiply current stack with input
       y+   # and add y
            # STACK, first pass: 4*4+2 = 18
            # STACK, second pass: 18*4+3 = 75

C ++ - 181 55

Đã sắp đăng bài giải pháp tuyệt vời đó bằng cách sử dụng <numeric>:

#import <vector>
#import <numeric>
using namespace std;int f(int n){vector<int> v(n+1);iota(v.begin(),v.end(),0);swap(v[0],v[1]);return accumulate(v.begin(),v.end()-1,0,[n](int r,int a){return r*n+a;});}

và sau đó tôi nhận ra đó là cách dễ dàng hơn:

int g(int n){int r=n,j=2;for(;j<n;)r=r*n+j++;return r;}

Perl 6 ,  34 31  30 byte

Được dịch từ ví dụ Haskell trên trang OEIS .

{(1,0,|(2..^$^n)).reduce: $n×*+*}        # 34
{(1,0,|(2..^$^n)).reduce: $n* *+*}       # 34

{reduce $^n×*+*,1,0,|(2..^$n)}           # 31
{[[&($^n×*+*)]] 1,0,|(2..^$n)}           # 31

{reduce $_×*+*,1,0,|(2..^$_)}            # 30

• [&(…)]biến …thành một toán tử infix tại chỗ
• Hình […]trên hiển thị biến một infix op thành một nếp gấp (trái hoặc phải tùy thuộc vào sự kết hợp của người vận hành)

Mở rộng:

{
  reduce

    # declare the blocks only parameter ｢$n｣ ( the ｢^｣ twigil )
    # declare a WhateverCode lambda that takes two args ｢*｣
    $^n × * + *

    # a list that always contains at least (1,0)
    1, 0,
    # with a range slipped in
    |(
      2 ..^ $n # range from 2 up-to and excluding ｢$n｣
               # it is empty if $n <= 2
    )
}

Sử dụng:

my &code = {reduce $_×*+*,1,0,|(2..^$_)}

say code 1; # 1
say code 2; # 2
say code 3; # 11
say code 4; # 75
say code 7; # 123717

# let's see how long it takes to calculate a largish value:

my $start-time = now;
$_ = code 17000;
my $calc-time = now;
$_ = ~$_; # 25189207981120412047...86380901260421982999
my $display-time = now;

say "It takes only { $calc-time - $start-time } seconds to calculate 17000";
say "but { $display-time - $calc-time } seconds to stringify"

# It takes only 1.06527824 seconds to calculate 17000
# but 5.3929017 seconds to stringify

Brain-Flak , 84 76 byte

Cảm ơn Wheat Wizard đã chơi golf 8 byte

(({})<>){(({}[()]))}{}(<{}{}>)((())){{}({<({}[()])><>({})<>}{}{})([][()])}{}

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

Giải trình

Chương trình đẩy các giá trị từ 0đến n-1ngăn xếp thay thế đỉnh 0và1 với 1và 0. Sau đó, nó nhân đỉnh của ngăn xếp nvà thêm giá trị bên dưới nó cho đến khi chỉ còn một giá trị trên ngăn xếp.

Về cơ bản, nó tìm thấy các chữ số cho số nhỏ nhất trong cơ sở ncó chứan các chữ số khác nhau (với n> 1 nó luôn có dạng 1023...(n-1)). Sau đó, nó tính toán số lượng cho các chữ số và cơ sở.

Mã chú thích

(({})<>)       # Pushes a copy of n to the right stack and switches to right stack
{(({}[()]))}{} # While the top of the stack != 0 copy the top of the stack-1
               #   and push it
(<{}{}>)       # Discard the top two values (0 and 1 for n > 1) and push 0
((()))         # Push 1 twice (second time so that the loop is works properly)
{{}            # Loop while stack height > 1
  (            #   Push...
    {<({}[()])><>({})<>}{} # The top value of the stack * n
    {}         #     Plus the value below the top of the stack
  )            #   End push
([][()])}{}    # End loop

Julia, 26 byte

\(n,k=n)=k<3?n:n\~-k*n+~-k

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

ShapeScript , 25 byte

_0?1'1+@2?*1?+@'2?2-*!#@#

Đầu vào là đơn nhất, đầu ra là số thập phân. Hãy thử trực tuyến!

PHP, 78 byte

for(;$i<$a=$argn;)$s=bcadd($s,bcmul($i<2?1-$i:$i,bcpow($a,$a-1-$i++)));echo$s;

Phiên bản trực tuyến

60 Byte chỉ hoạt động cho đến n = 16 với độ chính xác trong các mẫu thử

Với n = 144 INF

n = 145 NAN

for(;$j<$a=$argn;)$t+=($j<2?1-$j:$j)*$a**($a-1-$j++);echo$t;

k, 12 byte

Dựa trên câu trả lời của Dennis .

{x/x,2+!x-2}

JavaScript (ES6), 39 byte

Không sử dụng =>

function f(b,n){throw f(b,n>2?--n:1)*b}