Il s'agit d'une version de code golf d'une question similaire que j'ai posée sur la pile plus tôt, mais j'ai pensé que ce serait un puzzle intéressant.

Étant donné une chaîne de longueur 10 qui représente un nombre de base 36, incrémentez-la de un et retournez la chaîne résultante.

Cela signifie que les chaînes ne contiendront que des chiffres de 0à 9et des lettres de aà z.

La base 36 fonctionne comme suit:

Le droit chiffre le plus est incrémenté, d' abord à l'aide 0de9

0000000000> 9 itérations> 0000000009

et après aà zest utilisé:

000000000a> 25 itérations> 000000000z

Si elle zdoit être incrémentée, elle revient à zéro et le chiffre à sa gauche est incrémenté:

000000010

Autres règles:

• Vous pouvez utiliser des majuscules ou des minuscules.
• Vous ne pouvez pas supprimer de zéros non significatifs. L'entrée et la sortie sont des chaînes de longueur 10.
• Vous n'avez pas besoin de gérer zzzzzzzzzzen entrée.

Cas de test:

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

05AB1E , 10 octets

L'entrée est en majuscule .

Code

1ì36ö>36B¦

Explication

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

Utilise l' encodage 05AB1E . Essayez-le en ligne! ou Vérifiez tous les cas de test .

Japt , 13 octets

n36 Ä s36 ù0A

Essayez-le en ligne! et vérifier les cas de test

Prend l'entrée sous forme de chaîne

Explication

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

JavaScript (ES6), 45 octets

4 octets enregistrés grâce à @OOBalance

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

Essayez-le en ligne!

Haskell , 58 octets

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

Essayez-le en ligne!

Une stratégie très brutale: générez toutes les chaînes de base 10 de longueur 36 dans l'ordre, et trouvez celle qui vient après l'entrée dans la liste. Prenez énormément de temps sur les chaînes loin du début de la liste.

Haskell , 60 octets

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

Essayez-le en ligne!

Lit la chaîne de gauche à droite jusqu'à ce qu'elle atteigne un caractère suivi d'un suffixe de tous les z, qui peut être vide. Incrémente ce caractère et remplace les z par des 0.

Stax , 7 octets

ûæ≥╡►N▀

Exécuter et déboguer

Explication:

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

Un indicateur de portage explicite n'était pas nécessaire après la restructuration de la boucle pour se terminer dès qu'aucun report ne se produirait. Le réglage 9-> A est effectué pendant la vérification de la boucle.

Merci à plafondcat pour la suggestion.

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

Essayez-le en ligne!

Version originale: 71 57 octets

Cette version utilise un indicateur de portage pour propager les mises à jour: je l'ai défini sur true pour commencer l'incrémentation. La chaîne est modifiée sur place et accepte uniquement 0-9, AZ. La partie délicate consistait à s'assurer que 9-> A était correctement géré lors des portées.

Edit: J'ai réorienté le pointeur d'entrée comme drapeau de report.

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

Essayez-le en ligne!

C, 82 81 53 50 octets

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

Modifie directement la chaîne d'entrée; l'entrée et la sortie sont en majuscules. Essayez-le en ligne ici . Merci à Arnauld d' avoir joué au golf 24 octets et à plafondcat d' avoir joué au golf 3 octets de plus.

Non golfé:

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

Simulateur de machine de Turing en ligne , 745 octets

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

Interprète en ligne

Perl 6 , 34 32 30 octets

Merci à nwellnhof pour -2 octets grâce à l'utilisation de l' oopérateur pour combiner les fonctions

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

Essayez-le en ligne!

Fonction qui convertit l'argument en base 36, ajoute 1, reconvertit puis le formate. Utilise désormais la même tactique que la réponse d' Adnan pour conserver les zéros de tête.

MATL , 12 octets

36ZAQ5M10&YA

Essayez-le en ligne!

           % 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 octets

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

Essayez-le en ligne! Inverse la chaîne et vérifie le premier caractère:

• A 9est remplacé par un a.
• A zest remplacé par a 0et récursivement le caractère suivant est vérifié.
• Tous les autres caractères sont incrémentés à l'aide de succla fonction successeur qui peut être utilisée sur les caractères car ils sont une instance de la classe Enum .

