이것은 이전에 스택에서 물 었지만 비슷한 퍼즐이라고 생각 되는 비슷한 질문의 코드 골프 버전 입니다.

기수 36의 숫자를 나타내는 길이가 10 인 문자열이 주어지면 1 씩 증가시키고 결과 문자열을 반환합니다.

이 문자열은에서 숫자가 포함됩니다 의미 0에 9에서와 문자 a로 z.

기본 36은 다음과 같이 작동합니다.

가장 오른쪽 숫자는 먼저 0to 를 사용하여 증가 합니다.9

0000000000> 9 개의 반복> 0000000009

그 후에 a~ z가 사용됩니다.

000000000a> 25 회 반복> 000000000z

z증분해야하는 경우 다시 0으로 루프되고 왼쪽의 숫자가 증분됩니다.

000000010

추가 규칙 :

• 대문자 나 소문자를 사용할 수 있습니다.
• 선행 0을 제거 할 수 없습니다 . 입력과 출력은 모두 길이가 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

자바 스크립트 (ES6), 45 바이트

@OOBalance 덕분에 4 바이트 절약

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 인 base-36 문자열을 순서대로 생성하고 목록에서 입력 뒤에 오는 문자열을 찾으십시오. 목록의 시작 부분에서 멀리 떨어진 문자열에 엄청난 시간이 걸립니다.

하스켈 , 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으로 바꿉니다.

Stax , 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-> A 조정이 수행됩니다.

제안에 대한 천장 고양이 덕분에.

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

온라인으로 사용해보십시오!

원본 버전 : 71 57 바이트

이 버전은 캐리 플래그를 사용하여 업데이트를 전파합니다. 증가를 시작하기 위해 진실로 설정했습니다. 문자열은 내부에서 수정되며 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 바이트를 골프과에 ceilingcat 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,<

온라인 통역사

펄 6 , 34 32 30 바이트

o연산자를 사용하여 기능을 결합하여 -2 바이트의 nwellnhof 덕분에

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

온라인으로 사용해보십시오!

인수를 기수 36으로 변환하고 1을 더한 다음 다시 변환 한 다음 형식을 지정하는 함수입니다. 이제 Adnan의 대답 과 동일한 전술을 사용 하여 선행 0을 보존하십시오.

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

하스켈 , 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다음 문자는 재귀 적으로 확인됩니다.
• 다른 모든 문자는 Enum 클래스succ 의 인스턴스이기 때문에 Chars에서 사용할 수있는 후속 함수 인을 사용하여 증가 합니다.

마지막으로 결과 문자열이 다시 반전됩니다.

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

*)는 "불법"opcode ISB/를 사용하며 0xF3, 최신 CMOS 변형이 아닌 모든 원본 NMOS 6502 칩에서 작동합니다.

$fb/ 에있는 10 자 문자열에 대한 포인터를 $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 자 길이의 문자열을 반환

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

... 또는 온라인으로 사용해보십시오 .

파이썬 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으로 다시 변환합니다. 그런 다음 결과를 반전시키고 왼쪽으로 인쇄합니다.

자바 8, 90 76 56 바이트

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

대문자와 소문자를 모두 입력 할 수 있습니다. 출력은 항상 소문자입니다.

18 바이트 골프 를 한 Okx 에게 감사 합니다.

여기에서 온라인으로 사용해보십시오 .

언 골프 드 :

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'

자바 스크립트 (ES6), 89 바이트

이것은 다른 JavaScript 항목 만큼 바이트 효율적이지 않지만이 규칙에 유의하지 않고 이것을 만들었습니다.

길이가 10 인 문자열 이 주어짐

따라서 이것은 진지한 항목이 아닙니다-단지 재미를 위해서입니다! 예를 들어 - 0abc와 같은 일반 길이의 문자열과 함께 작동 1하고 첫 번째 숫자가 a 인 경우 앞에 붙습니다 . 입력은 소문자 여야합니다.zzzz1000

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, 그것은 마지막 문자에 이르기까지에 (자체를 실행하는 것 z)를하고, 대체 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 일 때만 거짓이기 때문에 일반적인 경우를 ||'0'방해하지 않기 때문에 특히 유용합니다. 1 길이 이상 (2 길이 이상).rs

문자열을 증가시키는 방법은 다른 JS 항목에서 사용 된 것과 동일합니다. base-36 "number"를 실제 숫자로 변환하고 1을 더한 다음 base-36으로 다시 변환하십시오. 실제로는 'z'를 증가시키지 않기 때문에 1증가하는 'z'( 'z'-> '10') 에 대해 걱정할 필요가 없습니다 (4 행 및 6 행 참조 : 마지막 문자는 'z'가 아닌 경우에만 증가 함).

또한 한 번에 하나 이상의 문자를 실제로 조작하지 않고 문자열의 마지막 문자 만 처리하므로 선행 0을 버릴 위험이 없습니다. 문자열과 접두사 뒤에 단어를 슬라이스 할 때 나머지 문자는 완전히 분리됩니다.

클린 , 89 84 바이트

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

r o@o r

온라인으로 사용해보십시오!

Laikoni 덕분에 더 짧은 솔루션 .

클린 , 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'와 사이의 간격을 고려하여 1 씩 증가합니다 'z'.
• $ :: [Char] -> [Char]마지막 문자를 증가시키고 ?값이 안정화 될 때까지 적용됩니다 .

R , 152123 바이트

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. 새로 발행 된 후행 전에 마지막 요소의 위치를 ​​찾으십시오 0. 다음 기본 36 자리를 찾으십시오. 변경하십시오. 온라인 튜링 머신 시뮬레이터 솔루션을 간신히 구타하게되어 기쁩니다.

별이 빛나는 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
| +   '

Wolfram Language (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 바이트가 짧을 수 있습니다. 16 진수 모드를 사용하는 경우 모든 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 링크를 사용하면 대소 문자를 혼합 할 수도 있습니다.