Hầu hết các máy tính lưu trữ số nguyên ở dạng nhị phân, nhưng xuất chúng dưới dạng thập phân. Tuy nhiên, thập phân chỉ là một đại diện, chúng tôi chỉ tình cờ tìm thấy nó thuận tiện.

Thách thức này là viết một số mã để xuất ra một giá trị số nguyên dưới dạng thập phân shortlex .

Cái gì vậy
http://en.wikipedia.org/wiki/Shortlex_order

Shortlex lấy độ dài của dãy số là ký hiệu chính của giá trị. Chuỗi, bắt đầu từ một chuỗi rỗng biểu thị số 0, là ...

ε,0,1,...,8,9,00,01,...98,99,000,001,...,998,999,0000,...

(Hãy nghĩ về các cột Excel, nhưng chỉ sử dụng các chữ số thập phân.)

Viết chương trình hoặc hàm chấp nhận một số nguyên và trả về một chuỗi tương ứng với biểu diễn thập phân ngắn của số nguyên đó như được mô tả ở trên.

Giá trị thử nghiệm:

0 → "" (Chuỗi trống)
1 → "0"
10 → "9"
11 → "00"
42 → "31"
100 → "89"
800 → "689"
1060 → "949"
10270 → "9159"
100501 → "89390"

JavaScript (ES6) 42 74

n=>(n-~(n+'').replace(/./g,8)+'').slice(1)

Kiểm tra trong bảng điều khiển FireFox

;[0,1,10,11,42,100,800,1060,10270,100501]
.forEach(x => console.log(x +" -> '" + S(x) + "'"))

Đầu ra

0 -> ''
1 -> '0'
10 -> '9'
11 -> '00'
42 -> '31'
100 -> '89'
800 -> '689'
1060 -> '949'
10270 -> '9159'
100501 -> '89390'

Làm thế nào tôi nghĩ về điều này?

Cho một số chữ số cố định, chuỗi đầu ra chỉ đơn giản là tăng dần, do đó có một delta cố định giữa đầu vào và đầu ra. Có một cái nhìn:

  1..10 -> 0..9 (delta -1)
 11..110 -> 00..99 (delta -11)
111..1110 -> 000..999 (delta -111) mmm there's a pattern here...

Nhưng các số 0 hàng đầu rất khó quản lý, vì vậy tôi có một mẹo tiêu chuẩn, thêm một chữ số đầu tiên và modulo làm việc (nghĩa là cắt chữ số đầu tiên trong đầu ra). Sau đó -1-> +9, -11 -> +89, -111 -> +889, v.v.
Bước cuối cùng: Tôi không quan tâm chữ số đầu tiên là gì, vì vậy không cần kiểm tra xem số iinput có phải là <hoặc> hơn 111 hay không (thật lòng tôi đã tìm thấy số này bằng cách dùng thử và lỗi)

Kiểm tra

var F=
n=>(n-~(n+'').replace(/./g,8)+'').slice(1)

function update()
{
  var i=+I.value
  O.textContent = F(i)
}


update()

<input id=I value=99 type=number oninput='update()'><pre id=O></pre>

Tuyệt vời 177 173 170

