Ini adalah versi kode golf dari pertanyaan serupa yang saya tanyakan di stack sebelumnya tetapi saya pikir itu akan menjadi teka-teki yang menarik.

Diberikan string dengan panjang 10 yang mewakili nomor basis 36, menambahnya dengan satu dan mengembalikan string yang dihasilkan.

Ini berarti string hanya akan berisi digit dari 0ke 9dan surat dari ake z.

Basis 36 berfungsi sebagai berikut:

Digit paling kanan bertambah, pertama dengan menggunakan 0untuk9

0000000000> 9 iterasi> 0000000009

dan setelah itu ake zdigunakan:

000000000a> 25 iterasi> 000000000z

Jika zperlu ditingkatkan, loop kembali ke nol dan digit ke kiri bertambah:

000000010

Aturan lebih lanjut:

• Anda dapat menggunakan huruf besar atau huruf kecil.
• Anda tidak boleh menjatuhkan angka nol di depan. Baik input dan output adalah string dengan panjang 10.
• Anda tidak perlu menangani zzzzzzzzzzsebagai input.

Kasus uji:

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

05AB1E , 10 byte

Input dalam huruf besar .

Kode

1ì36ö>36B¦

Penjelasan

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

Menggunakan penyandian 05AB1E . Cobalah online! atau Verifikasi semua kasus uji .

Japt , 13 byte

n36 Ä s36 ù0A

Cobalah online! dan Verifikasi kasus uji

Mengambil input sebagai string

Penjelasan

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

JavaScript (ES6), 45 byte

Disimpan 4 byte berkat @OOBalance

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

Cobalah online!

Haskell , 58 byte

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

Cobalah online!

Strategi yang sangat kasar: buat semua string panjang-10 base-36 secara berurutan, dan temukan satu yang muncul setelah input dalam daftar. Luangkan banyak waktu untuk merangkai jauh dari awal daftar.

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

Cobalah online!

Membaca string dari kiri ke kanan hingga mencapai karakter yang diikuti oleh sufiks dari semua z, yang mungkin kosong. Menambahkan karakter itu, dan menggantikan z dengan 0.

Stax , 7 byte

ûæ≥╡►N▀

Jalankan dan debug itu

Penjelasan:

|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

Bendera carry yang eksplisit tidak diperlukan setelah restrukturisasi loop agar berakhir segera setelah carry tidak akan terjadi. Pengaturan 9-> A dilakukan selama pemeriksaan loop.

Terima kasih kepada ceilingcat untuk sarannya.

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

Cobalah online!

Versi asli: 71 57 byte

Versi ini menggunakan flag carry untuk menyebarkan pembaruan: Saya mengaturnya agar benar untuk memulai kenaikan. String dimodifikasi di tempat dan hanya menerima 0-9, AZ. Bagian yang sulit adalah memastikan bahwa 9-> A dapat ditangani dengan benar pada perangkat.

Sunting: Saya menggunakan kembali pointer input sebagai flag carry.

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

Cobalah online!

C, 82 81 53 50 byte

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

Secara langsung memodifikasi string input; input dan output dalam huruf besar. Cobalah online di sini . Terima kasih kepada Arnauld untuk bermain golf 24 byte dan untuk ceilingcat untuk bermain golf 3 byte lebih banyak.

Tidak Terkumpul:

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)
 }

Simulator Mesin Turing Online , 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,<

Penerjemah online

Perl 6 , 34 32 30 byte

Berkat nwellnhof untuk -2 bytes melalui penggunaan ooperator untuk menggabungkan fungsi

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

Cobalah online!

Fungsi yang mengubah argumen menjadi basis 36, menambahkan 1, mengonversi kembali dan kemudian memformatnya. Sekarang gunakan taktik yang sama dengan jawaban Adnan untuk melestarikan nol terkemuka.

MATL , 12 byte

36ZAQ5M10&YA

Cobalah online!

           % 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

Cobalah online! Membalik string dan memeriksa karakter pertama:

• A 9digantikan oleh a.
• SEBUAH z digantikan oleh a 0dan secara rekursif karakter selanjutnya diperiksa.
• Semua karakter lain bertambah menggunakan succ, fungsi penerus yang dapat digunakan pada Chars karena mereka adalah turunan dari kelas Enum .

