To jest wersja kodu golfowego podobnego pytania, które zadałem wcześniej na stosie ale pomyślałem, że będzie to interesująca łamigłówka.

Biorąc pod uwagę ciąg o długości 10, który reprezentuje podstawową liczbę 36, zwiększ go o jeden i zwróć wynikowy ciąg.

Oznacza to, że ciągi będą zawierać tylko cyfry od 0do 9i litery od ado z.

Baza 36 działa w następujący sposób:

Prawa najbardziej cyfra jest zwiększana, najpierw za pomocą 0do9

0000000000> 9 iteracji> 0000000009

i po tej aDo zstosuje się:

000000000a> 25 iteracji> 000000000z

Jeśli ztrzeba zwiększyć, pętla wraca do zera, a cyfra po lewej stronie jest zwiększana:

000000010

Dalsze zasady:

• Możesz używać wielkich lub małych liter.
• Ty może nie spaść zera. Zarówno wejście, jak i wyjście są ciągami o długości 10.
• Nie musisz obsługiwać zzzzzzzzzzdanych wejściowych.

Przypadki testowe:

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

05AB1E , 10 bajtów

Dane wejściowe są pisane wielkimi literami .

Kod

1ì36ö>36B¦

Wyjaśnienie

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

Wykorzystuje kodowanie 05AB1E . Wypróbuj online! lub Zweryfikuj wszystkie przypadki testowe .

Japt , 13 bajtów

n36 Ä s36 ù0A

Wypróbuj online! i Zweryfikuj przypadki testowe

Pobiera dane wejściowe jako ciąg

Wyjaśnienie

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

JavaScript (ES6), 45 bajtów

Zaoszczędź 4 bajty dzięki @OOBalance

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

Wypróbuj online!

Haskell , 58 bajtów

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

Wypróbuj online!

Strategia bardzo brutalnej siły: generuj wszystkie ciągi długości -10-base-36 w kolejności i znajdź ten, który pojawia się po danych wejściowych na liście. Poświęć bardzo dużo czasu na ciągi znaków daleko od początku listy.

Haskell , 60 bajtów

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

Wypróbuj online!

Czyta ciąg znaków od lewej do prawej, aż do znaku, po którym następuje sufiks wszystkich liter Z, które mogą być puste. Zwiększa ten znak i zastępuje Z na 0.

Stax , 7 bajtów

ûæ≥╡►N▀

Uruchom i debuguj

Wyjaśnienie:

|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 bajtów

Wyraźna flaga przeniesienia nie była konieczna po zrestrukturyzowaniu pętli do końca, gdy tylko przeniesienie się nie zdarzy. Regulacja 9-> odbywa się podczas sprawdzania pętli.

Dzięki pułapkowi cat za sugestię.

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

Wypróbuj online!

Wersja oryginalna: 71 57 bajtów

Ta wersja używa flagi carry do rozpowszechniania aktualizacji: ustawiłem ją na true, aby rozpocząć przyrost. Ciąg jest modyfikowany w miejscu i akceptuje tylko 0-9, AZ. Najtrudniejsze było upewnienie się, że 9-> A zostało poprawnie obsłużone na noszach.

Edycja: Zmieniłem przeznaczenie wskaźnika wejściowego jako flagę przenoszenia.

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

Wypróbuj online!

C, 82 81 53 50 bajtów

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

Bezpośrednio modyfikuje ciąg wejściowy; dane wejściowe i wyjściowe są pisane wielkimi literami. Wypróbuj online tutaj . Dzięki Arnaulda do golfa 24 bajtów i do ceilingcat do golfa 3 więcej bajtów.

Nie golfowany:

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

Online Turing Machine Simulator , 745 bajtów

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,<

Tłumacz online

Perl 6 , 34 32 30 bajtów

Dzięki nwellnhof za -2 bajty dzięki użyciu ooperatora do łączenia funkcji

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

Wypróbuj online!

Funkcja, która konwertuje argument na bazę 36, dodaje 1, konwertuje z powrotem, a następnie formatuje go. Teraz stosuje tę samą taktykę jak odpowiedź Adnana, aby zachować wiodące zera.

MATL , 12 bajtów

36ZAQ5M10&YA

Wypróbuj 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 bajty

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

Wypróbuj online! Odwraca ciąg i sprawdza pierwszy znak:

• A 9zostaje zastąpione przez a.
• A zjest zastępowane przez a, 0a rekurencyjnie sprawdzany jest następny znak.
• Wszystkie pozostałe znaki są zwiększane za pomocą succ funkcji następcy, której można używać na znakach, ponieważ są one instancją klasy Enum .