@0@6000000@5
}0&0&0&0&0
>0@6&3
\\--\/&2
@0/\@4\/&1!!
@4@1..@2@5@3
IIIIIIIIIIII
FF&1FF&2FF&3
@1OO@2OO@3OO
:I
}1..}10001F7
=9&1++..&1&0
&0}0&1&0{1{1
{>\/{0//
:O
}0
+Z
+C
{0

Nó chỉ hoạt động cho các giá trị dưới 256 vì Marbelous là ngôn ngữ 8 bit.

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

Marbelous là một ngôn ngữ 2D với các giá trị được biểu thị bằng các viên bi 8 bit rơi xuống một ô trên mỗi dấu trừ khi một số thiết bị ngăn chúng rơi xuống. Chương trình đáng tin cậy này bao gồm 3 bảng; Hãy bắt đầu với cách dễ nhất:

:O
}0
+Z
+C
{0

:Olà tên của bảng (chính xác là O là tên và: nói với người được giải thích rằng dòng này là tên. Bằng cách đặt tên cho bảng, các bảng khác có thể gọi chúng }0là một thiết bị đầu vào, đây có thể được xem là một đối số của hàm này. Ô này sẽ được thay thế bằng một viên bi (giá trị) đầu vào khi hàm được gọi. +Zthêm 35 vào bất kỳ viên bi nào đi qua nó và cho phép nó rơi qua. +CKhông giống nhau nhưng chỉ thêm 12. {0là một ô đầu ra , khi một viên bi đến ô này, hàm sẽ thoát và trả về giá trị trong thiết bị đầu ra này.

Vì vậy, tất cả cùng nhau, bảng này lấy một giá trị và sau đó thêm 47 vào nó. Đối với chúng tôi, điều này có nghĩa là nó biến bất kỳ số nào có một chữ số thành mã ascii của chữ số -1 (tất nhiên điều này cũng sẽ hoạt động trong 10).

:I
}1 .. }1 00 01 F7
=9 &1 ++ .. &1 &0
&0 }0 &1 &0 {1 {1
{> \/ {0 //

Bảng này có vẻ phức tạp hơn một chút. Bạn sẽ có thể xác định :Ilà tên của bảng và đã phát hiện ra một số thiết bị đầu vào và đầu ra. Bạn sẽ nhận thấy rằng chúng tôi có hai thiết bị đầu vào khác nhau, }0và }1. Điều này có nghĩa là chức năng này mất 2 đầu vào. Bạn cũng sẽ nhận thấy rằng có hai phiên bản của }1thiết bị. Khi gọi hàm, cả hai ô này sẽ chứa cùng một giá trị. Các }0thiết bị đầu vào trực tiếp trên một \/thiết bị, điều này đóng vai trò như một thùng rác và loại bỏ bất kỳ bằng đá cẩm thạch rơi khi nó ngay lập tức.

Chúng ta hãy xem những gì xảy ra với một trong những viên bi được đưa vào bảng bởi các }1thiết bị đầu vào:

}1
=9 &1
&0
{>

Nó sẽ rơi xuống đánh dấu đầu tiên và đánh vào =9thiết bị. Điều này so sánh giá trị của đá cẩm thạch với 9 và cho phép viên bi rơi qua nếu câu lệnh =9ước lượng xuyên qua. Đá cẩm thạch được đẩy sang phải nếu không. &0và &1là đồng bộ hóa. Họ giữ những viên bi rơi vào chúng cho đến khi tất cả các &nđồng bộ hóa khác cũng được lấp đầy. Như bạn có thể mong đợi, điều này sẽ có điều kiện kích hoạt các hành vi khác nhau trên một số phần khác của bảng.

}1 00 01 F7
++ .. &1 &0
&1 &0 {1 {1
{0 //

Nếu tôi nói với bạn rằng đó ++là một bộ tăng, bạn đã có thể cho biết những gì các bộ đồng bộ hóa khác nhau sẽ được lấp đầy. Bên trái &1sẽ chứa giá trị đầu vào }1+ 1, &0bên cạnh nó sẽ chứa 0 ( 00là một ngôn ngữ, được biểu thị dưới dạng thập lục phân). Cái thứ hai &1sẽ chứa giá trị 1 và bên phải &0được điền bằng một F7, trừ 9 từ một giá trị vì phép cộng trong Marbelous là modulo 256.

// là một thiết bị làm lệch hướng, đẩy bất kỳ viên bi nào sang trái thay vì để nó rơi xuống.

Đặt tất cả những thứ này lại với nhau mang lại cho bạn điều này: nếu viên bi trong }1là 9, các &0bộ đồng bộ hóa sẽ được lấp đầy. Điều này sẽ khiến giá trị 0 rơi vào {0đầu ra và F7(hoặc -9) vào {1đầu ra. Nếu }1không phải là 9, {0sẽ được điền }1+ 1 và {0sẽ chứa 1. Ngoài ra còn có một {>thiết bị, đây là một đầu ra đặc biệt tạo ra một viên bi bên cạnh một bảng thay cho bên dưới nó. Điều này sẽ được điền với }1nếu nó bằng 9.

@0 @6 00 00 00 @5
}0 &0 &0 &0 &0
>0 @6 &3
\\ -- \/ &2
@0 /\ @4 \/ &1 !!
@4 @1 .. @2 @5 @3
II II II II II II
FF &1 FF &2 FF &3
@1 OO @2 OO @3 OO

Được rồi, bây giờ cho một lớn. Bảng này không có tên rõ ràng, vì nó là bảng chính của tệp. Tên ngầm của nó là Mb. Bạn sẽ có thể nhận ra một số tế bào. Có một thiết bị đầu vào, một số ngôn ngữ ( 00và FF). Có một số đồng bộ hóa và có một bộ làm lệch hướng. hãy bước qua mảnh này bằng mảnh.

@0 @6
}0 &0
>0 @6
\\ --
@0 /\ @4

Vì vậy, giá trị đầu vào (đầu vào dòng lệnh vì đây là bảng chính) bắt đầu từ ô thứ hai từ đỉnh }0được đặt. Nó sẽ rơi xuống và tiếp cận >0thiết bị, đó là một thiết bị so sánh khác. bất kỳ viên bi nào lớn hơn 0 rơi xuống, bất kỳ viên bi nào khác đều bị đẩy sang phải. (vì các biến Marbelous không được ký, chỉ chính xác 0 sẽ được đẩy sang phải). Đá cẩm thạch có giá trị bằng không này sau đó sẽ đạt@6 thiết bị. Đây là một cổng thông tin và vận chuyển đá cẩm thạch đến một cổng thông tin tương ứng khác, trong trường hợp này ngay trên nó. Đá cẩm thạch 0 sau đó sẽ đạt đến &0bộ đồng bộ hóa và kích hoạt một số thứ ở nơi khác.

