Bu, daha önce yığınta sordum ama ilginç bir bulmaca olacağını düşündüm benzer bir sorunun kod golf versiyonu .

Bir taban 36 numarasını temsil eden bir uzunluk 10 dizesi verildiğinde, bunu birer birer artırın ve elde edilen dizeyi döndürün.

Bu dizeleri sadece gelen rakamları içereceği anlamına gelir 0için 9gelen ve mektuplar aiçin z.

Temel 36 şu şekilde çalışır:

Sağ çoğu haneli birinci kullanarak, artırılır 0için9

0000000000> 9 iterasyon> 0000000009

ve bundan sonra aTo zkullanılır:

000000000a> 25 yineleme> 000000000z

Artırılması zgerekiyorsa sıfıra geri döner ve solundaki rakam artar:

000000010

Diğer kurallar:

• Büyük veya küçük harfler kullanabilirsiniz.
• Sen olabilir değil baştaki sıfırları bırakın. Hem giriş hem de çıkış 10 uzunluklu dizelerdir.
• Giriş olarak işlem yapmanıza gerek yoktur zzzzzzzzzz.

Test Durumları:

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

05AB1E , 10 bayt

Giriş büyük harflidir .

kod

1ì36ö>36B¦

açıklama

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 kodlamasını kullanır . Çevrimiçi deneyin! veya Tüm test senaryolarını doğrulayın .

Japt , 13 bayt

n36 Ä s36 ù0A

Çevrimiçi deneyin! ve Test senaryolarını doğrulayın

Girişi dize olarak alır

açıklama

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

JavaScript (ES6), 45 bayt

@OOBalance sayesinde 4 bayt tasarruf edildi

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

Çevrimiçi deneyin!

Haskell , 58 bayt

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

Çevrimiçi deneyin!

Çok kaba bir strateji: tüm uzunluk-10 taban-36 dizelerini sırayla oluşturun ve listedeki girdiden sonra geleni bulun. Listenin başlangıcından uzakta dizelerde muazzam bir zaman ayırın.

Haskell , 60 bayt

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

Çevrimiçi deneyin!

Dizeyi, boş olabilen tüm z'lerin sonekini takip eden bir karaktere ulaşıncaya kadar soldan sağa doğru okur. Bu karakteri artırır ve z'leri 0'larla değiştirir.

Stax , 7 bayt

ûæ≥╡►N▀

Çalıştır ve hata ayıkla

Açıklama:

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

Döngünün yeniden taşınmasından hemen sonra sona erecek şekilde yeniden yapılandırıldıktan sonra açık bir taşıma bayrağı gerekli değildi. Döngü kontrolü sırasında 9-> A ayarı yapılır.

Öneri için ceilingcat'e teşekkürler.

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

Çevrimiçi deneyin!

Orijinal versiyon: 71 57 bayt

Bu sürüm, güncellemeleri yaymak için bir taşıma bayrağı kullanır: Artışı başlatmak için gerçeğe ayarlayın. Dize yerinde değiştirilir ve yalnızca 0-9, AZ kabul eder. Zor kısmı 9-> A'nın taşımalarda doğru bir şekilde ele alındığından emin oluyordu.

Düzenleme: Giriş işaretçisini taşıma bayrağı olarak yeniden konumlandırdım.

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

Çevrimiçi deneyin!

C, 82 81 53 50 bayt

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

Giriş dizesini doğrudan değiştirir; giriş ve çıkış büyük harflidir. Burada çevrimiçi deneyin . 24 bayt golf için Arnauld ve 3 bayt golf için ceilingcat için teşekkürler .

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

Online Turing Machine Simulator , 745 bayt

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

Çevrimiçi tercüman

Perl 6 , 34 32 30 bayt

oFonksiyonları birleştirmek için operatörün kullanımı ile -2 baytlık nwellnhof sayesinde

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

Çevrimiçi deneyin!

Bağımsız değişkeni temel 36'ya dönüştüren, 1 ekleyen, geri dönüştüren ve sonra biçimlendiren işlev. Şimdi önde gelen sıfırları korumak için Adnan'ın cevabı ile aynı taktiği kullanıyor .

MATL , 12 bayt

36ZAQ5M10&YA

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin! Dizeyi tersine çevirir ve ilk karakteri kontrol eder:

