Đây là phiên bản golf mã của một câu hỏi tương tự tôi đã hỏi trên stack trước đó nhưng nghĩ rằng đó là một câu đố thú vị.

Cho một chuỗi có độ dài 10 đại diện cho một số cơ sở 36, tăng nó lên một và trả về chuỗi kết quả.

Điều này có nghĩa là các chuỗi sẽ chỉ chứa các chữ số từ 0đến 9và các chữ cái từ ađến z.

Cơ sở 36 hoạt động như sau:

Hầu hết các chữ số bên phải được tăng lên, đầu tiên bằng cách sử dụng 0để9

0000000000> 9 lần lặp> 0000000009

và sau đó ađể zđược sử dụng:

000000000a> 25 lần lặp> 000000000z

Nếu zcần tăng lên, nó lặp lại về 0 và chữ số bên trái của nó được tăng lên:

000000010

Quy tắc khác:

• Bạn có thể sử dụng chữ hoa hoặc chữ thường
• Bạn không thể thả số không hàng đầu. Cả đầu vào và đầu ra là các chuỗi có độ dài 10.
• Bạn không cần phải xử lý zzzzzzzzzznhư đầu vào.

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

"0000000000" -> "0000000001"
"0000000009" -> "000000000a"
"000000000z" -> "0000000010"
"123456zzzz" -> "1234570000"
"00codegolf" -> "00codegolg"

05AB1E , 10 byte

Đầu vào là chữ hoa .

Mã

1ì36ö>36B¦

Giải trình

1ì           # Prepend a 1 to the number
  36ö        # Convert from base 36 to decimal
     >       # Increment by 1
      36B    # Convert from decimal to base 36
         ¦   # Remove the first character

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm .

Japt , 13 byte

n36 Ä s36 ù0A

Hãy thử trực tuyến! và Xác minh các trường hợp thử nghiệm

Lấy đầu vào dưới dạng chuỗi

Giải trình

n36            converts input to base 36
    Ä           +1
      s36       to base 36 string
          ù0A   left-pad with 0 to length 10

JavaScript (ES6), 45 byte

Đã lưu 4 byte nhờ @OOBalance

s=>(parseInt(1+s,36)+1).toString(36).slice(1)

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

Haskell , 58 byte

d=['0'..'9']
f s=snd(span(<s)$mapM(\_->d++['a'..'z'])d)!!1

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

Một chiến lược rất mạnh mẽ: tạo ra tất cả các chuỗi dài 10 cơ sở-36 theo thứ tự và tìm chuỗi tiếp theo sau đầu vào trong danh sách. Dành một lượng lớn thời gian trên các chuỗi xa từ đầu danh sách.

Haskell , 60 byte

q '9'='a'
q c=succ c
f(h:t)|any(<'z')t=h:f t|r<-'0'<$t=q h:r

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

Đọc chuỗi từ trái sang phải cho đến khi nó đạt đến một ký tự theo sau là hậu tố của tất cả các z, có thể trống. Tăng ký tự đó và thay thế số z bằng 0.

Stax , 7 byte

ûæ≥╡►N▀

Chạy và gỡ lỗi nó

Giải trình:

|3^|3A|z Full program, implicit input
|3       Convert from base 36
  ^      Increment
   |3    Convert to base 36
     A|z Fill with "0" to length 10
         Implicit output

C (gcc) , 50 48 byte

Một cờ mang rõ ràng là không cần thiết sau khi cơ cấu lại vòng lặp để kết thúc ngay khi không có thực hiện mang. Điều chỉnh 9-> Một điều chỉnh được thực hiện trong quá trình kiểm tra vòng lặp.

Cảm ơn trần nhà cho lời đề nghị.

f(char*s){for(s+=9;(*s+=*s-57?1:8)>90;*s--=48);}

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

Phiên bản gốc: 71 57 byte