Nếu viên bi không bằng 0, nó rơi xuống, bị lệch về bên phải bởi các \\cú đánh --làm giảm nó một cái và sau đó rơi xuống /\, một người nhân bản. Thiết bị này lấy một viên bi và xuất ra một bản sao của nó ở bên phải và một bản bên trái. Một bên trái sẽ được đưa lên trên đến @0nơi khác , nơi đá cẩm thạch sẽ đi qua cùng một trình tự một lần nữa. Một bên trái sẽ được đưa đi nơi khác. Điều này cung cấp cho chúng ta một vòng lặp, làm giảm đầu vào dòng lệnh một lần trên mỗi vòng lặp và kích hoạt một số hành vi trên mỗi vòng lặp cho đến khi đạt đến 0. Sau đó, nó kích hoạt một số hành vi khác.

Chúng ta hãy xem những gì xảy ra với đá cẩm thạch được đẩy vào @4mỗi vòng.

@4 @1 .. @2 @5 @3
II II II II II II
FF &1 FF &2 FF &3
@1 OO @2 OO @3 OO

Có 3 ngôn ngữ ở đây ( FF), sẽ ngay lập tức rơi vào cổng. Các cổng này sẽ đưa họ đến ba trong số các IIthiết bị. IIđề cập đến bảng :Ichúng tôi xác định thêm xuống tập tin. Vì :Icó 2 thiết bị đầu vào riêng biệt, đại diện của nó trên một bảng khác phải rộng 2 ô. Vì chúng tôi có 6 ô chứa II, chúng tôi cam nói rằng chúng tôi có 3 trường hợp của chức năng này trên bảng.

Các FFviên bi (hoặc 256 hoặc -1 nếu bạn sẽ) sẽ nằm trong các ô đầu vào của :Ihàm chờ cho đến khi có đủ đá cẩm thạch đầu vào bắt đầu chức năng (thêm một viên nữa). Đó là nơi@4 cổng thông tin xuất hiện. Một bản sao của đầu vào dòng lệnh giảm dần rơi vào đó trên mỗi vòng lặp. Điều này sẽ kích hoạt :Ibảng ngoài cùng bên trái . Ban đầu với các giá trị 256 (hoặc -1) và bất kể đầu vào dòng lệnh là -1. Đá cẩm thạch bên trái sẽ được đưa vào các }0thiết bị của :Ibảng và một bên phải vào }1. Nếu bạn nhớ lại những gì bảng này đã làm, bạn sẽ có thể cho biết kết quả này có gì. Nó sẽ xuất ra một phiên bản tăng dần của đầu vào bên phải ở đầu ra bên trái (và nó biến 9 thành 0, không phải 10) và xuất ra 1 hoặc -9 ở bên phải.

Giá trị gia tăng sẽ được đưa trở lại ô nhập vào bên phải bởi một cổng và giá trị bên phải rơi vào bộ đồng bộ hóa. Nếu một bộ đồng bộ hóa đang giữ một viên bi, hai viên bi sẽ va chạm vào nhau. Các viên bi va chạm được thêm vào modulo 256. Vì vậy, các giá trị trong bộ đồng bộ sẽ thực hiện theo sau: Chúng bắt đầu trống, sau đó chuyển sang 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, và sau đó 1 lần nữa (kể từ khi được thêm modulo 256).