• A 9yerine bir a.
• A z, a ile değiştirilir 0ve ardışık olarak bir sonraki karakter kontrol edilir.
• Diğer tüm karakterler succ, Enum sınıfının bir örneği oldukları için Chars'ta kullanılabilen halef işlevi kullanılarak artırılır .

Son olarak, ortaya çıkan dize tekrar ters çevrilir.

6502 (NMOS *) makine kodu rutini, 26 bayt

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

*) "geçersiz" bir opcode ISB/ kullanır 0xF3, daha sonraki CMOS varyantlarında değil, tüm orijinal NMOS 6502 yongalarında çalışır.

Bir 10 karakterli dizgeye bir gösterici bekler $fb/ ' $fc, bir baz-36 numara olması beklenmektedir. Bu sayıyı yerinde artırır.

Geçersiz girişte mantıklı bir şey yapmaz (örneğin daha kısa bir dize gibi) - ZZZZZZZZZZkazayla "doğru" işler ;)

Yorumlanan sökme

; 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

Rutini kullanan örnek C64 montaj programı:

Çevrimiçi demo

Ca65 sözdizimindeki kod :

.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 bayt

T`zo`dl`.z*$

Çevrimiçi deneyin! Açıklama: dlikamesi hedefin parçası genişler 0-9a-ziken okopya sonuçlanan kaynağına, bu z0-9a-z(ikinci rağmen zdikkate alır o maç asla gibi). Bu eşleşen rakamları arttırır. Desenin bir .z*$kısmı son zrakam olmayan artı tüm izleyen noktalarla eşleşir z, böylece taşıma artışlarına kadar taşınır 0.

Yakut , 40 bayt

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

Çevrimiçi deneyin!

1. Dizeyi temel 36 olarak yorumlayan bir tam sayıya dönüştürün
2. 1 ekle
3. Temel 36 dizgeye dön
4. Sol ped 0s ile

"zzzzzzzzzz" 11 uzunluğunda bir dize döndürür

brainfuck , 109 bayt

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

Çevrimiçi deneyin!

Apl (Dyalog Unicode) , 30 28 24 bayt

Bazı baytları kaydetme ipucu için ngn'e teşekkürler.

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

Çevrimiçi deneyin!

• 0 ⎕IO gerektirir

• Büyük harf kullanır

PHP, 69 64 bayt

topal versiyonu :

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

İle boru olarak çalıştırın -R. Giriş büyük / küçük harfe duyarlı değil, küçük harf çıktı.

ilk yaklaşım, 69 bayt:

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

İle boru olarak çalıştır -F

döngü sürümü, ayrıca 69 bayt :

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

• Yalnızca PHP 7.1: Eski PHP negatif dize dizinlerini anlamıyor,
  genç PHP tanımsız sabitler için uyarılar verecektir.
• büyük harf girişi gerektirir. Değiştir Yve Aküçük girişi için küçük harfler ile.

İle boru olarak çalıştır -nR

... veya çevrimiçi deneyin .

Python 2 , 88 bayt

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

Çevrimiçi deneyin!

Dizeyi "el ile" artırır.

Kömür , 14 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

×0⁹

9 0sn yazdırın . Bu, sonucu doldurmaya yarar.

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

36 tabanından girişi dönüştürün, artırın, ardından 36 tabanına dönüştürün. Sonra sonucu tersine çevirin ve sola yazdırın.

Java 8, 90 76 56 bayt

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

Giriş için hem büyük hem de küçük harfleri kabul eder. Çıktı her zaman küçük harflidir.

18 bayt golf için Okx için teşekkürler .

Burada çevrimiçi deneyin .

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 bayt

Bu , diğer JavaScript girişi kadar neredeyse bayt verimli değil, ancak bu kuralı fark etmeden bunu yaptım:

10 uzunluk dizesi verildi

Yani bu ciddi bir giriş değil - sadece eğlence için! Gibi genel uzunluktaki dizelerle çalışır ve ilk hane olduğu zaman 0abca ekler , örneğin -> . Giriş küçük harf olmalıdır.1zzzz1000

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çıklama

İfade (A, B, C)aslında kodda yeniden kullandığım bazı değişkenleri bildirmek için kullandığım "do A, sonra B, sonra C geri" anlamına gelir. s"string" lanlamına gelir, "last" ranlamına gelir, "rest" anlamına gelir.

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

Bu özyinelemeli bir işlevdir. Gibi tipik bir dize için aza, son karakteri arttıracaktır (bakınız satır 6) - azb. Ama bir dize için olan uçlar olduğunu z, böyle h0gz, son karaktere şeyi yukarı (kendisi çalışacak z) ve yerine 0bunun yerine (satır 5) - f(h0gz)= f(h0g) + 0= h0h0.

||'0'5. satırda bir 1 uzunlukta dize (yani dize üzerinde deniyor zaman işlevi çalıştığını böyledir 'z'). Onsuz , tanımlanmamış davranışa sahip olan f('')( 'z'.slice(0, -1)olduğu gibi '') denir ( kelimenin tam anlamıyla - kendiniz deneyin) ve bu iyi değil. Beklenen sonuç f('z')olduğunu '10'biz aldığım budur, f('0') + 0kullandığımız yüzden ||'0'. ( ||'0'özellikle kullanışlıdır, çünkü en az 1 uzunlukta ( en az 2 uzunlukta) olağan durumun önüne geçmez - çünkü dizeler yalnızca 0 uzunlukta olduklarında falseydir.)rs

Bir dizeyi arttırma yöntemi diğer JS girişinde kullanılanla aynıdır: base-36 "numarasını" gerçek bir sayıya dönüştürür, 1 ekler ve sonra tekrar base-36'ya dönüştürür. Yaklaşık endişe gerekmez 1(artan 'z' den 'z'-> '10'), biz asla aslında artım 'z' beri (: o z 'değilse son karakter yalnızca artırılır hattı 4 ve 6 bakınız).

Ayrıca, asla sıfırları atma riskini göze alamayız, çünkü tek seferde tek bir karakterden fazlasını manipüle etmiyoruz - sadece dizideki son karakter. Karakterleri geri kalanı, herhangi bir dizeyi dilimlediğinizde ve sonradan eklenen kelimelerden sonra temiz bir şekilde dilimlenir.

Temiz , 89 84 bayt

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

r o@o r

Çevrimiçi deneyin!

Laikoni sayesinde daha kısa bir çözüm .

Temiz , 115 bayt

Kullanmaya başladığımda seviyorum 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)]))

Çevrimiçi deneyin!

Liste eşlemeyi kullanarak üsleri dönüştürmeden cevabı üretir.

• ? :: [Char] -> [Char] ileri taşıma yapar.
• @ :: Char -> Char'9've arasındaki boşluğu hesaba katarak birer birer artışlar 'z'.
• $ :: [Char] -> [Char]son karakteri artırır ve ?değer dengelenene kadar uygulanır .

R , 152123 bayt

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

Çevrimiçi deneyin!

Tamamen farklı bir yaklaşım. (Yapmak "artım" en sağdaki kod noktası yinelemeli ASCII kod puan alın ve 0için için (57) atlama a97 () ve zgeri dönmek (122) 0Eğer bitene kadar (48)) zs. Dizeye geri dönüştür.

Eski versiyon

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

Çevrimiçi deneyin!

Bu, R kodu golf ile el ele gitmeyen tüm metin manipülasyonudur.

Tümünü değiştir zile dizeleri sonunda 0. Yeni basılan sondan önceki son elemanın yerini bulun 0. Bir sonraki temel 36 basamağını bulun. Değişikliği yapın. Online Turing Machine Simulator çözümünü zar zor geçtiğiniz için mutlu olun.

Yıldızlı , 325 bayt

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

Çevrimiçi deneyin!

Açıklama:

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 Dili (Mathematica) , 39 bayt

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

Çevrimiçi deneyin!

Python 3.6+ ve gmpy2 , 62 bayt

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

Çevrimiçi deneyin!

(Gmpy2'nin Python standart kütüphanesinin bir parçası olmadığını ve ayrı kurulum gerektirdiğini unutmayın)

Pyke , 11 bayt

? b!!R+bhbt

Burada deneyin!

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

Aşağıdaki dil değişikliği ile 2 bayt daha kısa olabilir: Hex modu kullanılıyorsa, tüm base_36 ve base_10 kullanıcılarını base_92 olarak değiştirin (bu bağlamda gerçekten temel 92 olmayan)

sed , 94 bayt

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

Çevrimiçi deneyin!

Sed, karakterleri arama yaparak değiştirmek zorunda kaldığı için çok acı çekiyor.

Zsh , 41 36 bayt

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

Çevrimiçi deneyin!

Jöle , 21 bayt

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

Çevrimiçi deneyin!

Büyük harf kullanır. TIO bağlantısı küçük / karma kasaya da izin verir.