Phiên bản này sử dụng cờ mang để tuyên truyền các bản cập nhật: Tôi đặt nó thành sự thật để bắt đầu gia tăng. Chuỗi được sửa đổi tại chỗ và chỉ chấp nhận 0-9, AZ. Phần khó khăn là đảm bảo rằng 9-> A được xử lý chính xác khi mang.

Chỉnh sửa: Tôi đã tái sử dụng con trỏ đầu vào là cờ mang.

f(s){for(char*t=s+9;s;)*t--+=(s=++*t>90)?-43:7*!(*t-58);}

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

C, 82 81 53 50 byte

f(char*s){for(s+=10;*--s>89;)*s=48;*s+=*s-57?1:8;}

Trực tiếp sửa đổi chuỗi đầu vào; đầu vào và đầu ra là trong trường hợp trên. Hãy thử trực tuyến tại đây . Cảm ơn Arnauld vì đã chơi golf 24 byte và đến trần để chơi golf thêm 3 byte.

Ung dung:

f(char *s) { // function taking a string argument
     for(s += 10; *--s > 89; ) // skip to the least significant digit, and step through the string until you hit something other than a 'Z' (90 is the ASCII code for 'Z') ...
         *s = 48; // ... replacing each digit with a zero (48 is the ASCII code for '0')
         *s += // the next digit has to be incremented:
         *s - 57 // if it's not a '9' (ASCII code 57) ...
         ? 1 // ... that is straightforward ...
         : 8; // ... otherwise it has to be replaced with an 'A' (ASCII code 65 = 57 + 8)
 }

Trình mô phỏng máy Turing trực tuyến , 745 byte

init:0
accept:2
0,0
0,0,>
0,1
0,1,>
0,2
0,2,>
0,3
0,3,>
0,4
0,4,>
0,5
0,5,>
0,6
0,6,>
0,7
0,7,>
0,8
0,8,>
0,9
0,9,>
0,a
0,a,>
0,b
0,b,>
0,c
0,c,>
0,d
0,d,>
0,e
0,e,>
0,f
0,f,>
0,g
0,g,>
0,h
0,h,>
0,i
0,i,>
0,j
0,j,>
0,k
0,k,>
0,l
0,l,>
0,m
0,m,>
0,n
0,n,>
0,o
0,o,>
0,p
0,p,>
0,q
0,q,>
0,r
0,r,>
0,s
0,s,>
0,t
0,t,>
0,u
0,u,>
0,v
0,v,>
0,w
0,w,>
0,x
0,x,>
0,y
0,y,>
0,z
0,z,>
0,_
1,_,<
1,0
2,1,-
1,1
2,2,-
1,2
2,3,-
1,3
2,4,-
1,4
2,5,-
1,5
2,6,-
1,6
2,7,-
1,7
2,8,-
1,8
2,9,-
1,9
2,a,-
1,a
2,b,-
1,b
2,c,-
1,c
2,d,-
1,d
2,e,-
1,e
2,f,-
1,f
2,g,-
1,g
2,h,-
1,h
2,i,-
1,i
2,j,-
1,j
2,k,-
1,k
2,l,-
1,l
2,m,-
1,m
2,n,-
1,n
2,o,-
1,o
2,p,-
1,p
2,q,-
1,q
2,r,-
1,r
2,s,-
1,s
2,t,-
1,t
2,u,-
1,u
2,v,-
1,v
2,w,-
1,w
2,x,-
1,x
2,y,-
1,y
2,z,-
1,z
1,0,<

Phiên dịch trực tuyến

Perl 6 , 34 32 30 byte

Nhờ nwellnhof cho -2 byte thông qua việc sử dụng otoán tử để kết hợp các hàm