Bạn cũng có thể nhớ rằng một viên bi sẽ xuất ra bên phải khi giá trị đầu vào lặp lại 0. Vì các :Ibảng nằm ngay cạnh nhau, thsi sẽ kích hoạt bảng ở bên phải một lần. Điều này sẽ lấp đầy ba bộ đồng bộ hóa với các giá trị cao hơn một giá trị sẽ là một biểu diễn shortlex của đầu vào dòng lệnh, tại thời điểm này đã lặp xuống 0.

Bạn cũng có thể nhớ rằng :Ohàm biến một giá trị thành giá trị ascii của chữ số đại diện cho giá trị -1. Đầu ra của các OOô này sau đó sẽ rơi ra khỏi bảng, in ra các ký tự ascii tương ứng của chúng thành STDOUT.

00 00 00 @5
&0 &0 &0
&3
\/ &2
   \/ &1 !!
      @5

Vì vậy, điều gì xảy ra khi dòng lệnh đầu vào cẩm thạch đạt 0 và điền vào &0bộ đồng bộ hóa đó ? tốt, một vài viên bi giá trị 0 rơi xuống và kích hoạt ba bộ đồng bộ hóa đang giữ các chữ số (+ 1) của số shortlex ở dưới cùng của bảng. &3được kích hoạt đầu tiên, vì nó chứa chữ số có ý nghĩa nhất, sau đó được &2theo sau &1. Đá cẩm thạch này sau đó được dịch chuyển đến @5thiết bị khác trước khi cuối cùng chạm vào !!tế bào, làm chấm dứt bảng.

CJam, 14 11 byte

l40f-Ab)s1>

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

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

Cách tiếp cận này chủ yếu dựa trên câu trả lời của edc65 (với sự cho phép rõ ràng của anh ấy ):

" Read a line L from STDIN. ";

l

" edc65's answer now forms an integer N by replacing each digit in L by an 8 and computes
  L - ~N = L + N + 1. Instead of adding L and N, we subtract 40 from each char code of L.
  Since the char code of the digit `D` is `D + 48`, this basically adds 8 to each digit.  ";

40f-

" Turn the resulting array into an integer by considering its elements a base 10 number.
  This is implemented as A ↦ A[-1] + 10 * A[-2] + 100 * A[-3] + ⋅⋅⋅, so it won't choke
  on digits greater than the base.                                                        ";

Ab

" Increment the integer on the stack to complete the calculation of L + N + 1.            ";

)

" Push the integers string representation and discard its first character.                ";

s1>

Chạy ví dụ

$ for i in 0 1 10 11 42 100 800 1060 10270 100501
> do echo $i: $(cjam <(echo 'l40f-Ab)s1>') <<< $i)
> done
0:
1: 0
10: 9
11: 00
42: 31
100: 89
800: 689
1060: 949
10270: 9159
100501: 89390

Con trăn 2 (38) (43)

f=lambda n:n*'_'and f(~-n/10)+`~-n%10`

Không thay thế nhân vật, chỉ là số học.

Ung dung:

def f(n):
    if n==0: return ''
    else: return f((n-1)//10) + str((n-1)%10)

Tôi không có lý do chính đáng tại sao đệ quy hoạt động, tôi chỉ phù hợp với mẫu này vào danh sách các giá trị. Nếu bạn đã thay đổi từng n-1đếnn , bạn sẽ có được đại diện chữ số thông thường.

Đối với việc chơi golf, tôi sử dụng ~-nđể tính toán n-1với mức độ ưu tiên cao hơn /10hoặc %10, tiết kiệm tiền. Đây n*'_'chỉ là để tạo ra chuỗi trống khi n=0và bất kỳ chuỗi nào khác. Có '_'thể là bất kỳ chuỗi cho mục đích này.

Ruby, 70 68 66 64 57 byte

f=->n{i=-1;n-=10**i while n>=10**i+=1;i<1?'':"%0#{i}d"%n}

Xác định một chức năng được gọi là như thế f[42]. Đây là sự cố sơ bộ của thuật toán:

• Điều trị 0riêng.
• Trừ đi sức mạnh của 10 cho đến khi sức mạnh tiếp theo của 10 không còn phù hợp với con số nữa.
• Biến số thành một chuỗi được đệm bằng số 0 ở bên trái.

Tín dụng cho ý tưởng sử dụng chuỗi định dạng đi đến Falko!

Ngoài ra, sử dụng phương pháp của edc65:

f=->n{"#{n-~n.to_s.tr('^.',?8).to_i}"[1..-1]}

Đó là 45 byte và tôi chỉ bao gồm nó, bởi vì tôi không đánh bại anh ta với nó. ;)

