นี่เป็นคำถามที่คล้ายกันที่ฉันถามในรุ่นก่อนหน้านี้แต่ฉันคิดว่ามันเป็นปริศนาที่น่าสนใจ

รับสายอักขระที่มีความยาว 10 ซึ่งแทนหมายเลขฐาน 36 เพิ่มทีละหนึ่งและส่งคืนสตริงผลลัพธ์

ซึ่งหมายความว่าสายจะมีเพียงตัวเลขจาก0ไป9และตัวอักษรจากไปaz

ฐาน 36 ทำงานดังนี้:

ตัวเลขที่ถูกต้องที่สุดคือการเพิ่มค่าครั้งแรกโดยใช้0เพื่อ9

0000000000> 9 ซ้ำ> 0000000009

และหลังจากนั้นaจะ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)

ลองออนไลน์!

Haskell , 58 ไบต์

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

ลองออนไลน์!

กลยุทธ์การบังคับเดรัจฉาน: สร้างสตริง -10 base-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

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-> การปรับจะดำเนินการระหว่างการตรวจสอบลูป

ขอบคุณสำหรับคำแนะนำ

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

ลองออนไลน์!

รุ่นดั้งเดิม: 71 57 ไบต์

รุ่นนี้ใช้ธงพกพาเพื่อเผยแพร่การปรับปรุง: ฉันตั้งค่าเป็นความจริงเพื่อเริ่มต้นการเพิ่มขึ้น สตริงมีการแก้ไขในสถานที่และยอมรับ 0-9, AZ เท่านั้น ส่วนที่ยุ่งยากคือทำให้แน่ใจว่า 9-> A ได้รับการจัดการอย่างถูกต้องในการพกพา

แก้ไข: ฉัน repurposed ตัวชี้เข้าเป็นธงพก

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 ไบต์

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

ทัวริงเครื่องจำลองออนไลน์ 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 bytes ผ่านการใช้oโอเปอเรเตอร์เพื่อรวมฟังก์ชั่น

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

ลองออนไลน์!

ฟังก์ชันที่แปลงอาร์กิวเมนต์เป็นฐาน 36 เพิ่ม 1 แปลงกลับแล้วจัดรูปแบบ ตอนนี้ใช้กลยุทธ์เดียวกับคำตอบของ Adnanเพื่อรักษาศูนย์นำ

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

ลองออนไลน์! ย้อนกลับสตริงและตรวจสอบอักขระตัวแรก:

• จะถูกแทนที่โดย9a
• 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หลักรวมทั้งหมดต่อท้ายzs 0จึงจัดการนำติดตัวมาจากการเพิ่มขึ้นของพวกเขาไป

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

... หรือลองพวกเขาออนไลน์

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 ไบต์

ลองออนไลน์ได้ที่นี่ที่นี่

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 เหมือนกับรายการ JavaScript อื่น ๆแต่ฉันทำสิ่งนี้โดยไม่สังเกตเห็นกฎนี้:

รับค่าสตริงความยาว 10

ดังนั้นนี่ไม่ใช่รายการที่ร้ายแรง - เพื่อความสนุก! จะทำงานร่วมกับสตริงของความยาวทั่วไปเช่น0abcและ prepends 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หมายถึง "string" lหมายถึง "last" rหมายถึง "rest"

/*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) และแทนที่ a0 (ดูบรรทัดที่ 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 อื่น: แปลง base-36 "number" เป็นตัวเลขจริงเพิ่ม 1 จากนั้นแปลงกลับเป็น base-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

ลองออนไลน์!

วิธีการแก้ปัญหาที่สั้นกว่าขอบคุณที่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''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 s แปลงกลับเป็นสตริง

เวอร์ชั่นเก่า

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 หลัก ทำการเปลี่ยนแปลง มีความยินดีที่ได้เอาชนะ Online 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
| +   '

ภาษา Wolfram (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 standard library และต้องมีการติดตั้งแยกต่างหาก)

Pyke 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 ไบต์ด้วยการเปลี่ยนแปลงภาษาต่อไปนี้: หากใช้โหมด hex ให้เปลี่ยนการใช้ 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 ช่วยให้ตัวพิมพ์เล็ก / ใหญ่ผสมกัน