{S/.//}o{base :36(1~$_)+1: 36}

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

Hàm chuyển đổi đối số thành cơ sở 36, thêm 1, chuyển đổi lại và sau đó định dạng nó. Bây giờ sử dụng chiến thuật tương tự như câu trả lời của Adnan để bảo toàn các số 0 hàng đầu.

MATL , 12 byte

36ZAQ5M10&YA

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

           % Implicit input
36ZA       % convert from base 36 to decimal
Q          % increment by 1
5M         % bring the 36 back on stack (done this way to avoid needing space separator after this)
10         % = minimum length of output string
&YA        % convert back to base 36 with those arguments
           % Implicit output

Haskell , 63 byte

r.f.r
f('9':r)='a':r
f('z':r)='0':f r
f(c:r)=succ c:r
r=reverse

Hãy thử trực tuyến! Đảo ngược chuỗi và kiểm tra ký tự đầu tiên:

• A 9được thay thế bằng một a.
• A zđược thay thế bằng a 0và đệ quy ký tự tiếp theo được kiểm tra.
• Tất cả các ký tự khác được tăng lên bằng cách sử dụng succ, hàm kế tiếp có thể được sử dụng trên Chars vì chúng là một thể hiện của lớp Enum .

Cuối cùng, chuỗi kết quả được đảo ngược một lần nữa.

Thường trình mã máy 6502 (NMOS *) , 26 byte

A0 09 F3 FB B1 FB C9 5B 90 07 A9 30 91 FB 88 10 F1 C9 3A D0 04 A9 41 91 FB 60

*) sử dụng opcode "bất hợp pháp" ISB/ 0xF3, hoạt động trên tất cả các chip NMOS 6502 ban đầu, không phải trên các biến thể CMOS sau này.

Yêu cầu một con trỏ tới một chuỗi 10 ký tự trong $fb/ $fcđược dự kiến ​​là một số cơ sở 36. Tăng số này tại chỗ.

Không làm bất cứ điều gì hợp lý trên đầu vào không hợp lệ (ví dụ như chuỗi ngắn hơn) - xử lý ZZZZZZZZZZ"chính xác" một cách tình cờ;)

Bình luận tháo gỡ

; function to increment base 36 number as 10 character string
;
; input:
;   $fb/$fc: address of string to increment
; clobbers:
;   A, Y
 .inc36:
A0 09       LDY #$09            ; start at last character
 .loop:
F3 FB       ISB ($FB),Y         ; increment character ("illegal" opcode)
B1 FB       LDA ($FB),Y         ; load incremented character
C9 5B       CMP #$5B            ; > 'z' ?
90 07       BCC .checkgap       ; no, check for gap between numbers and letters
A9 30       LDA #$30            ; load '0'
91 FB       STA ($FB),Y         ; and store in string
88          DEY                 ; previous position
10 F1       BPL .loop           ; and loop
 .checkgap:
C9 3A       CMP #$3A            ; == '9' + 1 ?
D0 04       BNE .done           ; done if not
A9 41       LDA #$41            ; load 'a'
91 FB       STA ($FB),Y         ; and store in string
 .done:
60          RTS

Ví dụ chương trình biên dịch chương trình C64 sử dụng thường trình:

Bản demo trực tuyến

Mã theo cú pháp ca65 :

.import inc36   ; link with routine above

.segment "BHDR" ; BASIC header
                .word   $0801           ; load address
                .word   $080b           ; pointer next BASIC line
                .word   2018            ; line number
                .byte   $9e             ; BASIC token "SYS"
                .byte   "2061",$0,$0,$0 ; 2061 ($080d) and terminating 0 bytes

.bss
b36str:         .res    11

.data
prompt:         .byte   "> ", $0

.code
                lda     #<prompt        ; display prompt
                ldy     #>prompt
                jsr     $ab1e

                lda     #<b36str        ; read string into buffer
                ldy     #>b36str
                ldx     #$b
                jsr     readline

                lda     #<b36str        ; address of array to $fb/fc
                sta     $fb
                lda     #>b36str
                sta     $fc
                jsr     inc36           ; call incrementing function

                lda     #<b36str        ; output result
                ldy     #>b36str
                jmp     $ab1e

