Rễ kỹ thuật số (cũng là tổng kỹ thuật số lặp lại) của một số nguyên dương là giá trị (một chữ số) thu được từ một quá trình lặp lại của các chữ số, trên mỗi lần lặp sử dụng kết quả từ lần lặp trước để tính tổng một chữ số. Quá trình tiếp tục cho đến khi đạt được một số có một chữ số.

Ví dụ: gốc kỹ thuật số của 65536 là 7 , vì 6 + 5 + 5 + 3 + 6 = 25 và 2 + 5 = 7 .

Sắp xếp tất cả các gốc kỹ thuật số không có nhiều ý nghĩa, vì nó sẽ chỉ bắt đầu với vô số 1 giây.

Thay vào đó, chúng tôi sẽ tạo danh sách tất cả các số nguyên một chữ số cùng với các gốc kỹ thuật số của chúng, sau đó tất cả các số có hai chữ số cùng với các gốc kỹ thuật số của chúng, sau đó là ba, bốn, v.v.

Bây giờ, với mỗi danh sách đó, chúng tôi sẽ sắp xếp nó để tất cả các số nguyên có gốc kỹ thuật số 1 xuất hiện trước, sau đó tất cả các số nguyên có gốc kỹ thuật số là 2 , v.v. Việc sắp xếp sẽ ổn định, do đó danh sách các số nguyên có gốc kỹ thuật số nhất định phải theo thứ tự tăng dần sau khi sắp xếp.

Cuối cùng, chúng tôi sẽ ghép các danh sách này thành một chuỗi duy nhất. Chuỗi này sẽ bắt đầu với tất cả các số có một chữ số, sau đó tất cả các số có hai chữ số (được sắp xếp theo gốc kỹ thuật số của chúng), sau đó tất cả các số có ba chữ số, v.v.

Thử thách:

Hãy tích cực số nguyên n như là đầu vào, đầu ra và các n 'th số trong chuỗi mô tả ở trên. Bạn có thể chọn nếu danh sách là 0 -exexed của 1 -exexed.

Trình tự diễn ra như sau:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 19, 28, 37, 46, 55, 64, 73, 82, 91, 11, 20, 29 ... 
72, 81, 90, 99, 100, 109, 118, ... 
981, 990, 999, 1000, 1009, 1018, 1027, ...

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

Các trường hợp thử nghiệm được lập chỉ mục 1.

   n   f(n)  
   9      9
  10     10
  11     19
  40     13
  41     22
  42     31
  43     40
  44     49
  45     58
 600    105
 601    114
 602    123
 603    132
 604    141
 605    150
4050   1453
4051   1462
4052   1471
4053   1480
4054   1489
4055   1498

Dễ sao chép hơn:

n =    9, 10, 11, 40, 41, 42, 43, 44, 45, 600, 601, 602, 603, 604, 605, 4050, 4051, 4052, 4053, 4054, 4055, 
f(n) = 9, 10, 19, 13, 22, 31, 40, 49, 58, 105, 114, 123, 132, 141, 150, 1453, 1462, 1471, 1480, 1489, 1498

Làm rõ:

• Bạn không thể xuất tất cả n phần tử đầu tiên. Bạn có trách nhiệm chỉ ra các n 'th.
• Về mặt lý thuyết, mã phải hoạt động cho tất cả các số nguyên lên đến 10 ^ 9 , nhưng sẽ ổn nếu hết thời gian trên TIO (hoặc các trình thông dịch khác có giới hạn thời gian) cho các đầu vào lớn hơn 999 .
• Giải thích được khuyến khích.

Đó là môn đánh gôn , vì vậy mã ngắn nhất trong mỗi ngôn ngữ sẽ thắng! Đừng nản lòng với các giải pháp khác bằng ngôn ngữ bạn muốn chơi gôn, ngay cả khi chúng ngắn hơn những gì bạn có thể quản lý!

Python 2 , _{78 60 52 46} 45 byte

