Esta es una versión de código de golf de una pregunta similar que hice en la pila anteriormente, pero pensé que sería un rompecabezas interesante.

Dada una cadena de longitud 10 que representa un número base 36, increméntelo en uno y devuelva la cadena resultante.

Esto significa que las cadenas solo contendrán dígitos de 0a 9y letras de aa z.

Base 36 funciona de la siguiente manera:

El dígito del extremo derecho se incrementa, en primer lugar mediante el uso 0de9

0000000000> 9 iteraciones> 0000000009

y después de que aa zse utiliza:

000000000a> 25 iteraciones> 000000000z

Si znecesita incrementarse, vuelve a cero y el dígito a su izquierda se incrementa:

000000010

Reglas adicionales:

• Puede usar letras mayúsculas o minúsculas.
• Es posible que no deje caer los ceros iniciales. Tanto la entrada como la salida son cadenas de longitud 10.
• No necesita manejar zzzzzzzzzzcomo entrada.

Casos de prueba:

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

05AB1E , 10 bytes

La entrada está en mayúscula .

Código

1ì36ö>36B¦

Explicación

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

Utiliza la codificación 05AB1E . Pruébalo en línea! o Verificar todos los casos de prueba .

Japt , 13 bytes

n36 Ä s36 ù0A

Pruébalo en línea! y verificar casos de prueba

Toma la entrada como una cadena

Explicación

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

JavaScript (ES6), 45 bytes

Guardado 4 bytes gracias a @OOBalance

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

Pruébalo en línea!

Haskell , 58 bytes

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

Pruébalo en línea!

Una estrategia de fuerza bruta: genera todas las cadenas de longitud 10 base-36 en orden, y encuentra la que viene después de la entrada en la lista. Tómese una enorme cantidad de tiempo en cadenas lejos del comienzo de la lista.

Haskell , 60 bytes

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

Pruébalo en línea!

Lee la cadena de izquierda a derecha hasta que alcanza un carácter seguido de un sufijo de todas las z, que puede estar vacío. Incrementa ese carácter y reemplaza las z por 0.

Stax , 7 bytes

ûæ≥╡►N▀

Ejecutar y depurarlo

Explicación:

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

No fue necesario un indicador de acarreo explícito después de reestructurar el ciclo para que finalice tan pronto como no ocurra ningún acarreo. El ajuste 9-> A se realiza durante la verificación del bucle.

Gracias a ceilingcat por la sugerencia.

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

Pruébalo en línea!

Versión original: 71 57 bytes

Esta versión utiliza un indicador de acarreo para propagar actualizaciones: lo configuré como verdadero para comenzar el incremento. La cadena se modifica en el lugar y solo acepta 0-9, AZ. La parte difícil fue asegurarse de que 9-> A se manejara correctamente en los acarreos.

Editar: reutilicé el puntero de entrada como el indicador de acarreo.

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

Pruébalo en línea!

C, 82 81 53 50 bytes

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

Modifica directamente la cadena de entrada; La entrada y la salida están en mayúsculas. Pruébelo en línea aquí . Gracias a Arnauld por jugar al golf 24 bytes y a ceilingcat por jugar al golf 3 bytes más.

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

Simulador de máquina de Turing en línea , 745 bytes

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

Intérprete en línea

Perl 6 , 34 32 30 bytes

Gracias a nwellnhof por -2 bytes a través del uso del ooperador para combinar funciones

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

Pruébalo en línea!

Función que convierte el argumento en base 36, agrega 1, convierte de nuevo y luego lo formatea. Ahora usa la misma táctica que la respuesta de Adnan para preservar los ceros iniciales.

MATL , 12 bytes

36ZAQ5M10&YA

Pruébalo en línea!

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

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

Pruébalo en línea! Invierte la cadena y comprueba el primer carácter:

• A 9es reemplazado por un a.
• A zse reemplaza por a 0y recursivamente se verifica el siguiente carácter.
• Todos los demás caracteres se incrementan usando succla función sucesora que se puede usar en Chars porque son una instancia de la clase Enum .