; read a line of input from keyboard, terminate it with 0
; expects pointer to input buffer in A/Y, buffer length in X
.proc readline
                dex
                stx     $fb
                sta     $fc
                sty     $fd
                ldy     #$0
                sty     $cc             ; enable cursor blinking
                sty     $fe             ; temporary for loop variable
getkey:         jsr     $f142           ; get character from keyboard
                beq     getkey
                sta     $2              ; save to temporary
                and     #$7f
                cmp     #$20            ; check for control character
                bcs     checkout        ; no -> check buffer size
                cmp     #$d             ; was it enter/return?
                beq     prepout         ; -> normal flow
                cmp     #$14            ; was it backspace/delete?
                bne     getkey          ; if not, get next char
                lda     $fe             ; check current index
                beq     getkey          ; zero -> backspace not possible
                bne     prepout         ; skip checking buffer size for bs
checkout:       lda     $fe             ; buffer index
                cmp     $fb             ; check against buffer size
                beq     getkey          ; if it would overflow, loop again
prepout:        sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
output:         lda     $2              ; load character
                jsr     $e716           ;   and output
                ldx     $cf             ; check cursor phase
                beq     store           ; invisible -> to store
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and show
                ora     #$80            ;   cursor in
                sta     ($d1),y         ;   current row
                lda     $2              ; load character
store:          cli                     ; enable interrupts
                cmp     #$14            ; was it backspace/delete?
                beq     backspace       ; to backspace handling code
                cmp     #$d             ; was it enter/return?
                beq     done            ; then we're done.
                ldy     $fe             ; load buffer index
                sta     ($fc),y         ; store character in buffer
                iny                     ; advance buffer index
                sty     $fe
                bne     getkey          ; not zero -> ok
done:           lda     #$0             ; terminate string in buffer with zero
                ldy     $fe             ; get buffer index
                sta     ($fc),y         ; store terminator in buffer
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
                inc     $cc             ; disable cursor blinking
                cli                     ; enable interrupts
                rts                     ; return
backspace:      dec     $fe             ; decrement buffer index
                bcs     getkey          ; and get next key
.endproc

Võng mạc 0.8.2 , 12 byte