-6 byte nhờ GB .
-1 byte nhờ Jakob .

n=input()
b=10**~-len(`n`)
print~-b+n/b+n%b*9

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

Cuối cùng đạt đến một hình thức đóng, 1 chỉ mục.

Python 2 , 78 byte

Chỉ số 0.

d=10;k=1
exec'\nk+=9\nif k>d+7:k=d;d*=10\nif k>=d:k-=d/10*9-1'*input()
print k

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

Python 3 , 80 byte

f=lambda i,k=1:k>i and sorted(range(k//10,k),key=lambda n:n%-9)[i-k]or f(i,k*10)

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

1 chỉ mục. Đây là cách tốt nhất tôi có thể quản lý trong Python 3 (tốt, ngoại trừ 78-byter , là một cổng của giải pháp Python 2 của tôi bên dưới; tuy nhiên tôi nghĩ rằng cái này mát hơn nhiều). Các chương trình đầy đủ của Python 2 được ưu tiên cho thử thách cụ thể này, bởi vì input()cần chuyển đổi thành intPython 3 (+5 byte), execlà một hàm, chứ không phải là một câu lệnh (+2 byte) và /thực hiện phân chia số nguyên theo mặc định nếu các đối số của nó là số nguyên trong Py 2 (+1 byte), do đó, điều này chắc chắn ngắn hơn câu trả lời của ovs .

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

Thiết lập

f=lambda i,k=1:k>i and ... or f(i,k*10)

Điều này xác định hàm đệ quy f lấy một đối số nguyên i và một đối số khác, k , mặc định là 1 . Trong khi k ≤ i , hàm f trả về f (i, 10k) , nhân k với 10 mỗi lần cho đến khi nó trở nên lớn hơn i .

Phạm vi mục tiêu và lập chỉ mục chính xác

...range(k//10,k)...[i-k]

Sau tập hợp hoạt động này, chúng ta còn lại i , đầu vào ban đầu và biến k đại diện cho công suất nhỏ nhất bằng 10 lớn hơn i . Bằng cách này, chúng tôi có thể tạo phạm vi (số nguyên) [tầng (k / 10), k) , về cơ bản bao gồm tất cả các số nguyên là:

• lớn hơn hoặc bằng công suất cao nhất 10 nhỏ hơn hoặc bằng i
• nhỏ hơn k , công suất nhỏ nhất bằng 10 lớn hơn i

Vì chúng tôi bỏ qua các số nguyên nhỏ hơn x = floor (k / 10) , chúng tôi phải thay đổi chỉ mục để chúng tôi tính đến các số còn thiếu. Cách rõ ràng là trừ số đếm của họ, x , từ i , để chúng tôi lập chỉ mục vào danh sách (sau khi sắp xếp, được mô tả bên dưới), do đó có ix . Tuy nhiên, kể từ khi danh sách chứa 9k / 10 , các mục, và lập chỉ mục trong một danh sách tại chỉ số -y đối với một số dương y mang lại những y ^thứ yếu tố từ ngày kết thúc bằng Python, điều này chỉ đơn giản là tương đương với chỉ mục với ik , do đó tiết kiệm 4 byte.

Sắp xếp từng đoạn theo gốc kỹ thuật số

sorted(...,key=lambda n:n%-9)

Công thức cho hàm gốc kỹ thuật số là 1 + ((n-1) mod 9) (xem phần công thức Congruence của bài viết Wikipedia này ). Vì 1 cách này sẽ được thêm vào mỗi người trong số họ, điều này là không cần thiết khi sắp xếp, vì vậy chúng tôi còn lại với (n-1) mod 9 . Cách %toán tử của Python hoạt động khi được cung cấp số âm trên RHS rất thuận tiện, vì chúng ta có thể sử dụng n pymod -9 thay vào đó để lưu byte bao phấn.

Python 2 , 72 byte

Lấy cảm hứng từ đệ trình của Chas Brown .

lambda i:sorted(range(1,10**len(`i`)),key=lambda n:(len(`n`),n%-9))[i-1]

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

Python 2 , 73 71 70 byte

lambda n:sorted(range(10**len(`n`)),key=lambda i:(len(`~i`),i%9))[n]+1

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

2 byte thx cho ông XCoder ; và 1 byte thx cho H.PWiz .

Đây là 0 chỉ mục.

Thạch ,  15 14 10  9 byte

D,Ḣ$‘Ḍḅ9’

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

Làm sao?

Sử dụng một phiên bản golf của giải pháp dạng đóng được tạo bởi các ô trong câu trả lời Python của họ ...

Công thức được tiếp xúc bởi các lò nướng là: 9 * (n% b) + (n / b) + b - 1 trong đó b = 10 ^{tầng (log (n, 10))}

Bây giờ nếu c là số chữ số thập phân của n thì b-1 là số thập phân c-1 .
Điều này giống như chín lần giá trị của c-1 trong số thập phân (ví dụ 111*9=999).

Hơn nữa, n / b là chữ số hàng đầu của n và n% b là phần còn lại của các chữ số dưới dạng số thập phân.

Một công thức như b * x + y có thể được thực hiện dưới dạng chuyển đổi [x,y]từ cơ sở b
(tức là b ^ 1 * x + b ^ 0 * y = b * x + y )

Như vậy, chúng ta có thể lấy một số, n (ví dụ 7045), chia nó thành các chữ số hàng đầu và dấu, đặt chữ số hàng đầu ở cuối ( [[0,4,5],7]), thêm một vào tất cả các chữ số của mục đầu tiên để phục vụ cho việc thêm b-1 ( [[1,5,6],7]) chuyển đổi chúng từ danh sách thập phân sang số nguyên ( [156,7]) và chuyển đổi từ danh sách cơ sở chín ( 1411).

Trong phần triển khai bên dưới, chúng tôi thêm một vào tất cả các chữ số của cả hai mục khi phục vụ cho b-1 ( [[0,4,5],8]), chuyển đổi từ danh sách thập phân sang số nguyên ( [156,8]), chuyển đổi từ cơ sở chín ( 1412) và sau đó trừ đi quy trình này được thêm vào ( 1411).

D,Ḣ$‘Ḍḅ9’ - Link: positive integer, n    e.g. 4091
D         - to base ten                       [4, 0, 9, 1]
   $      - last two links as a monad:
  Ḣ       -   head (modifies the list too)    4
 ,        -   pair (the modified list) with   [[0, 9, 1], 4]
    ‘     - increment (vectorises)            [[1, 10, 2], 5]
     Ḍ    - from base ten (vectorises)        [202, 5] (since 1*10^2+10*10^1+2*10^0 = 100+100+2 = 202)  
      ḅ9  - convert from base 9               1823 (since 202*9^1 + 5*9^0 = 202*9 + 6*9 = 1818 + 5 = 1823)
        ’ - decrement                         1822

Trước đó, 14 byter:

æċ⁵DL,’%9ƊƲÞị@

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

Cái này xây dựng danh sách lên tới lũy thừa 10 trên đầu vào bằng cách sắp xếp các số tự nhiên này [digitalRoot, digitCount]sau đó tìm giá trị ở chỉ số được nhập.

Haskell , 94 88 byte

([n|x<-[0..],i<-[1..9],n<-[10^x..10^(x+1)-1],until(<10)(sum.map(read.pure).show)n==i]!!)

Hãy thử trực tuyến! Chỉ số 0.

Giải trình:

Việc hiểu danh sách tạo ra chuỗi dưới dạng danh sách vô hạn mà chúng tôi lập chỉ mục với !!:

• x là một ít hơn số chữ số hiện tại và được rút ra từ danh sách vô hạn [0,1,2,3, ...]
• ilặp đi lặp lại trong phạm vi từ 1đến 9và được sử dụng để sắp xếp theo các gốc kỹ thuật số
• nlặp đi lặp lại trên tất cả các số có x+1chữ số
• until(<10)(sum.map(read.pure).show)tính toán gốc kỹ thuật số ( xem ở đây để giải thích )
• nđược thêm vào danh sách nếu gốc kỹ thuật số của nó bằng i.

Võng mạc , 65 byte

.
9
.+
*
L$`
$`
O$`_(_{9})*(_*)
$2
_+
$.&
N$`
$.&
"$+L`^|\d+"^~G`

Hãy thử trực tuyến! 1 chỉ mục. Giải trình:

.
9
.+
*
L$`
$`

Xây dựng danh sách các dòng _s từ 0 cho đến lũy thừa 10 (độc quyền).

O$`_(_{9})*(_*)
$2

Sắp xếp tất cả theo thứ tự gốc kỹ thuật số.

_+
$.&

Chuyển đổi từ unary sang thập phân.

N$`
$.&

Sắp xếp chúng theo thứ tự chiều dài.

"$+L`^|\d+"^~G`

Trích xuất nphần tử thứ.

Pyth ,  36 31 25 24 23  22 byte

1 chỉ mục.

@o%tN9rFK^LThBlt`Q-QhK

Bộ thử nghiệm!

Cách thức hoạt động (lỗi thời)

@smo%tN9dcU^TKhs.lQT^LTSK – Full program. Q = input.
             Khs.lQT      – Take floor(log10(Q))+1 and store it in K.
          U^T             – Generate [0 ... T^K).
         c                – Cut at locations...
                    ^LTSK – Of the powers of 10 less than K.
  m     d                 – Map over those.
   o  N                   – Sort them by...
    %t 9                  – Themselves decremented, modulo 9.
@s                        – Flatten the result and retrieve the Q'th entry.

05AB1E , 19 11 byte

Cổng câu trả lời Python của tôi .

-6 byte (!) Nhờ Kevin Cruijssen .

g<°©‰`9*®O<

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

Code           Explanation            Stack
               implicit input         [n]
g              length                 [len(n)]
 <             decrement              [len(n)-1]
  °            10 ** a                [10**(len(n) - 1)]
   ©           store value            [10**(len(n) - 1)]
    ‰          divmod                 [[n // 10**(len(n) - 1), n % 10**(len(n) - 1)]]
     `         push items to stack    [n // 10**(len(n) - 1), n % 10**(len(n) - 1)]
      9*       multiply by 9          [n // 10**(len(n) - 1), n % 10**(len(n) - 1) * 9]
        ®      retrieve value         [n // 10**(len(n) - 1), n % 10**(len(n) - 1) * 9, 10**(len(n) - 1)]
         O     sum the stack          [n // 10**(len(n) - 1) + n % 10**(len(n) - 1) * 9 + 10**(len(n) - 1)]
          <    decrement              [n // 10**(len(n) - 1) + n % 10**(len(n) - 1) * 9 + 10**(len(n) - 1) - 1]
               implicit output

Bình thường , 23 byte

@o%tN9rF_mJ^TsdtBl`Q-QJ

Hãy thử nó ở đây.

-3 cảm ơn ông Xcoder

1 chỉ mục.

Perl 6 ,  68  58 byte

{({|(10**$++..^10**++$).sort({({.comb.sum}…*==*).tail})}…*)[$_]}

Kiểm tra nó dựa trên 0

{sort({.chars,({.comb.sum}…*==*).tail},^10**.chars)[$_]}

Kiểm tra nó dựa trên 1

Mở rộng:

{  # bare block lambda with implicit parameter $_

  sort(
    {
      .chars,         # sort by the length first

      (  # generate sequence to find digital sum

        { .comb.sum } # one round of digital sum
        … * == *      # stop when the digital sum matches itself (1..9)

      ).tail          # get the last value
    },

    ^                 # Range up to (and excluding)
      10 ** .chars    # the next power of 10

  )[ $_ ] # index into the sequence
}

Ruby , 43 38 byte

->x{9*(x%b=10**~-x.to_s.size)+x/b+b-1}

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

Ban đầu là một cổng của câu trả lời Python tuyệt vời của ovs, sau đó đơn giản hóa một số chi tiết.

Java 8, 68 byte

n->{int b=(int)Math.pow(10,(n+"").length()-1);return~-b+n/b+n%b*9;}

Cổng nhàm chán trong câu trả lời Python 2 của @ovs , vì vậy hãy đảm bảo nâng cấp anh ta!
-1 byte nhờ @Jakob

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

K4 , 38 byte

Dung dịch:

-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:

Ví dụ:

q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:40
13
q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:601
114
q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:4051
1462

Giải trình:

Giải pháp của cảng Jonathan Allan khi tôi hết bộ nhớ xây dựng các gốc kỹ thuật số từ 1 đến 1e9.

-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\: / the solution
                                  10\: / convert to base 10
                                1+     / add 1
                              x:       / save as x
                             #         / take from x
                     (      )          / do together
                          #x           / count x
                        c:             / save as c
                      1+               / add 1
                   1_                  / drop the first
                  _                    / cut at these indices
           ( ;   )                     / 2-item list
              c-1                      / length - 1
            0                          / .. zero
      10/:'                            / convert each from base 10
   9/:                                 / convert from base 9
-1+                                    / subtract 1

Tiền thưởng:

Dịch giải pháp của lò nướng đơn giản hơn nhưng dài hơn:

-1+b+/1 9*(_%;.q.mod).\:x,b:10 xexp#1_$x:

Thạch , 19 byte

æḟ©ræċɗ⁵Ṗ%Þ-9⁸‘_®¤ị

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

-1 cảm ơn ông Xcoder .

1 chỉ mục.

J, 24 byte

(]/:([:+/[:".&>":)^:_"0)

Đây ngầm biểu hiện được bọc trong dấu ngoặc để biểu thị rằng nó cần được điều trị ngày của riêng mình chứ không phải là một phần của bất kỳ biểu hiện sau (giống như các đối số).

Cụm từ '] /:' thứ tự (tăng dần '/:') mảng ban đầu ']' bằng tổng '+ /' của các chữ số Biểu thức

". &> ":

chuyển đổi một số thành một vectơ ký tự với '":', sau đó áp dụng nghịch đảo của nó '".' - ký tự thành số - áp dụng cho từng mục '&>'. Vì vậy, 65536 -> '65536' -> 6 5 5 3 6.

Kết hợp sức mạnh '^:' gần cuối biểu thức áp dụng mã chúng tôi vừa giải thích (ở bên trái) một số lần được chỉ định. Trong trường hợp này, số lần được chỉ định là vô hạn '_' có nghĩa là tiếp tục áp dụng cho đến khi kết quả ngừng thay đổi.

Chữ "0" cuối cùng có nghĩa là áp dụng toàn bộ biểu thức ở bên trái cho mỗi mục vô hướng (0 chiều) ở bên phải, đây sẽ là mảng các số mà chúng tôi muốn áp dụng điều này.

Thuốc tiên , 239 byte

q=:math
e=Enum
r=fn x,f->cond do
x<10->x
1->f.(e.sum(Integer.digits x),f)end end
fn p->e.at(e.at(Stream.unfold({0,[0]},fn {a,c}->{c,{a+1,c++e.sort(trunc(q.pow 10,a)..trunc(q.pow 10,a+1)-1,&r.(&1,r)<=r.(&2,r))}}end),1+trunc q.log10 p),p)end

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

Giải thích đến (từ từ)! Tôi không nghĩ nó có thể ngắn hơn thế này nhiều, nhưng tôi luôn cởi mở với các đề xuất

Perl 5 -pF , 27 byte

$_=9x$#F+$_%10**$#F*9+$F[0]

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

Sử dụng công thức của @ ovs và các giải thích của @ JonathanAllen để đưa ra một đoạn mã nhỏ gọn đẹp mắt.