Finalmente, la cadena resultante se invierte nuevamente.

Rutina de código de máquina 6502 (NMOS *) , 26 bytes

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

*) Utiliza un código de operación "ilegal" ISB/ 0xF3, funciona en todos los NMOS 6502 fichas originales, no en las variantes más adelante CMOS.

Espera un puntero a una cadena de 10 caracteres en $fb/ $fcque se espera que sea un número base 36. Incrementa este número en el lugar.

No hace nada sensato en una entrada no válida (como, por ejemplo, una cadena más corta): maneja ZZZZZZZZZZ"correctamente" por accidente;)

Desmontaje comentado

; 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

Ejemplo de programa ensamblador C64 usando la rutina:

Demostración en línea

Código en sintaxis 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 bytes

T`zo`dl`.z*$

Pruébalo en línea! Explicación: La dlparte del destino de sustitución se expande hasta 0-9a-zque se ocopia en la fuente, lo que da como resultado z0-9a-z(aunque el segundo zse ignora, ya que nunca puede coincidir). Esto incrementa los dígitos coincidentes. La .z*$parte del patrón coincide con el último no zdígito más todos los zs finales , manejando así el acarreo desde su incremento hasta 0.

Rubí , 40 bytes.

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

Pruébalo en línea!

1. Convierta la cadena a un entero interpretándola como base 36
2. Añadir 1
3. Convertir de nuevo a la cadena base 36
4. Almohadilla izquierda con 0s

"zzzzzzzzzz" devuelve una cadena de 11 largos

brainfuck , 109 bytes

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

Pruébalo en línea!

Apl (Dyalog Unicode) , 30 28 24 bytes

Gracias a ngn por la sugerencia de guardar algunos bytes.

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

Pruébalo en línea!

• Requiere ⎕IO de 0

• Utiliza mayúsculas

PHP, 69 64 bytes

versión pobre :

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

Ejecutar como tubería con -R. Entrada insensible a mayúsculas y minúsculas.

primer enfoque, 69 bytes:

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

Corre como tubería con -F

versión de bucle, también 69 bytes :

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

• Solo PHP 7.1: el PHP anterior no entiende los índices de cadena negativos, el
  PHP más joven generará advertencias para constantes indefinidas.
• requiere entrada en mayúscula. Reemplace Yy Acon letras minúsculas para la entrada en minúsculas.

Corre como tubería con -nR

... o pruébalos en línea .

Python 2 , 88 bytes

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

Pruébalo en línea!

Incrementa la cadena "a mano".

Carbón , 14 bytes

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

Pruébalo en línea!El enlace es a la versión detallada del código. Explicación:

×0⁹

Imprimir 9 0 s. Esto sirve para rellenar el resultado.

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

Convierta la entrada de la base 36, incremente, luego vuelva a convertir a la base 36. Luego, invierta el resultado e imprímalo hacia la izquierda.

Java 8, 90 76 56 bytes

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

Acepta letras mayúsculas y minúsculas para la entrada. La salida siempre está en minúscula.

Gracias a Okx por jugar al golf 18 bytes.

Pruébelo en línea aquí .

Sin 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 bytes

Este no es tan eficiente en bytes como la otra entrada de JavaScript , pero lo hice sin notar esta regla:

Dada una cuerda de longitud 10

Así que esta no es una entrada seria, ¡solo por diversión! Funciona con cadenas de longitud general, como 0abc, y antepone a 1cuando el primer dígito es z, por ejemplo, zzz-> 1000. La entrada debe estar en minúscula.

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

Explicación

La expresión en (A, B, C)realidad significa "hacer A, luego hacer B, luego devolver C", que utilizo para declarar algunas variables que reutilizo en el código. ssignifica "cadena", lsignifica "último", rsignifica "descanso".

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

Esta es una función recursiva. Para una cadena típica como aza, solo incrementará el último carácter (ver línea 6) - azb. Pero para una cadena que termina con z, como h0gz, se ejecutará en todo hasta el último carácter (el z) y sustituirá a 0en su lugar (vea la línea 5) - f(h0gz)= f(h0g) + 0=h0h0 .

La ||'0'línea 5 es para que la función funcione cuando se llama en una cadena de 1 longitud (es decir, la cadena 'z'). Sin él, f('')se llama (como 'z'.slice(0, -1)es ''), que tiene un comportamiento indefinido (literalmente, pruébelo usted mismo), y eso no es bueno. El resultado esperado de f('z')es '10', que es de lo que obtenemos f('0') + 0, por lo que utilizamos ||'0'. ( ||'0'es particularmente útil porque no se interpone en el caso habitual , ya rque tiene al menos 1 longitud ( sal menos 2 de longitud), porque las cuerdas son falsey solo cuando son de longitud 0).

El método para incrementar una cadena es el mismo que el utilizado en la otra entrada JS: convierta el "número" base 36 en un número real, agregue 1 y luego vuelva a convertirlo en base 36. No debemos preocuparnos por el 1incremento de 'z' ( 'z'-> '10'), ya que nunca incrementamos 'z' (ver líneas 4 y 6: el último carácter solo se incrementa si no es 'z').

Además, nunca corremos el riesgo de descartar los ceros a la izquierda, porque en realidad nunca manipulamos más de un solo carácter a la vez, solo el último carácter de la cadena. El resto de los caracteres se cortan limpiamente a medida que corta cualquier cadena y palabras posteriores.

Limpio , 89 84 bytes

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

r o@o r

Pruébalo en línea!

Una solución más corta gracias a Laikoni .

Limpio , 115 bytes

Me encanta cuando puedo usar 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)]))

Pruébalo en línea!

Produce la respuesta sin convertir bases usando la comparación de listas.

• ? :: [Char] -> [Char] realiza transporte hacia adelante.
• @ :: Char -> Charincrementos en uno, lo que representa la brecha entre '9'y 'z'.
• $ :: [Char] -> [Char]incrementa el último carácter y se aplica ?hasta que el valor se estabilice.

R , 152 123 bytes

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

Pruébalo en línea!

Un enfoque completamente diferente. Obtenga los puntos de código ASCII y "incremente" recursivamente el punto de código más a la derecha (haciendo que 0(57) salte a a(97) y z(122) regrese a 0(48)) hasta que se quede sin zs. Convertir de nuevo a cadena.

Versión antigua

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

Pruébalo en línea!

Todo esto es manipulación de texto, que no va de la mano con el golf de código R.

Reemplace todo zal final de las cadenas con 0. Encuentre la ubicación del último elemento antes del 0s. Encuentra la siguiente base de 36 dígitos. Haz el cambio. Alégrate de haber superado apenas la solución Online Turing Machine Simulator.

Estrellado , 325 bytes

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

Pruébalo en línea!

Explicación:

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 bytes

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

Pruébalo en línea!

Python 3.6+ y gmpy2 , 62 bytes

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

Pruébalo en línea!

(Tenga en cuenta que gmpy2 no es parte de la biblioteca estándar de Python y requiere una instalación separada)

Pyke , 11 bytes

? b!!R+bhbt

Pruébalo aquí!

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

Podría ser 2 bytes más corto con el siguiente cambio de idioma: si se utiliza el modo hexadecimal, cambie todos los usos de base_36 y base_10 a base_92 (que de todos modos no es realmente base 92 en ese contexto)

sed , 94 bytes

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

Pruébalo en línea!

Sed sufre mucho por tener que cambiar los personajes por búsqueda.

Zsh , 41 36 bytes

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

Pruébalo en línea!

Jalea , 21 bytes

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

Pruébalo en línea!

Utiliza mayúsculas. El enlace TIO también permite mayúsculas / minúsculas.