Questa è una versione di golf del codice di una domanda simile che ho posto in precedenza sullo stack ma ho pensato che sarebbe stato un puzzle interessante.

Data una stringa di lunghezza 10 che rappresenta un numero di base 36, incrementalo di uno e restituisci la stringa risultante.

Ciò significa che le stringhe conterranno solo cifre da 0a 9e lettere da aa z.

Base 36 funziona come segue:

La cifra più a destra viene incrementata, prima usando 0to9

0000000000> 9 iterazioni> 0000000009

e dopo che aa zviene utilizzato:

000000000a> 25 iterazioni> 000000000z

Se zdeve essere incrementato, ritorna a zero e la cifra alla sua sinistra viene incrementata:

000000010

Ulteriori regole:

• È possibile utilizzare lettere maiuscole o minuscole.
• Si può non far cadere gli zeri iniziali. Sia l'input che l'output sono stringhe di lunghezza 10.
• Non è necessario gestirlo zzzzzzzzzzcome input.

Casi test:

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

05AB1E , 10 byte

L'input è in maiuscolo .

Codice

1ì36ö>36B¦

Spiegazione

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

Utilizza la codifica 05AB1E . Provalo online! oppure Verifica tutti i casi di test .

Japt , 13 byte

n36 Ä s36 ù0A

Provalo online! e verifica i casi di test

Accetta l'input come stringa

Spiegazione

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

JavaScript (ES6), 45 byte

Salvato 4 byte grazie a @OOBalance

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

Provalo online!

Haskell , 58 byte

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

Provalo online!

Una strategia molto bruta: genera in ordine tutte le stringhe di lunghezza 10 base-36 e trova quella che segue l'inserimento nell'elenco. Dedica molto tempo alle stringhe lontano dall'inizio dell'elenco.

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

Provalo online!

Legge la stringa da sinistra a destra fino a quando non raggiunge un carattere seguito da un suffisso di tutte le z, che può essere vuoto. Incrementa quel personaggio e sostituisce le z con 0.

Stax , 7 byte

ûæ≥╡►N▀

Esegui ed esegui il debug

Spiegazione:

|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

Una bandiera di carry esplicita non era necessaria dopo la ristrutturazione del loop per terminare non appena si verificava alcun carry. Il 9-> Una regolazione viene eseguita durante il controllo del loop.

Grazie a ceilingcat per il suggerimento.

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

Provalo online!

Versione originale: 71 57 byte

Questa versione utilizza un flag carry per propagare gli aggiornamenti: l'ho impostato su true per iniziare l'incremento. La stringa viene modificata sul posto e accetta solo 0-9, AZ. La parte difficile era assicurarsi che 9-> A venisse gestito correttamente sui carry.

Modifica: ho riproposto il puntatore di input come flag carry.

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

Provalo online!

C, 82 81 53 50 byte

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

Modifica direttamente la stringa di input; input e output sono in maiuscolo. Provalo online qui . Grazie ad Arnauld per giocare a golf 24 byte e a plafoniera per giocare a golf altri 3 byte.

Ungolfed:

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

Simulatore online di Turing Machine , 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,<

Interprete online

Perl 6 , 34 32 30 byte

Grazie a nwellnhof per -2 byte attraverso l'uso odell'operatore per combinare le funzioni

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

Provalo online!

Funzione che converte l'argomento in base 36, aggiunge 1, converte indietro e quindi lo formatta. Ora usa la stessa tattica della risposta di Adnan per preservare gli zeri iniziali.

MATL , 12 byte

36ZAQ5M10&YA

Provalo 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

Provalo online! Inverte la stringa e controlla il primo carattere:

• A 9è sostituito da un a.
• A zviene sostituito da a 0e ricorsivamente viene controllato il carattere successivo.
• Tutti gli altri caratteri vengono incrementati usando succ, la funzione successiva che può essere usata su Chars perché sono un'istanza della classe Enum .

Alla fine la stringa risultante viene nuovamente invertita.

6502 (NMOS *) routine codice macchina , 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

*) utilizza un codice operativo "illegale" ISB/ 0xF3, funziona su tutti i chip NMOS 6502 originali, non sulle varianti CMOS successive.

Si aspetta un puntatore a una stringa di 10 caratteri in $fb/ $fcche dovrebbe essere un numero di base 36. Incrementa questo numero sul posto.

Non fa nulla di sensato su input non validi (come ad esempio una stringa più corta) - gestisce ZZZZZZZZZZ"correttamente" per caso;)

Smontaggio commentato

; 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

Esempio di programma assemblatore C64 che utilizza la routine:

Demo online

Codice nella sintassi 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*$

Provalo online! Spiegazione: La dlparte della destinazione di sostituzione si espande a 0-9a-zmentre le ocopie la coprono alla fonte, risultando z0-9a-z(anche se la seconda zviene ignorata in quanto non può mai corrispondere). Ciò aumenta le cifre corrispondenti. La .z*$parte del modello corrisponde all'ultima non zcifra più tutte le zs finali , gestendo così il carry dal loro incremento a 0.

Rubino , 40 byte

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

Provalo online!

1. Converti la stringa in un numero intero interpretandolo come base 36
2. Aggiungi 1
3. Converti nuovamente in 36 string di base
4. Pad sinistro con 0s

"zzzzzzzzzz" restituisce una stringa lunga 11

Brainfuck , 109 byte

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

Provalo online!

Apl (Dyalog Unicode) , 30 28 24 byte

Grazie a ngn per il suggerimento per salvare alcuni byte.

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

Provalo online!

• Richiede ⎕IO di 0

• Usa maiuscole

PHP, 69 64 byte

versione zoppa :

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

Esegui come pipe con -R. Maiuscole / minuscole, input minuscole

