Це кодова версія для гольфу подібного питання, яку я задав у стеці раніше, але подумав, що це буде цікава загадка.

Давши рядок довжиною 10, який представляє базове число 36, збільште його на одне і поверніть отриману рядок.

Це означає, що рядки містять лише цифри від 0до 9та букви від aдо z.

База 36 працює наступним чином:

Найбільш правильна цифра збільшується спочатку за допомогою 0кнопок9

0000000000> 9 ітерацій> 0000000009

і після цього aTo zвикористовується:

000000000a> 25 ітерацій> 000000000z

Якщо zпотрібно збільшувати, воно циклічно повертається до нуля, а цифра ліворуч збільшується:

000000010

Подальші правила:

• Ви можете використовувати великі і малі літери.
• Ви не можете скидати провідні нулі. І вхід, і вихід - це рядки довжиною 10.
• Вам не потрібно обробляти zzzzzzzzzzяк вхід.

Випробування:

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

05AB1E , 10 байт

Введення є великими літерами .

Код

1ì36ö>36B¦

Пояснення

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

Використовує кодування 05AB1E . Спробуйте в Інтернеті! або Перевірте всі тестові випадки .

Japt , 13 байт

n36 Ä s36 ù0A

Спробуйте в Інтернеті! і Перевірка тестових випадків

Вводиться як рядок

Пояснення

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

JavaScript (ES6), 45 байт

Збережено 4 байти завдяки @OOBalance

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

Спробуйте в Інтернеті!

Хаскелл , 58 байт

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

Спробуйте в Інтернеті!

Дуже жорстка стратегія: генеруйте всі строки довжини-10 базових-36 в порядку і знайдіть ту, що надходить після введення в списку. Виділіть величезну кількість часу на рядках, далеких від початку списку.

Haskell , 60 байт

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

Спробуйте в Інтернеті!

Читає рядок зліва направо, поки не доходить до символу, а за ним суфікс усіх z, який може бути порожнім. Збільшення, що символізують, і замінює z на 0.

Стакс , 7 байт

ûæ≥╡►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 байт

Явний прапор переносу не був необхідний після реструктуризації циклу, щоб закінчитися, як тільки не відбудеться перенесення. 9-> Налаштування виконується під час перевірки циклу.

Дякую стельовій кішці за пропозицію.

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

Спробуйте в Інтернеті!

Оригінальна версія: 71 57 байт

Ця версія використовує прапор перенесення для поширення оновлень: я встановив його на truthy для початку збільшення. Рядок змінено на місці і приймає лише 0-9, AZ. Складна частина полягала в тому, щоб 9-> A правильно поводилися з носіями.

Редагувати: я змінив вхідний вказівник як прапор перенесення.

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

Спробуйте в Інтернеті!

C, 82 81 53 50 байт

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

Безпосередньо змінює рядок введення; вхід і вихід у верхньому регістрі. Спробуйте його онлайн тут . Дякуємо Arnauld за те, що він займався 24 байтами для гри в гольф, і ще 3 байти для гольфу.

Безголівки:

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

Інтернет-тренажер Тьюрінга , 745 байт

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

Онлайн-перекладач

Perl 6 , 34 32 30 байт

Завдяки nwellnhof за -2 байти через використання oоператора для поєднання функцій

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

Спробуйте в Інтернеті!

Функція, яка перетворює аргумент в базу 36, додає 1, перетворює назад і потім форматує його. Тепер використовується та ж тактика, що і відповідь Аднана, щоб зберегти перші нулі.

MATL , 12 байт

36ZAQ5M10&YA

Спробуйте в Інтернеті!

           % 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 байти

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

Спробуйте в Інтернеті! Повертає рядок і перевіряє перший символ:

• A 9замінюється на a.
• A zзамінюється на a 0і рекурсивно перевіряється наступний символ.
• Усі інші символи збільшуються за допомогою succфункції спадкоємця, яка може бути використана для Chars, оскільки вони є екземпляром класу Enum .

