Cho phép tạo một hệ thống các số trong đó chữ số lớn nhất trong giá trị vị trí thứ n (tính từ phải sang trái) có độ dài m luôn bằng m - n + 1. Để đưa ra ví dụ về số có 5 chữ số lớn nhất có thể biểu thị trong hệ thống này được viết 12345. Ngoài số lượng chữ số có sẵn được sử dụng ở một nơi cụ thể bị hạn chế, tất cả các mức tăng khác là tiêu chuẩn. Cụ thể khi một chữ số vượt quá giới hạn chữ số của nó, chúng ta thêm một chữ số vào chữ số tiếp theo.

Đây là cách đếm sẽ được thể hiện trong hệ thống này:

1; 10; 11; 12; 100; 101; 102; 103; 110; 111; 112; 113; 120; 121; 122; 123; 1000; 1001 ...

Nhiệm vụ của bạn là viết một hàm lấy một số cơ sở 10 tiêu chuẩn và chuyển đổi nó thành hệ thống đánh số của tôi.

Mã ngắn hơn là thích hợp hơn. Cơ hội Bonne!

** Nếu bạn cần chữ số sau 9 (bạn nên), bạn có thể chọn sử dụng chữ cái hoặc bạn có thể trả về số có 2 chữ số làm thành phần của danh sách.

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

10 -> 111
20 -> 1003
30 -> 1023
50 -> 1123
100 -> 10035
23116 -> 1234567
21977356 -> 123456789A

Trường hợp cuối cùng có thể rất chậm để chạy tùy thuộc vào cách bạn thực hiện. Bạn không cần chạy nó nếu mất quá nhiều thời gian hoặc sử dụng quá nhiều bộ nhớ. Tuy nhiên lưu ý rằng có những cách để nó chạy nhanh và sử dụng ít bộ nhớ.

Toán học, 64 byte