Haskell, 67 byte

n('9':x)='0':n x
n(c:x)=succ c:x
n""="0"
f x=reverse$iterate n""!!x

giải pháp này về cơ bản thêm 1 số lần cho trước, theo ký hiệu shortlex.

sử dụng:

>f 9
"8"
>f 100
"89"

CJam, 16 byte

li_)9*,{`1>}%_&=

Hãy thử trực tuyến. Yêu cầu ít nhất O (n) thời gian và bộ nhớ, vì vậy hãy để lại 100501 cho trình thông dịch ngoại tuyến ...

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

Ý tưởng cơ bản đằng sau phương pháp này là tính toán ít nhất N số thập phân theo thứ tự tự nhiên và loại bỏ tất cả trừ Nth. Không hiệu quả lắm, nhưng ngắn.

li                " Read an integer N from STDIN.                                   ";
  _)9*            " Push M := (N + 1) * 9.                                          ";
      ,           " Push A := [ 0 1 ... M - 1 ].                                    ";
       {   }%     " For each I ∊ A:                                                 ";
       {`1>}%     " Push its string representation and discard the first character. ";
             _&   " Remove duplicates from the resulting array.                     ";
               =  " Retrieve the Nth element.                                       ";

Chạy ví dụ

$ for i in 0 1 10 11 42 100 800 1060 10270 100501
> do echo $i: $(cjam <(echo 'li_)9*,{`1>}%_&=') <<< $i)
> done
0:
1: 0
10: 9
11: 00
42: 31
100: 89
800: 689
1060: 949
10270: 9159
100501: 89390

Bash + coreutils, 27 byte

Câu trả lời thông minh của cảng @ edc65 , với những cải tiến của @ Dennis :