Нарешті отриманий рядок знову перевертається.

Рутинний код машинного коду 6502 (NMOS *) , 26 байт

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

*) використовує "незаконний" опкод ISB/ 0xF3, працює на всіх оригінальних мікросхемах NMOS 6502, а не на пізніших варіантах CMOS.

Очікує вказівник на 10-символьний рядок в $fb/, $fcякий, як очікується, буде базовим числом 36. Збільшується ця кількість на місці.

Не робить нічого розумного при неправильному введенні (наприклад, коротша рядок) - ZZZZZZZZZZвипадково обробляє "правильно";)

Прокоментували розбирання

; 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

Приклад програми асемблера C64 з використанням рутини:

Демонстрація в Інтернеті

Код у синтаксисі 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

Сітківка 0,8,2 , 12 байт

T`zo`dl`.z*$

Спробуйте в Інтернеті! Пояснення: dlчастина пункту призначення заміни розширюється на 0-9a-zтой час, як oкопіює його до джерела, в результаті чого z0-9a-z(хоча друга zігнорується, оскільки вона ніколи не може збігатися). Це збільшує відповідні цифри. .z*$Частина шаблону збігається з останнім не- zцифри плюс все хвостове zс, таким чином , обробці перенесення від їх приросту до 0.

Рубін , 40 байт

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

Спробуйте в Інтернеті!

1. Перетворіть рядок у ціле число, інтерпретуючи його як базу 36
2. Додайте 1
3. Перетворити назад в базу 36 рядка
4. Ліва накладка з 0s

"zzzzzzzzzz" повертає 11-довгий рядок

мозковий ебать , 109 байт

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

Спробуйте в Інтернеті!

Apl (Dyalog Unicode) , 30 28 24 байт

Завдяки ngn за підказку зберегти кілька байт.

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

Спробуйте в Інтернеті!

• Потрібно ⎕IO 0

• Використовується верхній регістр

PHP, 69 64 байт

кульгава версія :

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

Запустити як труба -R. Вхідний регістр нечутливий, виводить малі регістри.

перший підхід, 69 байт:

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

Запустити як труба -F

циклічна версія, також 69 байт :

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

• Лише PHP 7.1: старший PHP не розуміє негативних рядкових індексів,
  молодший PHP отримуватиме попередження для невизначених констант.
• вимагає введення великих літер. Замініть Yі Aмалими літерами для введення малих літер.

Запустити як труба -nR

... або спробуйте їх в Інтернеті .

Python 2 , 88 байт

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

Спробуйте в Інтернеті!

Збільшує рядок "від руки".

Вугілля деревне , 14 байт

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

×0⁹

Друк 9 0с. Це служить для підбивання результату.

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

Перетворіть вхід із бази 36, збільшивши його, а потім перетворіть назад на базу 36. Потім переверніть результат і надрукуйте його вліво.

Java 8, 90 76 56 байт

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

Приймає для введення як великі, так і маленькі літери. Вихід завжди є малим.

Завдяки Okx для гри в гольф на 18 байт.

Спробуйте його онлайн тут .

Безголівки:

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 байт

Цей не є настільки ефективним, як інший JavaScript , але я це зробив, не помічаючи цього правила:

Дано рядок довжиною 10

Тож це не серйозний запис - просто для розваги! Він працює з рядками загальної довжини, такими як 0abc, і попереджує a, 1коли перша цифра z, наприклад zzz-> 1000. Вхід повинен бути малий.

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

Пояснення

Вираз (A, B, C)насправді означає "зробити A, потім зробити B, потім повернути C", який я використовую для оголошення деяких змінних, які я повторно використовую в коді. sозначає "рядок", lозначає "останній", rозначає "відпочинок".

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

Це рекурсивна функція. Для типового рядка, як-от aza, він просто збільшить останній символ (див. Рядок 6) - azb. Але для рядка, який закінчується z, як-от h0gz, він запустить себе на все до останнього символу (the z) і замінить a 0замість нього (див. Рядок 5) - f(h0gz)= f(h0g) + 0= h0h0.

||'0'У рядку 5, так що функція працює , коли вона викликається на 1 довжину рядку (тобто рядки 'z'). Без нього f('')називається (оскільки 'z'.slice(0, -1)є ''), який має невизначену поведінку (буквально - спробуйте самі), і це не добре. Очікуваний результат f('z')- '10'це те, що ми отримуємо f('0') + 0, тому використовуємо ||'0'. ( ||'0'особливо корисно, оскільки це не перешкоджає звичайному випадку - rщонайменше 1-довжина ( sпринаймні 2-довжина) - тому що струни фальсифікуються лише тоді, коли вони дорівнюють 0.)

Спосіб нарощування рядка такий же, як і в іншому записі JS: перетворіть базове 36 "число" в фактичне число, додайте 1, а потім перетворите його назад в базу-36. Нам не потрібно хвилюватися з приводу 1збільшення "z" ( 'z'-> '10'), оскільки ми ніколи насправді не збільшуємо "z" (див. Рядки 4 і 6: останній символ збільшується лише, якщо він не 'z').

Крім того, ми ніколи не ризикуємо відкинути провідні нулі, тому що ми ніколи фактично не маніпулюємо більше ніж одним символом одночасно - лише останнім символом у рядку. Решта символів чітко обрізаються, коли ви нарізаєте будь-який рядок і попередньо подані після нього слова.

Чисто , 89 84 байт

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

r o@o r

Спробуйте в Інтернеті!

Коротше рішення завдяки Лайконі .

Чисто , 115 байт

Мені це подобається, коли я отримую користуватися 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)]))

Спробуйте в Інтернеті!

Створює відповідь без перетворення баз, використовуючи відповідність списку.

• ? :: [Char] -> [Char] виконує перенесення вперед.
• @ :: Char -> Charприріст по одному, що враховує розрив між '9'і 'z'.
• $ :: [Char] -> [Char]збільшує останній символ і застосовується, ?поки значення не стабілізується.

R , 152 123 байт

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

Спробуйте в Інтернеті!

Зовсім інший підхід. Отримайте кодові точки ASCII і рекурсивно "збільшуйте" найбільш правою кодовою точкою (змушуючи 0(57) перейти до a(97) і z(122) повернутися до 0(48)), поки не закінчите z. Перетворити назад у рядок.

Стара версія

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

Спробуйте в Інтернеті!

Це все маніпулювання текстом, яке не йде рука об руку з гольф-кодом R.

Замініть всі zна кінці рядків на 0. Знайдіть розташування останнього елемента перед нещодавно відсіченими кінцевими 0s. Знайдіть наступну базову 36 цифру. Внесіть зміни. Будь радий, що ледве побив рішення онлайн-симулятора Turing Machine Simulator.

Зоряний , 325 байт

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

Спробуйте в Інтернеті!

Пояснення:

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

Мова Вольфрама (Mathematica) , 39 байт

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

Спробуйте в Інтернеті!

Python 3.6+ і gmpy2 , 62 байти

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

Спробуйте в Інтернеті!

(Зверніть увагу, що gmpy2 не є частиною стандартної бібліотеки Python і вимагає роздільної установки)

Пайк , 11 байт

? b!!R+bhbt

Спробуйте тут!

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

Може бути на 2 байти коротшим із наступною зміною мови: Якщо використовується шістнадцятковий режим, змініть усі звички base_36 та base_10 на base_92 (що в цьому контексті дійсно не є базовим 92)

sed , 94 байт

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

Спробуйте в Інтернеті!

Sed дуже страждає від необхідності зміни символів за допомогою пошуку.

Zsh , 41 36 байт

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

Спробуйте в Інтернеті!

Желе , 21 байт

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

Спробуйте в Інтернеті!

Використовується великі регістри. TIO-посилання також дозволяє використовувати нижній / змішаний регістр.