T`zo`dl`.z*$

Hãy thử trực tuyến!Giải thích: Một dlphần của đích thay thế mở rộng 0-9a-ztrong khi các obản sao đến nguồn, dẫn đến z0-9a-z(mặc dù phần thứ hai zbị bỏ qua vì nó không bao giờ có thể khớp). Điều này làm tăng các chữ số phù hợp. Một .z*$phần của mẫu khớp với zchữ số không có chữ số cuối cùng cộng với tất cả các dấu z, do đó xử lý việc mang từ số gia của chúng đến 0.

Ruby , 40 byte

->s{(s.to_i(36)+1).to_s(36).rjust 10,?0}

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

1. Chuyển đổi chuỗi thành một số nguyên diễn giải nó là cơ sở 36
2. Thêm 1
3. Chuyển đổi trở lại chuỗi 36 cơ sở
4. Đệm trái với 0s

"zzzzzzzzzz" trả về một chuỗi dài 11

Brainfuck , 109 byte

,[>>,]<+[++++<[<--->>-<-]-[<->>+<---]<[[-]>-------<]+>>[[+<+>]<<+[>+<------]>>]-[<+>-----]<++++<]<[<<]>>[.>>]

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

Apl (Dyalog Unicode) , 30 28 24 byte

Cảm ơn ngn cho gợi ý để lưu một số byte.

(f⍣¯1)1+f←36⊥1,(⎕D,⎕A)⍳⊢

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

• Yêu cầu ⎕IO của 0

• Sử dụng chữ hoa

PHP, 69 64 byte

phiên bản khập khiễng :

printf("%010s",base_convert(1+base_convert($argn,36,10),10,36));

Chạy như ống với -R. Trường hợp đầu vào không nhạy, chữ thường đầu ra.

Cách tiếp cận đầu tiên, 69 byte:

<?=str_pad(base_convert(1+base_convert($argn,36,10),10,36),10,'0',0);

Chạy như ống với -F

phiên bản lặp, cũng 69 byte :

for($n=$argn;~$c=$n[$i-=1];)$f||$f=$n[$i]=$c!=9?$c>Y?0:++$c:A;echo$n;

• Chỉ dành cho PHP 7.1: PHP cũ hơn không hiểu các chỉ mục chuỗi âm,
  PHP trẻ hơn sẽ đưa ra các cảnh báo cho các hằng số không xác định.
• yêu cầu nhập chữ hoa. Thay thế Yvà Abằng chữ thường cho đầu vào chữ thường.

Chạy như ống với -nR

... hoặc thử chúng trực tuyến .

Python 2 , 88 byte

def f(s):L,R=s[:-1],s[-1:];return s and[[L+chr(ord(R)+1),f(L)+'0'][R>'y'],L+'a'][R=='9']

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

Tăng chuỗi "bằng tay".

Than , 14 byte

×0⁹←⮌⍘⊕⍘Ｓ³⁶¦³⁶

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:

×0⁹

In 9 0giây. Điều này phục vụ để đệm kết quả.

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

Chuyển đổi đầu vào từ cơ sở 36, tăng nó, sau đó chuyển đổi trở lại cơ sở 36. Sau đó, đảo ngược kết quả và in sang trái.

Java 8, 90 76 56 byte

s->Long.toString(Long.valueOf(1+s,36)+1,36).substring(1)

Chấp nhận cả chữ hoa và chữ thường cho đầu vào. Đầu ra luôn luôn trong trường hợp thấp hơn.

Cảm ơn Okx vì đã chơi golf 18 byte.

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

Ung dung:

s -> // lambda taking a String argument and returning a String
    Long.toString(Long.valueOf(1+s,36)+1,36) // prefix input with '1' to ensure leading zeros, convert to Long using base 36, increment, then convert back to String in base 36
    .substring(1) // remove the leading '1'

JavaScript (ES6), 89 byte

Cái này gần như không hiệu quả bằng byte như mục nhập JavaScript khác , nhưng tôi đã thực hiện điều này mà không nhận thấy quy tắc này:

Cho một chuỗi có độ dài 10

Vì vậy, đây không phải là một mục nghiêm trọng - chỉ để cho vui! Nó hoạt động với các chuỗi có độ dài chung, chẳng hạn như 0abc, và thêm 1vào trước khi chữ số đầu tiên là z, ví dụ zzz-> 1000. Đầu vào phải là chữ thường.

s=>(l=s[s.length-1],r=s.slice(0,-1),l=='z'?f(r||'0')+0:r+(parseInt(l,36)+1).toString(36))

Giải trình

Biểu thức (A, B, C)thực sự có nghĩa là "làm A, sau đó làm B, sau đó trả về C", mà tôi sử dụng để khai báo một số biến tôi sử dụng lại trong mã. slà viết tắt của "chuỗi", lcó nghĩa là "cuối cùng", rcó nghĩa là "phần còn lại".

/*1*/ s=>(
/*2*/   l=s[s.length-1],
/*3*/   r=s.slice(0,-1),
/*4*/   l=='z'
/*5*/     ? f(r||'0')+0
/*6*/     : r+(parseInt(l,36)+1).toString(36))

Đây là một hàm đệ quy. Đối với một chuỗi điển hình như aza, nó sẽ chỉ tăng ký tự cuối cùng (xem dòng 6) - azb. Nhưng đối với một chuỗi kết thúc bằng z, như h0gz, nó sẽ tự chạy trên mọi thứ cho đến ký tự cuối cùng ( zthay thế) và thay thế một chuỗi thay thế 0(xem dòng 5) - f(h0gz)= f(h0g) + 0=h0h0 .

Các ||'0'phù 5 là để các chức năng hoạt động khi nó được gọi là trên một chuỗi 1 có độ dài (tức là chuỗi 'z'). Không có nó, f('')được gọi là (vì 'z'.slice(0, -1)là ''), có hành vi không xác định (theo nghĩa đen - hãy tự mình thử) và điều đó không tốt. Kết quả mong đợi f('z')là '10', đó là những gì chúng tôi nhận được f('0') + 0, vì vậy chúng tôi sử dụng ||'0'. ( ||'0'đặc biệt hữu ích vì nó không cản trở trường hợp thông thường - rít nhất là 1 chiều dài ( sít nhất là 2 chiều dài) - bởi vì các chuỗi chỉ dừng lại khi chúng có độ dài 0).

Phương thức tăng chuỗi giống như được sử dụng trong mục nhập JS khác: chuyển đổi số "36" cơ bản thành số thực, thêm 1, sau đó chuyển đổi lại thành cơ sở 36. Chúng ta không cần phải lo lắng về việc 1tăng 'z' ( 'z'-> '10'), vì chúng ta không bao giờ thực sự tăng 'z' (xem dòng 4 và 6: ký tự cuối cùng chỉ tăng nếu không phải là 'z').

Ngoài ra, chúng tôi không bao giờ mạo hiểm loại bỏ các số 0 đứng đầu, bởi vì chúng tôi không thực sự thao túng nhiều hơn một ký tự tại một thời điểm - chỉ bao giờ là ký tự cuối cùng trong chuỗi. Phần còn lại của các ký tự được cắt ra một cách sạch sẽ khi bạn cắt bất kỳ chuỗi nào và trả lời sau.

Sạch , 89 84 byte

import StdEnv
@['9':t]=['a':t]
@['z':t]=['0': @t]
@[c:t]=[inc c:t]
r=reverse

r o@o r

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

Một giải pháp ngắn hơn nhờ Laikoni .

Sạch sẽ , 115 byte

Tôi thích nó khi tôi sử dụng limit(iterate...

import StdEnv
@'9'='a'
@c=inc c
?[h,'{':t]=[@h,'0': ?t]
?[h:t]=[h: ?t]
?e=e
$l=limit(iterate?(init l++[@(last l)]))

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

Tạo câu trả lời mà không chuyển đổi cơ sở bằng cách sử dụng danh sách khớp.

• ? :: [Char] -> [Char] thực hiện tiến về phía trước.
• @ :: Char -> Chartăng thêm một, chiếm khoảng cách giữa '9'và 'z'.
• $ :: [Char] -> [Char]tăng ký tự cuối cùng và áp dụng ?cho đến khi giá trị ổn định.

R , 152 123 byte

function(x)f(utf8ToInt(x),10)
f=function(x,n,y=x[n]){x[n]=y+(y==57)*39+(y==122)*(-75)+1
"if"(y==122,f(x,n-1),intToUtf8(x))}

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

Một cách tiếp cận hoàn toàn khác. Lấy các điểm mã ASCII và đệ quy "tăng" điểm mã bên phải nhất (làm 0(57) nhảy tới a(97) và z(122) trở lại 0(48)) cho đến khi bạn hết zs. Chuyển đổi trở lại chuỗi.

Phiên bản cũ

function(s,w=gsub("(z)(?=\\1*$)","0",s,,T),x=regexpr(".0*$",w)[1],y=substr(w,x,x),z=chartr("0-9a-z","1-9a-z0",y))sub(p(y,"(0*$)"),p(z,"\\1"),w)
p=paste0

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

Đây là tất cả các thao tác văn bản, không đi đôi với chơi golf mã R.

Thay thế tất cả zở cuối chuỗi bằng 0. Tìm vị trí của phần tử cuối cùng trước dấu 0s mới được tạo . Tìm cơ sở tiếp theo 36 chữ số. Hãy thay đổi. Hãy vui mừng vì hầu như không đánh bại giải pháp mô phỏng máy Turing trực tuyến.

Starry , 325 byte

     + , , , , , , , , , ,     +      +   +   +`* +          + +* + +**      + * +* * '    +           + +* +* +* +*      +* `     +  + +                + +  *       +* *  '    +      +*           + +* +* +*  `   +   +           + +* +  *  **   +  + +'    +    +   ` +           + +* +  *    * .           + +* +  *   * +   '

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