primo approccio, 69 byte:

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

Esegui come pipe con -F

versione in loop, anche 69 byte :

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

• Solo PHP 7.1: PHP precedente non comprende gli indici di stringa negativi,
  PHP più giovane genererà avvisi per costanti indefinite.
• richiede input maiuscoli. Sostituisci Ye Acon lettere minuscole per input minuscoli.

Esegui come pipe con -nR

... o provali 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']

Provalo online!

Incrementa la stringa "a mano".

Carbone , 14 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

×0⁹

Stampa 9 0s. Questo serve a riempire il risultato.

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

Convertire l'input dalla base 36, incrementarlo, quindi riconvertirlo in base 36. Quindi, invertire il risultato e stamparlo a sinistra.

Java 8, 90 76 56 byte

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

Accetta sia lettere maiuscole che minuscole per l'input. L'output è sempre in minuscolo.

Grazie a Okx per giocare a golf 18 byte.

Provalo online qui .

Ungolfed:

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

Questo non è quasi efficiente in termini di byte come l'altra voce JavaScript , ma l'ho fatto senza notare questa regola:

Dato una stringa di lunghezza 10

Quindi questa non è una voce seria - solo per divertimento! Funziona con stringhe di lunghezza generale, come 0abc, e antepone a 1quando la prima cifra è z, ad es. zzz-> 1000. L'ingresso deve essere minuscolo.

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

Spiegazione

L'espressione in (A, B, C)realtà significa "esegui A, quindi esegui B, quindi restituisce C", che utilizzo per dichiarare alcune variabili che riutilizzo nel codice. ssta per "stringa", lsignifica "ultimo", rsignifica "riposo".

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

Questa è una funzione ricorsiva. Per una stringa tipica come aza, aumenterà solo l'ultimo carattere (vedi riga 6) - azb. Ma per una stringa che termina con z, come h0gz, verrà eseguita su tutto fino all'ultimo carattere (il z) e sostituirà un 0al posto di esso (vedi riga 5) - f(h0gz)= f(h0g) + 0=h0h0 .

La ||'0'riga 5 fa in modo che la funzione funzioni quando viene chiamata su una stringa di 1 lunghezza (ovvero la stringa 'z'). Senza di essa, f('')si chiama (poiché lo 'z'.slice(0, -1)è ''), che ha un comportamento indefinito (letteralmente - provalo tu stesso), e non va bene. Il risultato atteso di f('z')è '10', che è ciò che otteniamo f('0') + 0, quindi usiamo ||'0'. ( ||'0'è particolarmente utile perché non interferisce con il solito caso - ressendo almeno 1 lunghezza ( salmeno 2 lunghezza) - perché le stringhe sono false solo quando sono lunghe 0.

Il metodo per incrementare una stringa è lo stesso usato nell'altra voce JS: convertire il "numero" base-36 in un numero effettivo, aggiungere 1, quindi riconvertirlo in base-36. Non dobbiamo preoccuparci 1dell'incremento di 'z' ( 'z'-> '10'), dal momento che in realtà non incrementiamo mai 'z' (vedere le righe 4 e 6: l'ultimo carattere viene incrementato solo se non è 'z').

Inoltre, non rischiamo mai di scartare gli zeri iniziali, perché in realtà non manipoliamo mai più di un singolo carattere alla volta, solo l'ultimo carattere della stringa. Il resto dei caratteri viene tagliato in modo netto mentre si taglia qualsiasi stringa e le parole d'ordine anteposte.

Pulito , 89 84 byte

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

r o@o r

Provalo online!

Una soluzione più breve grazie a Laikoni .

Pulito , 115 byte

Lo adoro quando riesco a usarlo 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)]))

Provalo online!

Produce la risposta senza convertire le basi utilizzando la corrispondenza elenco.

• ? :: [Char] -> [Char] esegue il trasporto in avanti.
• @ :: Char -> Charincrementi di uno, tenendo conto del divario tra '9'e 'z'.
• $ :: [Char] -> [Char]incrementa l'ultimo carattere e si applica ?fino a quando il valore non si stabilizza.

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

Provalo online!

Un approccio completamente diverso. Ottieni i punti di codice ASCII e "incrementa" ricorsivamente il punto di codice più a destra (facendo 0saltare (57) a a(97) e z(122) torna a 0(48)) fino a quando non esaurisci zs. Converti nuovamente in stringa.

Vecchia versione

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

Provalo online!

Questa è tutta manipolazione del testo, che non va di pari passo con il golf con codice R.

Sostituisci tutto zalla fine delle stringhe con 0. Trova la posizione dell'ultimo elemento prima dei messaggi finali appena coniati 0. Trova la prossima cifra di 36 cifre. Fai il cambiamento. Sii contento di aver battuto a malapena la soluzione del simulatore di macchine online Turing.

Stellato , 325 byte

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

Provalo online!

Spiegazione:

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 byte

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

Provalo online!

Python 3.6+ e gmpy2 , 62 byte

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

Provalo online!

(Nota che gmpy2 non fa parte della libreria standard di Python e richiede un'installazione separata)

Pyke , 11 byte

? b!!R+bhbt

Provalo qui!

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

Potrebbe essere più corto di 2 byte con la seguente modifica della lingua: Se si utilizza la modalità esadecimale, cambiare tutti gli usi base_36 e base_10 in base_92 (che comunque non è proprio la base 92 in quel contesto)

sed , 94 byte

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

Provalo online!

Sed soffre molto per aver dovuto cambiare i personaggi in base alla ricerca.

Zsh , 41 36 byte

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

Provalo online!

Gelatina , 21 byte

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

Provalo online!

Usa lettere maiuscole. Il collegamento TIO consente anche lettere minuscole / miste.