Enfin, la chaîne résultante est à nouveau inversée.

6502 (NMOS *) routine de code machine , 26 octets

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

*) utilise un opcode "illégal" ISB/ 0xF3, fonctionne sur toutes les puces NMOS 6502 originales, pas sur les variantes CMOS ultérieures.

Attend un pointeur sur une chaîne de 10 caractères dans $fb/ $fcqui devrait être un nombre en base 36. Incrémente ce nombre sur place.

Ne fait rien de sensé sur une entrée invalide (comme par exemple une chaîne plus courte) - gère ZZZZZZZZZZ"correctement" par accident;)

Démontage commenté

; 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

Exemple de programme assembleur C64 utilisant la routine:

Démo en ligne

Code dans la syntaxe 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 octets

T`zo`dl`.z*$

Essayez-le en ligne! Explication: La dlpartie de la destination de substitution se développe en 0-9a-ztandis que la ocopie vers la source, entraînant z0-9a-z(bien que la seconde zsoit ignorée car elle ne peut jamais correspondre). Cela incrémente les chiffres correspondants. La .z*$partie du modèle correspond au dernier non- zchiffre plus tous les zs de fin , gérant ainsi le report de leur incrément à 0.

Rubis , 40 octets

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

Essayez-le en ligne!

1. Convertir la chaîne en un entier l'interprétant comme base 36
2. Ajouter 1
3. Convertir en chaîne de base 36
4. Pad gauche avec 0s

"zzzzzzzzzz" renvoie une chaîne longue de 11

brainfuck , 109 octets

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

Essayez-le en ligne!

Apl (Dyalog Unicode) , 30 28 24 octets

Merci à ngn pour l'astuce pour économiser quelques octets.

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

Essayez-le en ligne!

• Nécessite ⎕IO de 0

• Utilise les majuscules

PHP, 69 64 octets

version boiteuse :

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

Exécuter en tant que tuyau avec -R. Entrée insensible à la casse, sortie en minuscules.

première approche, 69 octets:

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

Exécuter en tant que tuyau avec -F

version en boucle, également 69 octets :

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

• PHP 7.1 uniquement: le PHP plus ancien ne comprend pas les index de chaîne négatifs, le
  PHP plus récent générera des avertissements pour les constantes non définies.
• nécessite une entrée en majuscules. Remplacez Yet Apar des lettres minuscules pour la saisie en minuscules.

Exécuter en tant que tuyau avec -nR

... ou essayez-les en ligne .

Python 2 , 88 octets

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

Essayez-le en ligne!

Incrémente la chaîne "à la main".

Fusain , 14 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

×0⁹

Imprimer 9 0s. Cela sert à garnir le résultat.

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

Convertissez l'entrée de la base 36, incrémentez-la, puis reconvertissez-la en base 36. Ensuite, inversez le résultat et imprimez-le vers la gauche.

Java 8, 90 76 56 octets

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

Accepte les lettres majuscules et minuscules pour la saisie. La sortie est toujours en minuscules.

Merci à Okx d' avoir joué au golf 18 octets.

Essayez-le en ligne ici .

Non golfé:

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 octets

Celui-ci n'est pas aussi efficace en octets que l'autre entrée JavaScript , mais je l'ai fait sans remarquer cette règle:

Étant donné une chaîne de longueur 10

Ce n'est donc pas une entrée sérieuse - juste pour le plaisir! Il fonctionne avec des chaînes de longueur générale, telles que 0abc, et ajoute un 1lorsque le premier chiffre est z, par exemple zzz-> 1000. L'entrée doit être en minuscules.

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

Explication

L'expression (A, B, C)signifie en fait "faire A, puis faire B, puis retourner C", que j'utilise pour déclarer certaines variables que je réutilise dans le code. ssignifie "chaîne", lsignifie "dernier", rsignifie "repos".

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

Il s'agit d'une fonction récursive. Pour une chaîne typique comme aza, il incrémentera simplement le dernier caractère (voir ligne 6) - azb. Mais pour une chaîne qui se termine par z, comme h0gz, elle s'exécutera sur tout jusqu'au dernier caractère (le z) et remplacera un 0à la place de celui-ci (voir ligne 5) - f(h0gz)= f(h0g) + 0=h0h0 .

La ||'0'ligne 5 est pour que la fonction fonctionne lorsqu'elle est appelée sur une chaîne de 1 longueur (c'est-à-dire la chaîne 'z'). Sans elle, f('')est appelée (depuis 'z'.slice(0, -1)est ''), qui a un comportement indéfini (littéralement - essayez-le vous-même), et ce n'est pas bon. Le résultat attendu de f('z')est '10', qui est ce que nous obtenons f('0') + 0, nous utilisons donc ||'0'. ( ||'0'est particulièrement utile car il ne gêne pas le cas habituel - rétant d'au moins 1 longueur ( sau moins 2 longueurs) - parce que les chaînes ne sont falsey que lorsqu'elles sont de longueur 0.)

La méthode pour incrémenter une chaîne est la même que celle utilisée dans l'autre entrée JS: convertir le "nombre" base-36 en un nombre réel, ajouter 1, puis le reconvertir en base-36. Nous n'avons pas à nous soucier de l' 1incrémentation de 'z' ( 'z'-> '10'), car nous n'incrémentons jamais réellement 'z' (voir lignes 4 et 6: le dernier caractère n'est incrémenté que s'il n'est pas 'z').

De plus, nous ne risquons jamais de supprimer les zéros non significatifs, car nous ne manipulons jamais plus d'un seul caractère à la fois - uniquement le dernier caractère de la chaîne. Les autres caractères sont tranchés proprement au fur et à mesure que vous coupez n'importe quelle chaîne et après-mots ajoutés.

Nettoyer , 89 84 octets

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

r o@o r

Essayez-le en ligne!

Une solution plus courte grâce à Laikoni .

Propre , 115 octets

J'adore quand j'utilise 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)]))

Essayez-le en ligne!

Produit la réponse sans convertir les bases à l'aide de la correspondance de liste.

• ? :: [Char] -> [Char] effectue le transport vers l'avant.
• @ :: Char -> Charincréments d'une unité, ce qui explique l'écart entre '9'et 'z'.
• $ :: [Char] -> [Char]incrémente le dernier caractère et s'applique ?jusqu'à ce que la valeur se stabilise.

R , 152 123 octets

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

Essayez-le en ligne!

Une approche complètement différente. Obtenez les points de code ASCII et "incrémentez" récursivement le point de code le plus à droite (faisant 0(57) sauter à a(97) et z(122) revenir à 0(48)) jusqu'à ce que vous soyez à court de zs. Reconvertissez en chaîne.

Ancienne version

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

Essayez-le en ligne!

Il s'agit uniquement de manipulation de texte, ce qui ne va pas de pair avec le golf en code R.

Remplacez tout zà la fin des chaînes par 0. Trouver l'emplacement du dernier élément avant les 0s finaux nouvellement créés . Trouvez le prochain chiffre de base 36. Faites le changement. Soyez heureux d'avoir à peine battu la solution Online Turing Machine Simulator.

Étoilé , 325 octets

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

Essayez-le en ligne!

Explication:

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 octets

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

Essayez-le en ligne!

Python 3.6+ et gmpy2 , 62 octets

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

Essayez-le en ligne!

(Notez que gmpy2 ne fait pas partie de la bibliothèque standard Python et nécessite une installation séparée)

Pyke , 11 octets

? b!!R+bhbt

Essayez-le ici!

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

Peut être 2 octets plus court avec le changement de langue suivant: Si le mode hexadécimal est utilisé, changez toutes les utilisations de base_36 et base_10 en base_92 (qui n'est pas vraiment de base 92 dans ce contexte de toute façon)

sed , 94 octets

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

Essayez-le en ligne!

Sed souffre beaucoup d'avoir à changer les personnages par recherche.

Zsh , 41 36 octets

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

Essayez-le en ligne!

Gelée , 21 octets

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

Essayez-le en ligne!

Utilise des majuscules. Le lien TIO permet également les minuscules / mixtes.