Ostatecznie powstały ciąg znaków jest ponownie odwracany.

Procedura kodu maszynowego 6502 (NMOS *) , 26 bajtów

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

*) używa „nielegalnego” kodu operacyjnego ISB/0xF3 , działa na wszystkich oryginalnych układach NMOS 6502, a nie na późniejszych wariantach CMOS.

Oczekuje wskaźnika do ciągu 10 znaków w $fb/$fc który ma być liczbą podstawową 36. Zwiększa tę liczbę w miejscu.

Nie robi nic sensownego na nieprawidłowych danych wejściowych (jak np. Krótszy łańcuch) - uchwyty ZZZZZZZZZZ przez przypadek „poprawnie”;)

Skomentowano demontaż

; 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

Przykładowy program asemblerowy C64 wykorzystujący procedurę:

Demo online

Kod w składni 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 bajtów

T`zo`dl`.z*$

Wypróbuj online! Objaśnienie: dlCzęść miejsca docelowego zamiany rozwija się, 0-9a-zpodczas gdy okopie kopiują ją do źródła, co powoduje z0-9a-z(chociaż druga zzostaje zignorowana, ponieważ nigdy nie może się dopasować). Zwiększa to dopasowane cyfry. .z*$Część wzoru mecze ostatniej nieprzestrzegania zcyfrę plusa wszystkie spływu zs, a więc manipulowania carry z ich przyrostem do 0.

Rubinowy , 40 bajtów

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

Wypróbuj online!

1. Konwertuj ciąg na liczbę całkowitą, interpretując go jako podstawę 36
2. Dodaj 1
3. Konwertuj z powrotem na ciąg 36 bazowy
4. Lewa podkładka z 0s

"zzzzzzzzzz" zwraca łańcuch o długości 11

pieprzenie mózgu , 109 bajtów

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

Wypróbuj online!

Apl (Dyalog Unicode) , 30 28 24 bajtów

Dzięki ngn za podpowiedź, aby zaoszczędzić trochę bajtów.

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

Wypróbuj online!

• Wymaga ⎕IO równego 0

• Używa wielkich liter

PHP, 69 64 bajtów

kiepska wersja :

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

Uruchom jako potok z -R. Wielkość liter nie ma znaczenia, małe litery wyjściowe.

pierwsze podejście, 69 bajtów:

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

Uruchom jako potok z -F

wersja zapętlona, ​​również 69 bajtów :

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

• Tylko PHP 7.1: starsze PHP nie rozumie ujemnych indeksów ciągów,
  młodsze PHP wyświetla ostrzeżenia o niezdefiniowanych stałych.
• wymaga wprowadzenia wielkich liter. Zamień Yi na Amałe litery, aby wprowadzić małe litery.

Uruchom jako potok z -nR

... lub wypróbuj je online .

Python 2 , 88 bajtów

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

Wypróbuj online!

Zwiększa ciąg „ręcznie”.

Węgiel drzewny , 14 bajtów

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

Wypróbuj online!Link jest do pełnej wersji kodu. Wyjaśnienie:

×0⁹

Drukuj 9 0 s. Służy to uzupełnieniu wyniku.

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

Konwertuj dane wejściowe z bazy 36, zwiększaj je, a następnie konwertuj z powrotem na bazę 36. Następnie odwróć wynik i wydrukuj go w lewo.

Java 8, 90 76 56 bajtów

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

Akceptuje zarówno duże, jak i małe litery do wprowadzania. Dane wyjściowe są zawsze pisane małymi literami.

Dzięki Okx za w golfa 18 bajtów.

Wypróbuj online tutaj .

Nie golfowany:

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 bajtów

Ten nie jest tak efektywny bajtowo jak drugi wpis JavaScript , ale zrobiłem to, nie zauważając tej reguły:

Biorąc pod uwagę ciąg o długości 10

To nie jest poważny wpis - dla zabawy! Działa z ciągami o ogólnej długości, takimi jak 0abc, i wstawia, 1gdy pierwsza cyfra to z, np. zzz-> 1000. Dane wejściowe muszą być pisane małymi literami.

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

Wyjaśnienie

Ekspresja (A, B, C) faktycznie oznacza „zrób A, następnie zrób B, a następnie zwróć C”, którego używam do deklarowania niektórych zmiennych, których ponownie używam w kodzie. soznacza „ciąg”, loznacza „ostatni”, roznacza „odpoczynek”.

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

To jest funkcja rekurencyjna. W przypadku typowego ciągu znaków azazwiększy on tylko ostatni znak (patrz wiersz 6) - azb. Ale dla łańcucha, który kończy się naz , na przykład h0gz, będzie działać na wszystkim aż do ostatniego znaku (the z) i zastąpi go 0zamiast niego (patrz wiersz 5) - f(h0gz)= f(h0g) + 0=h0h0 .

W ||'0'wierszu 5 funkcja działa, gdy jest wywoływana na łańcuch o długości 1 (tj. Łańcuch 'z'). Bez niego f('')nazywa się (ponieważ 'z'.slice(0, -1)jest ''), który ma niezdefiniowane zachowanie (dosłownie - spróbuj sam), a to nie jest dobre. Oczekiwany wynik f('z')to '10', z czego otrzymujemy f('0') + 0, więc wykorzystujemy ||'0'. ( ||'0'jest szczególnie użyteczny, ponieważ nie przeszkadza w zwykłym przypadku - rma co najmniej 1 długość (s co najmniej 2 długości) - ponieważ łańcuchy są falsey tylko, gdy mają długość 0).

Metoda inkrementacji łańcucha jest taka sama, jak stosowana w drugim wpisie JS: przekonwertuj „liczbę” base-36 na liczbę rzeczywistą, dodaj 1, a następnie przekonwertuj ją z powrotem na base-36. Nie musimy się martwić o 1zwiększenie wartości „z” ( 'z'->'10' ), ponieważ tak naprawdę nigdy nie inkrementujemy „z” (patrz linie 4 i 6: ostatni znak jest zwiększany tylko wtedy, gdy nie jest „z”).

Ponadto nigdy nie ryzykujemy odrzucenia wiodących zer, ponieważ tak naprawdę nigdy nie manipulujemy więcej niż jednym znakiem naraz - tylko ostatnim znakiem w ciągu. Reszta znaków jest czysto odcinana, gdy kroisz dowolny ciąg i poprzedzające go posłowie.

Czysty , 89 84 bajtów

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

r o@o r

Wypróbuj online!

Krótsze rozwiązanie dzięki Laikoni .

Czysty , 115 bajtów

Uwielbiam to, kiedy mogę użyć 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)]))

Wypróbuj online!

Daje odpowiedź bez konwersji baz przy użyciu dopasowywania list.

• ? :: [Char] -> [Char] wykonuje przewóz do przodu.
• @ :: Char -> Charprzyrosty o jeden, uwzględniając różnicę między '9'i 'z'.
• $ :: [Char] -> [Char]zwiększa ostatni znak i obowiązuje, ?dopóki wartość nie ustabilizuje się.

R , 152 123 bajty

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

Wypróbuj online!

Zupełnie inne podejście. Zdobądź punkty kodowe ASCII i rekurencyjnie „zwiększaj” najbardziej prawy punkt kodowy (sprawiając, że 0(57) skacze do a(97) i z(122) wraca do 0(48)), aż zabraknie ci z. Konwertuj z powrotem na ciąg.

Stara wersja

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

Wypróbuj online!

To wszystko manipulowanie tekstem, które nie idzie w parze z golfem w kodzie R.

Zamień wszystko zna końcu ciągów na 0. Znajdź lokalizację ostatniego elementu przed nowo wybitymi końcowymi 0s. Znajdź następną bazę 36 cyfr. Dokonać zmiany. Ciesz się, że ledwo pokonałeś rozwiązanie Online Turing Machine Simulator.

Gwiaździsta , 325 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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

Wolfram Language (Mathematica) , 39 bajtów

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

Wypróbuj online!

Python 3.6+ i gmpy2 , 62 bajty

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

Wypróbuj online!

(Uwaga: gmpy2 nie jest częścią standardowej biblioteki Pythona i wymaga oddzielnej instalacji)

Pyke , 11 bajtów

? b!!R+bhbt

Wypróbuj tutaj!

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

Może być o 2 bajty krótszy z następującą zmianą języka: Jeśli używany jest tryb szesnastkowy, zmień wszystkie zastosowania base_36 i base_10 na base_92 (które w rzeczywistości w tym kontekście nie są tak naprawdę base 92)

sed , 94 bajty

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

Wypróbuj online!

Sed bardzo cierpi z powodu konieczności zmiany postaci poprzez wyszukiwanie.

Zsh , 41 36 bajtów

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

Wypróbuj online!

Galaretka , 21 bajtów

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

Wypróbuj online!

Używa wielkich liter. Łącze TIO pozwala również na małe / mieszane przypadki.