Giải trình:

Put-a-zero-at-the-base-of-the-stack
|     +
Read-10-digits
| , , , , , , , , , ,
Initialise-next-stack
|     +
Initialise-carry-bit
|      +
|   +   +
Do
|`
    Top-of-stack:-[output-stack]-[carry-bit]-[next-value]
    Add-Carry-bit-to-digit
    |*

    Compare-with-58-("9"=57)
    | +
    5-double-triple-sub1-double
    |          + +* + +**      + * +*
    Take-difference
    | *
    If-one-above-"9"
    | '
        set-to-"a"=97=6-double-double-double-double-add1
        |    +
        |           + +* +* +* +*      +*
    | `

    Initialise-next-carry-bit
    |     +
    |  +

    Compare-with-123-("z"=122)
    | +
    11-squared-add2
    |                + +  *       +*
    Take-difference
    | *
    If-one-above-"z"
    |  '
        Delete-current-value
        |    +
        set-carry-bit
        |      +*
        Set-to-"0"=48
        |           + +* +* +*
    |  `

    Push-value-to-stack
    |   +   +
    |           + +* +  *
    |  **

    |   +  +
While-next-value-is-not-null
| +'

Pop-carry-bit-and-null-string-terminator
|    +    +
Do
|   `
    Get-top-value
    | +
    |           + +* +  *
    |    *

    Print-it
    | .

    Pop-the-value-off-the-stack
    |           + +* +  *
    |   *