Part[Join@@Array[Tuples@Join[{{1}},Array[Range,#-1,3]-1]&,#],#]&

Hàm không tên lấy tham số nguyên dương và trả về danh sách các số nguyên.

Join[{{1}},Array[Range,#-1,3]-1]trả về danh sách lồng nhau { {1}, {0,1,2}, {0,1,2,3}, ..., {0,1,...,#} }. Sau đó Tuplestrả về tập hợp (được sắp xếp) của tất cả các bộ dữ liệu có phần tử đầu tiên nằm trong đó {1}, phần tử thứ hai nằm trong {0,1,2}, v.v. đây là những #số-số trong hệ thống đánh số này. Join@@Array[...,#]trả về một mảng gồm tất cả các số trong hệ thống đánh số này với nhiều #chữ số nhất và Part[...,#]trích xuất số #thứ tự như vậy.

Điều này là vô vọng chậm! Nó chạy tốt cho đầu vào lên đến 9. Đối với đầu vào lớn hơn, hãy kiểm tra nó bằng cách thay thế đầu cuối ,#],#]&bằng ,Ceiling[0.9Log[#]]],#]&; điều này đặt giới hạn thực tế hơn về số lượng chữ số cần thiết để đi đủ xa trong hệ thống đánh số để tìm ra chữ số chúng ta muốn.

Toán học, 93 byte

Nest[#/.{x___,y_}:>{x,y+1}//.x:{y___,z_:0,w_,v___}/;w>Tr[1^x]-Tr[1^{v}]:>{y,z+1,0,v}&,{0},#]&

Hàm thuần túy với đối số đầu tiên #. Nếu một số nguyên không âm được đưa ra, nó sẽ đưa ra danh sách các chữ số 0chính xác (thậm chí xử lý chính xác!).

Giải trình

Nest[f,expr,n]đưa ra kết quả của việc áp dụng fcho expr nthời gian. Trong trường hợp này, exprlà danh sách {0}và nlà số nguyên đầu vào #. Chức năng frất phức tạp:

# (* Starting with the input # *)
 /. (* Apply the following rule *)
   {x___,y_} (* If you see a list of the form {x___,y} *)
            :> (* replace it with *)
              {x,y+1} (* this *)
                     //. (* Now apply the following rule repeatedly until nothing changes *)
                        x:{y___,z_:0,w_,v___} (* If you see a list x starting with a sequence y of 0 or more elements, 
                                                 followed by an optional element z (default value of 0),
                                                 followed by an element w,
                                                 followed by a sequence v of 0 or more elements *)
                                             /; (* such that *)
                                               w>Tr[1^x]-Tr[1^{v}] (* w is greater than the length of x minus the length of {v} *)
                                                                  :> (* replace it with *)
                                                                    {y,z+1,0,v}& (* this *)

Perl 6 , 38 byte

{map({|[X] 1,|map ^*,3..$_},1..*)[$_]}

Lấy một số nguyên dương và đưa ra một danh sách các số nguyên biểu thị các chữ số.

Giải trình:

{                                    }  # a lambda

 map({                    },1..*)       # for each number length from 0 to infinity,
                                        # offset by 1 to avoid a +1 in next step...

           1,|map ^*,3..$_              # generate the digit ranges, e.g.:
                                        #     length 0  ->  (1)  # bogus, but irrelevant
                                        #     length 1  ->  (1)
                                        #     length 2  ->  (1, 0..2)
                                        #     length 3  ->  (1, 0..2, 0..3)
                                        #     length 4  ->  (1, 0..2, 0..3, 0..4)

       [X]                              # take the cartesian product

      |                                 # slip the results into the outer sequence

                                 [$_]   # Index the sequence generated this way

Pyth - 14 byte

Chỉ cần trả về nthgiá trị phù hợp với "mẫu nhỏ hơn giá trị địa điểm".

e.f.A.eghkbjZT

Phòng thử nghiệm .

Haskell, 65 byte

i(x:r)|x>length r=0:i r|1<2=1+x:r
i[]=[1]
reverse.(iterate i[]!!)

ităng số trong hệ thống số với các chữ số theo thứ tự đảo ngược. iteratetạo danh sách vô hạn của tất cả các số này bắt đầu bằng 0 được biểu thị bằng []. Sau đó, tất cả những gì còn lại phải làm là lấy ( !!) số yêu cầu và reversenó.

Dòng cuối cùng là một hàm, không phải là một định nghĩa hàm, vì vậy nó không thể xuất hiện như trong một tệp mã nguồn. Thay vào đó, chỉ đặt các dòng khác trong mã nguồn và sử dụng dòng cuối cùng tại trình thông dịch (hoặc liên kết hàm với tên bằng cách thêm vào f=dòng cuối cùng).

Ví dụ sử dụng:

*Main> reverse.(iterate i[]!!) $ 100
[1,0,0,3,5]

(8 byte có thể được lưu nếu [5,3,0,0,1]là một đại diện được phép của kết quả.)

Haskell, 49 byte

x=[1]:[n++[d]|n<-x,d<-[0..length n+1]]
(x!!).pred

Dòng đầu tiên là một định nghĩa phụ trợ và dòng thứ hai đánh giá một hàm. Nó nhận một số nguyên và trả về một danh sách các số nguyên. Hãy thử trực tuyến!

Giải trình

Tôi xác định xlà danh sách vô hạn các đại diện được đề cập trong văn bản thách thức; hàm chính chỉ làm giảm đối số và lập chỉ mục của nó thành x. Dòng đầu tiên hoạt động như thế này:

x=                     -- The list of lists x contains
 [1]:                  -- the list [1], followed by
 [n++[d]|              -- integer d appended to list n, where
  n<-x,                -- n is drawn from x, and
  d<-[0..length n+1]]  -- the new "digit" d is drawn from this range.

Bạn thấy điều đó xđược định nghĩa theo chính nó, nhưng Haskell là lười biếng, vì vậy đây không phải là một vấn đề.