cut -b2-<<<$[$1-~${1//?/8}]

Đầu ra:

$ for n in 0 1 10 11 42 100 110 111 800 1060 1110 1111 10270 100501; do echo "./shortlex.sh $n = \"$(./shortlex.sh $n)\""; done
./shortlex.sh 0 = ""
./shortlex.sh 1 = "0"
./shortlex.sh 10 = "9"
./shortlex.sh 11 = "00"
./shortlex.sh 42 = "31"
./shortlex.sh 100 = "89"
./shortlex.sh 110 = "99"
./shortlex.sh 111 = "000"
./shortlex.sh 800 = "689"
./shortlex.sh 1060 = "949"
./shortlex.sh 1110 = "999"
./shortlex.sh 1111 = "0000"
./shortlex.sh 10270 = "9159"
./shortlex.sh 100501 = "89390"
$ 

Câu trả lời trước:

Bash + coreutils, 71 54 byte

Đây là một cách hơi khác để làm điều đó:

jot -w%x $1$1|tr 0-9a a0-9|grep -P ^\\d+$|sed $1!d 2>-

• jot đầu ra tăng số nguyên thập lục phân
• tr chuyển đổi này thành (0,1, ..., 8,9, b, ... f, 0a, 00,01, ..., 99,9b, ..., ff, 0aa, ..., 000 , ...)
• grep chỉ cần lọc tất cả các dòng chứa chữ số để cung cấp (0,1, ..., 8,9,00, ..., 99.000 ....)
• sed xóa tất cả trừ dòng thứ n
• STDERR được chuyển hướng đến một tệp vứt đi '-' để chúng ta chỉ cần lấy chuỗi trống khi 0 được truyền vào ( sedđếm số dòng bắt đầu từ 1, do đó lỗi nếu 0 được thông qua)
• Bởi vì chúng tôi đang lọc các số với grep, chúng tôi cần tạo ra nhiều số nguyên cơ sở 11 với seq/ dchơn số đầu vào. Lặp lại các chữ số của n là quá đủ.

Lưu ý rằng một khi số shortlex được in, tôi seqtiếp tục tạo ra các số lên đến $1$1, đặc biệt là chậm đối với các số đầu vào lớn hơn - O (n²), tôi nghĩ vậy. Chúng tôi có thể tăng tốc bằng cách seqthoát ngay lập tức sau khi in với chi phí 7 byte:

jot -w%x $1$1|tr 0-9a a0-9|grep -P ^\\d+$|sed -n $1{p\;q} 2>-

Không có yêu cầu về tốc độ trong câu hỏi, vì vậy tôi sẽ sử dụng phiên bản ngắn hơn cho câu trả lời chính của mình.

Con trăn 2 - 84, 70 66

n=input()
i=0
while n>=10**i:n-=10**i;i+=1
print"%%0%dd"%i%n*(i>0)

Cách tiếp cận khác (cùng chiều dài):

n=input()
k=len(`9*(n+1)/10`)
print"%%0%dd"%k%(n-int('1'*k))*(n>0)

Python 3, 107 ký tự

Điều này đã không kết thúc chiến thắng nhưng tôi nghĩ rằng nó là thông minh:

def G():yield'';yield from(r+c for r in G()for c in'0123456789')
S=lambda n:list(zip(range(n+1),G()))[n][1]

Tôi xác định một trình tạo cho toàn bộ chuỗi trong 64 ký tự. Thật không may, tôi phải trải qua một số mâu thuẫn để có được phần tử thứ n của trình tạo ... nếu tôi có thể làm được S=lambda n:G()[n].

Bình 12 tháng 12

Một cổng khác của câu trả lời của @ edc65, ai là người chiến thắng rõ ràng (IMO):

t`+hQv*l`Q\8

Gói thử nghiệm (Cảm ơn @DigitalTrauama):

$ for n in 0 1 10 11 42 100 110 111 800 1060 1110 1111 10270 100501; do echo "shortlex.pyth $n = \"$(pyth programs/shortlex.pyth <<< $n)\""; done
shortlex.pyth 0 = ""
shortlex.pyth 1 = "0"
shortlex.pyth 10 = "9"
shortlex.pyth 11 = "00"
shortlex.pyth 42 = "31"
shortlex.pyth 100 = "89"
shortlex.pyth 110 = "99"
shortlex.pyth 111 = "000"
shortlex.pyth 800 = "689"
shortlex.pyth 1060 = "949"
shortlex.pyth 1110 = "999"
shortlex.pyth 1111 = "0000"
shortlex.pyth 10270 = "9159"
shortlex.pyth 100501 = "89390"

Giải trình:

Q = eval(input())             Implicit.
t`                            All but the first digit of
  +hQ                         Q+1 + 
   v                          eval(
    *l`Q                      len(repr(Q)) * 
     \8                       "8"

Java 8, 60 byte

n->(n-~new Long((n+"").replaceAll(".","8"))+"").substring(1)

Cảng Câu trả lời JavaScript (ES6) tuyệt vời @ edc65 , vì tôi nghi ngờ nó có thể được thực hiện ngắn hơn theo cách số học trong Java.

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

Haskell , 57 byte

((g=<<[0..])!!)
g 0=[""]
g n=[c:s|c<-['0'..'9'],s<-g$n-1]

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

Xây dựng một danh sách vô hạn các số shortlex và chỉ mục vào đó để trả lời. g nxây dựng "thế hệ" thứ n của các số bằng cách thêm vào chữ số tiếp theo trước mỗi số trong thế hệ trước.

05AB1E , 7 byte

Sử dụng thay thế của edc65 bằng 8 mẹo

8sg×+>¦

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

Giải trình

8          # push 8
 sg×       # repeat it len(input) times
    +      # add to input
     >     # increment
      ¦    # discard the first digit

Excel, 37 byte

Sử dụng phương pháp của @ edc65:

=REPLACE(REPT(8,LEN(A1))+A1+1,1,1,"")

Thạch , 5 byte

ḃ⁵ịØD

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

Tôi rất mới với Jelly, vì vậy nếu bạn có thể cải thiện điều này, hãy bình luận!

Giải trình:

ḃ⁵ịØD   Main link.
ḃ       Convert to bijective base ...
 ⁵      10.
  ị     Each number (1 - 10) is converted to the character at its index in the string...
   ØD   “0123456789” (digits)

(Theo nhận xét của res ở trên, vấn đề tương đương với việc chuyển đổi số thành cơ sở tính toán 10)