While-stack-is-not-null
| +   '

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

IntegerString[#~FromDigits~36+1,36,10]&

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

Python 3.6+ và gmpy2 , 62 byte

from gmpy2 import*;f=lambda s:f'{digits(mpz(s,36)+1,36):0>10}'

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

(Lưu ý rằng gmpy2 không phải là một phần của thư viện chuẩn Python và yêu cầu cài đặt riêng)

Pyke , 11 byte

? b!!R+bhbt

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

? b         - Change default base of `base` command to 36 
            -  This is kind of clever because it modifies the list of characters 
            -  the command uses to exactly the same as it was originally, whilst
            -  forcing an overwrite from the default settings of 10. 
            -  The default setup works for base 36, you just have to specify it
            -  time when using the command.
            -  Literally `b.contents = modify(b.contents, func=lambda: noop)`
   !!       - The previous command returns `0123456789abcdefghijklmnopqrstuvwxyz`
            -  So we convert it into a 1 with (not not ^) for the following command:
     R+     -     "1"+input
       b    -    base(^, 36)
        h   -   ^ + 1
         b  -  base(^, 36)
          t - ^[1:]

Có thể ngắn hơn 2 byte với thay đổi ngôn ngữ sau: Nếu chế độ hex được sử dụng, hãy thay đổi tất cả các cách sử dụng base_36 và base_10 thành base_92 (dù sao đó không thực sự là cơ sở 92 trong bối cảnh đó)

sed , 94 byte

s/$/#:0123456789abcdefghijklmnopqrstuvwxyz#0/
:l
s/\(.\)#\(.*:.*\1\)\(#*.\)/\3\2\3/
tl
s/:.*//

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

Sed chịu đựng rất nhiều vì phải thay đổi nhân vật bằng cách tra cứu.

Zsh , 41 36 byte

echo ${(l:10::0:)$(([##36]36#$1+1))}

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

Thạch , 21 byte

ØBḊiⱮḅ‘bɗ36Ż9¡ṫ-9‘ịØB

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

Sử dụng chữ hoa. Liên kết TIO cho phép trường hợp thấp hơn / hỗn hợp quá.