Akhirnya string yang dihasilkan dibalik lagi.

6502 (NMOS *) rutin kode mesin , 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

*) menggunakan opcode "ilegal" ISB/0xF3 , bekerja pada semua chip NMOS 6502 asli, bukan pada varian CMOS yang lebih baru.

Mengharapkan pointer ke string 10 karakter di $fb/$fc yang diharapkan menjadi nomor base-36. Menambah nomor ini di tempat.

Tidak melakukan apa pun yang masuk akal pada input yang tidak valid (seperti misalnya string yang lebih pendek) - menangani ZZZZZZZZZZ"dengan benar" secara tidak sengaja;)

Komentar pembongkaran

; 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

Contoh program assembler C64 menggunakan rutin:

Demo online

Kode dalam sintaksis 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

Retina 0.8.2 , 12 byte

T`zo`dl`.z*$

Cobalah online! Penjelasan: Bagian dldari tujuan substitusi diperluas ke 0-9a-zsementara osalinan itu ke sumber, menghasilkan z0-9a-z(meskipun yang kedua zdiabaikan karena tidak pernah bisa cocok). Ini menambah angka yang cocok. Bagian .z*$dari pola cocok dengan non- zdigit terakhir ditambah semua trailing z, sehingga menangani carry dari kenaikannya ke 0.

Ruby , 40 byte

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

Cobalah online!

1. Ubah string menjadi integer yang menafsirkannya sebagai basis 36
2. Tambahkan 1
3. Konversi kembali ke basis 36 string
4. Pad kiri dengan 0s

"zzzzzzzzzz" mengembalikan string 11-panjang

brainfuck , 109 byte

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

Cobalah online!

Apl (Dyalog Unicode) , 30 28 24 byte

Terima kasih kepada ngn untuk petunjuk untuk menyimpan beberapa byte.

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

Cobalah online!

• Membutuhkan ⎕IO dari 0

• Gunakan huruf besar

PHP, 69 64 byte

versi lumpuh :

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

Jalankan sebagai pipa dengan -R. Input case tidak sensitif, output huruf kecil.

pendekatan pertama, 69 byte:

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

Jalankan sebagai pipa dengan -F

versi perulangan, juga 69 byte :

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

• Hanya PHP 7.1: PHP lama tidak memahami indeks string negatif,
  PHP yang lebih muda akan menghasilkan peringatan untuk konstanta yang tidak ditentukan.
• membutuhkan input huruf besar. Ganti Ydan Adengan huruf kecil untuk input huruf kecil.

Jalankan sebagai pipa dengan -nR

... atau coba online .

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']

Cobalah online!

Menambah string "dengan tangan".

Arang , 14 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

×0⁹

Cetak 9 0s. Ini berfungsi untuk memberikan hasil.

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

Konversikan input dari basis 36, tambahkan, lalu konversikan kembali ke basis 36. Kemudian, balikkan hasilnya dan cetak ke kiri.

Java 8, 90 76 56 byte

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

Menerima huruf besar dan kecil untuk input. Output selalu dalam huruf kecil.

Terimakasih untuk Okx untuk bermain golf 18 byte.

Cobalah online sini .

Tidak Terkumpul:

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

Yang ini hampir tidak seefisien byte entri JavaScript lainnya , tapi saya membuatnya tanpa memperhatikan aturan ini:

Diberikan string dengan panjang 10

Jadi ini bukan entri serius - hanya untuk bersenang-senang! Ia bekerja dengan string dengan panjang umum, seperti 0abc, dan menambahkan sebuah 1ketika digit pertama adalah z, misalnya zzz-> 1000. Input harus berupa huruf kecil.

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

Penjelasan

Ekspresi (A, B, C)sebenarnya berarti "lakukan A, lalu lakukan B, lalu kembali C", yang saya gunakan untuk mendeklarasikan beberapa variabel yang saya gunakan kembali dalam kode. ssingkatan dari "string", lberarti "terakhir", rberarti "istirahat".

/*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))

Ini adalah fungsi rekursif. Untuk string seperti biasa aza, itu hanya akan menambah karakter terakhir (lihat baris 6) - azb. Tetapi untuk string yang diakhiri dengan z, seperti h0gz, itu akan berjalan sendiri pada semua hingga karakter terakhir (the z) dan mengganti a 0di tempat itu (lihat baris 5) - f(h0gz)= f(h0g) + 0=h0h0 .

The ||'0'sejalan 5 adalah agar fungsi bekerja ketika itu disebut pada 1-panjang string (yaitu string 'z'). Tanpanya, f('')disebut (sejak 'z'.slice(0, -1)itu ''), yang memiliki perilaku yang tidak terdefinisi (secara harfiah - coba sendiri), dan itu tidak baik. Hasil yang diharapkan f('z')adalah '10', dari mana kita dapatkan f('0') + 0, jadi kita gunakan ||'0'. ( ||'0'ini sangat berguna karena tidak menghalangi kasus biasa - rmenjadi setidaknya 1-panjang ( ssetidaknya 2-panjang) - karena string hanya palsu ketika mereka 0-panjang.)

Metode untuk menambahkan string sama dengan yang digunakan pada entri JS lainnya: ubah "angka" basis-36 menjadi angka aktual, tambahkan 1, lalu ubah kembali ke basis-36. Kita tidak perlu khawatir dengan 1bertambahnya 'z' ( 'z'-> '10'), karena kita tidak pernah benar-benar menambah 'z' (lihat baris 4 dan 6: karakter terakhir hanya bertambah jika bukan 'z').

Selain itu, kami tidak pernah mengambil risiko membuang angka nol di depan, karena kami tidak pernah benar-benar memanipulasi lebih dari satu karakter sekaligus - hanya karakter terakhir dalam string. Sisa karakter dipotong dengan rapi saat Anda mengiris string apa pun dan kata penutup yang berurutan.

Bersih , 89 84 byte

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

r o@o r

Cobalah online!

Solusi yang lebih singkat berkat Laikoni .

Bersih , 115 byte

Saya suka ketika bisa digunakan 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)]))

Cobalah online!

Menghasilkan jawaban tanpa mengonversi basis menggunakan pencocokan daftar.

• ? :: [Char] -> [Char] melakukan pengangkutan ke depan.
• @ :: Char -> Charselisih satu per satu, yang menjelaskan kesenjangan antara '9'dan 'z'.
• $ :: [Char] -> [Char]menambah karakter terakhir dan berlaku ?hingga nilainya stabil.

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))}

Cobalah online!

Pendekatan yang sama sekali berbeda. Dapatkan poin kode ASCII dan secara berulang "menambah" titik kode paling kanan (membuat 0(57) melompat ke a(97) dan z(122) kembali ke 0(48)) sampai Anda kehabisan zs. Konversi kembali ke string.

Versi lama

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

Cobalah online!

Ini semua adalah manipulasi teks, yang tidak berjalan seiring dengan golf kode R.

Ganti semua zdi akhir string dengan 0. Temukan lokasi elemen terakhir sebelum jejak yang baru dicetak 0. Temukan base 36 digit berikutnya. Membuat perubahan. Senang bisa mengalahkan solusi Simulator Mesin Turing Online.

Starry , 325 byte

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

Cobalah online!

Penjelasan:

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
| +   '

Bahasa Wolfram (Mathematica) , 39 byte

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

Cobalah online!

Python 3.6+ dan gmpy2 , 62 byte

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

Cobalah online!

(Perhatikan bahwa gmpy2 bukan bagian dari pustaka standar Python dan membutuhkan instalasi terpisah)

Pyke , 11 byte

? b!!R+bhbt

Coba di sini!

? 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:]

Bisa jadi 2 byte lebih pendek dengan perubahan bahasa berikut: Jika mode hex digunakan, ubah semua penggunaan base_36 dan base_10 menjadi base_92 (yang sebenarnya bukan basis 92 dalam konteks itu)

sed , 94 byte

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

Cobalah online!

Sed banyak menderita karena harus mengubah karakter dengan mencari.

Zsh , 41 36 byte

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

Cobalah online!

Jelly , 21 byte

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

Cobalah online!

Gunakan huruf besar. TIO link juga memungkinkan untuk huruf kecil / campuran.