वृद्धि बेस -36 स्ट्रिंग्स

20

यह इसी तरह के एक प्रश्न का एक कोड गोल्फ संस्करण है जो मैंने पहले स्टैक पर पूछा था लेकिन सोचा था कि यह एक दिलचस्प पहेली होगी।

लंबाई 10 की एक स्ट्रिंग को देखते हुए जो एक बेस 36 नंबर का प्रतिनिधित्व करता है, इसे एक से बढ़ाता है और परिणामस्वरूप स्ट्रिंग वापस करता है।

इसका मतलब यह है तार केवल से अंक में शामिल होंगे 0करने 9से और पत्र aके लिए z।

बेस 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"
code-golf  string  base-conversion 
— जैक हेल्स
स्रोत
@JoKing कोड-गोल्फ, शांत विचार, और दक्षता मुझे लगता है।
— जैक हेल्स
7
मुझे सिर्फ वेतन वृद्धि को लागू करने का विचार पसंद है क्योंकि इसमें आधार-परिवर्तित के अलावा और पीछे रणनीतियों की क्षमता है।
— xnor
2
PPCG में आपका स्वागत है! यह एक अच्छा चुनौती विचार है, हालांकि जैसा कि कुछ टिप्पणियों ने बताया है, विनिर्देश के कुछ हिस्से अस्पष्ट हैं। भविष्य के लिए मैं हमारे सैंडबॉक्स का उपयोग करने की सलाह देता हूं जहां आप इसे पोस्ट करने से पहले एक चुनौती पर प्रतिक्रिया प्राप्त कर सकते हैं।
— लैकोनी
1
सुझाव है कि आप "0zzzzzzzzz"एक परीक्षण मामले के रूप में कुछ जोड़ते हैं (सबसे अधिक सांकेतिक अंक को संशोधित करें)। ऑफ-वन-एरर के कारण इसने मेरे C सॉल्यूशन को तीन गुना कर दिया।
— OOBalance
1
एक प्रविष्टि जोड़ा गया है यह ठीक है - एक सी प्रविष्टि पहले से ही यह भी करती है।
— फेलिक्स पालमेन

जवाबों:

6

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 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

— अदनान
स्रोत
05AB1E के नए संस्करण में 8 बाइट्स हो सकते हैं ।
— केविन क्रूज़सेन
8

जाप , 13 बाइट्स

n36 Ä s36 ù0A

इसे ऑनलाइन आज़माएं! और परीक्षण मामलों की जाँच करें

एक स्ट्रिंग के रूप में इनपुट लेता है

व्याख्या

n36            converts input to base 36
    Ä           +1
      s36       to base 36 string
          ù0A   left-pad with 0 to length 10
— crashoz
स्रोत
Japt में आपका स्वागत है! :)
— झबरा
8

जावास्क्रिप्ट (ईएस 6), 45 बाइट्स

सहेजे गए 4 बाइट्स @OOBalance की बदौलत

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

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत
तुम पागल हो, अच्छा है। +1
— जैक हेल्स
2
45 बाइट्स: bit.ly/2K5tjw0
— OOBalance
मुझे नहीं लगता कि ES8 अब नवीनतम गोल्फ के बाद ...
— डाउनगोट
@Downgoat धन्यवाद! आप सही हे। अपडेट किया गया।
— अरनुलद
7

हास्केल , 58 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक बहुत ही क्रूर बल रणनीति: सभी लंबाई -10 आधार -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 के प्रत्यय के बाद किसी वर्ण तक नहीं पहुंच जाता है, जो खाली हो सकता है। उस चरित्र को बढ़ाता है, और 0 के साथ z की जगह लेता है।

— XNOR
स्रोत
6

सी (जीसीसी) , 50 48 बाइट्स

एक स्पष्ट कैरी फ्लैग लूप के पुनर्गठन के बाद जरूरी नहीं था कि जैसे ही कोई कैरी होगा। 9-> लूप चेक के दौरान एक समायोजन किया जाता है।

सुझाव के लिए सीलिंग के लिए धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

मूल संस्करण: 71 57 बाइट्स

यह संस्करण अद्यतनों को प्रचारित करने के लिए एक कैरी फ़्लैग का उपयोग करता है: मैंने वेतन वृद्धि शुरू करने के लिए इसे सच कर दिया। स्ट्रिंग को जगह में संशोधित किया गया है और केवल 0-9, AZ को स्वीकार करता है। मुश्किल हिस्सा यह सुनिश्चित कर रहा था कि 9-> एक को सही ढंग से किया जाता है।

संपादित करें: मैंने कैरी फ्लैग के रूप में इनपुट पॉइंटर को फिर से तैयार किया।

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

इसे ऑनलाइन आज़माएं!

— ErikF
स्रोत
6

सी, 82 81 53 50 बाइट्स

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

सीधे इनपुट स्ट्रिंग को संशोधित करता है; इनपुट और आउटपुट ऊपरी मामले में है। इसे यहाँ ऑनलाइन आज़माएँ । करने के लिए धन्यवाद Arnauld 24 बाइट्स गोल्फ के लिए और करने के लिए ceilingcat 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)
 }
— OOBalance
स्रोत
मुझे लगता है कि यह सुरक्षित होना चाहिए: 60 बाइट्स
— अरनौल्ड
1
@ अरनल्ड आप स्ट्रिंग से पहले एक शून्य बाइट नहीं मान सकते ...
— जैकब
1
@ जाकोब मैं उस बारे में 100% निश्चित नहीं हूं। हम भाषाओं को उनके कार्यान्वयन द्वारा परिभाषित करते हैं। यह एक TIO VM पर चलने वाला C (gcc) है, जहाँ मेमोरी हो सकती है - मुझे लगता है - शुरू में क्लियर माना जाता है। (मैंने अन्य सी उत्तर देखे हैं जो समान धारणाएं बनाते हैं।)
— अरनॉल्ड
2
'कार्यान्वयन' में परीक्षण के वातावरण को शामिल करके, मैं इसे एक मंच पर ले जा सकता हूं। लेकिन आप अभी भी 60-बाइट संस्करण का उपयोग कर सकते हैं जो किसी भी स्मृति धारणा पर निर्भर नहीं करता है।
— अरनुलद
1
@Arnauld मैंने एक और 4 बाइट्स गलाई हैं। यह वास्तव में सुरक्षित होना चाहिए, क्योंकि हमें संभालना नहीं है ZZZZZZZZZZ। ErikF का उत्तर भी यही करता है, लेकिन इससे भी कम: codegolf.stackexchange.com/a/169468/79343
— OOBalance
5

ऑनलाइन ट्यूरिंग मशीन सिम्युलेटर , 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,<

ऑनलाइन दुभाषिया

— आउटग्रॉफर को एरिक करें
स्रोत
5

पर्ल 6 , 34 32 30 बाइट्स

oकार्यों के संयोजन के लिए ऑपरेटर के उपयोग के माध्यम से -2 बाइट्स के लिए nwellnhof के लिए धन्यवाद

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

इसे ऑनलाइन आज़माएं!

फ़ंक्शन जो आधार को 36 में कनवर्ट करता है, 1 जोड़ता है, वापस धर्मान्तरित करता है और फिर इसे प्रारूपित करता है। अब अग्रणी जीरो को संरक्षित करने के लिए अदनान के जवाब के रूप में उसी रणनीति का उपयोग करता है ।

— मजाक कर रहा है
स्रोत
{S/.//}o{base :36(1~$_)+1: 36}30 बाइट्स के लिए।
— nwellnhof
@nwellnhof नीट! oजब मैंने पहले गोल्फ का उपयोग करने के लिए कभी सोचा नहीं था , लेकिन मैं देख सकता हूं कि यह कहां उपयोगी हो सकता है!
— जो किंग
आह, यह अफ़सोस की बात है कि .succ( एक के बाद एक वेतन वृद्धि) काम नहीं करता है
— जो किंग
4

हास्केल , 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, उत्तराधिकारी फ़ंक्शन जो कि चार्ट पर उपयोग किए जा सकते हैं क्योंकि वे इसका एक उदाहरण हैं Enum वर्ग ।

अंत में परिणामी स्ट्रिंग फिर से उलट है।

— Laikoni
स्रोत
4

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 , सभी मूल NMOS 6502 चिप्स पर काम करता है, बाद में CMOS वेरिएंट पर नहीं।

में $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
— फेलिक्स पालमेन
स्रोत
1
65C02 संस्करण ISB को त्याग सकता है, फिर LDA (), Y (और .done एक पंक्ति से ऊपर) के बाद INC का उपयोग कर सकता है और एक बाइट से छोटा हो सकता है।
— पीटर फेरी
@peterferrie के पास accu के लिए 65C02 का INC है?
— फेलिक्स पैलमेन
@peterferrie ठीक है, यह अच्छा है - कि मैं 6502 पर पहली जगह में क्या याद कर रहा था :)
— फेलिक्स Palmen
3

रेटिना 0.8.2 , 12 बाइट्स

T`zo`dl`.z*$

इसे ऑनलाइन आज़माएं! व्याख्या: dlप्रतिस्थापन गंतव्य का हिस्सा स्रोत तक उन प्रतियों 0-9a-zको oफैलाता है, जिसके परिणामस्वरूप z0-9a-z(हालांकि दूसरा zअनदेखा हो जाता है क्योंकि यह कभी भी मेल नहीं खा सकता है)। यह मिलान किए गए अंकों को बढ़ाता है। .z*$पैटर्न का हिस्सा पिछले गैर- zअंकों के साथ - साथ सभी अनुगामी zएस से मेल खाता है , इस प्रकार उनकी वृद्धि से ले जाने को संभालता है 0।

— नील
स्रोत
3

रूबी , 40 बाइट्स

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

इसे ऑनलाइन आज़माएं!

  1. स्ट्रिंग को पूर्णांक में रूपांतरित करते हुए इसे आधार 36 के रूप में व्याख्यायित करते हैं
  2. 1 जोड़ें
  3. बेस 36 स्ट्रिंग में वापस कनवर्ट करें
  4. बाएं पैड के साथ 0एस

"zzzzzzzzzz" 11-लंबी स्ट्रिंग लौटाता है

— असोन तुहिद
स्रोत
3

अप्ल (डाइलॉग यूनिकोड) , 30 28 24 बाइट्स

कुछ बाइट्स को बचाने के संकेत के लिए ngn के लिए धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

  • 0 के RequiresIO की आवश्यकता है

  • ऊपरी मामले का उपयोग करता है

— jslip
स्रोत
क्यों नहीं एक कदम आगे बढ़ें और इसका '1',हिस्सा बनें f? फिर 1↓
— ngn
@ नमस्कार, धन्यवाद!
— jslip
इससे भी कम: (⎕D,⎕A)⍳'1',->1,(⎕D,⎕A)⍳
— ngn
एक अंतिम सुधार - इसे एक ट्रेन के रूप में फिर से लिखा जा सकता है:(f⍣¯1)1+f←36⊥1,(⎕D,⎕A)⍳⊢
— ngn
3

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
एक और 68 बाइट्स संस्करण: इसे ऑनलाइन आज़माएं! आप अपना उपयोग कर सकते हैं -Rऔर इस एक 66 बाइट्स को भी कॉल कर सकते हैं ।
— रात 2
1
@ रात 2 अच्छा दृष्टिकोण; लेकिन इसे और भी छोटा किया जा सकता है:printf('%010s',($b=base_convert)(1+$b($argn,36,10),10,36)); - 59 बाइट्स
— टाइटस
1
अच्छा है। पता नहीं था कि हम इस तरह से एक समारोह कह सकते हैं:($b=base_convert)(a,b,c) :। मैं आपसे बहुत कुछ सीख रहा हूं।
— Night2
2

चारकोल , 14 बाइट्स

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

इसे ऑनलाइन आज़माएं!लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

×0⁹

प्रिंट 9 0 एस। यह परिणाम पैड करने के लिए कार्य करता है।

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

इनपुट को बेस 36 से परिवर्तित करें, इसे इंक्रीमेंट किया, फिर वापस बेस 36 में कन्वर्ट करें। फिर, परिणाम को उल्टा करें और इसे बाईं ओर प्रिंट करें।

— नील
स्रोत
2

जावा 8, 90 76 56 बाइट्स

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

इनपुट के लिए अपर-केस और लोअर-केस दोनों पत्रों को स्वीकार करता है। आउटपुट हमेशा निचले मामले में होता है।

ओकेक्स के लिए धन्यवाद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'
— OOBalance
स्रोत
अच्छा! पुराने जावा में भविष्य के संदर्भ के लिए आप कुछ ऐसा कर सकते हैं जैसे"".format("%10s",t).replace(' ','0')
— जैकब
@ जाकोब धन्यवाद, यही मैं ढूंढ रहा था।
— OOBalance
यह 1शुरू में इसे हटाने पर इसे जोड़ने के दृष्टिकोण का उपयोग करने के लिए कम है :s->Long.toString(Long.valueOf("1"+s,36)+1,36).substring(1)
— Okx
@ ओएक्सएक्स अच्छा तरीका। 2 और बाइट्स: "1"+s=>1+s
— OOBalance
2

जावास्क्रिप्ट (ईएस 6), 89 बाइट्स

यह अन्य जावास्क्रिप्ट प्रविष्टि के रूप में लगभग बाइट-कुशल नहीं है , लेकिन मैंने इस नियम को ध्यान दिए बिना बनाया है:

लंबाई 10 की एक स्ट्रिंग दी

तो यह एक गंभीर प्रविष्टि नहीं है - सिर्फ मनोरंजन के लिए! यह सामान्य लंबाई के तार के साथ काम करता है, जैसे कि 0abc, और 1जब पहला अंक होता है z, जैसे कि prepends , जैसे 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)वास्तव में मतलब है "डू ए, फिर बी करें, फिर सी वापस करें", जिसे मैं कोड में पुन: उपयोग किए जाने वाले कुछ चर घोषित करने के लिए उपयोग करता हूं। 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'विशेष रूप से उपयोगी है क्योंकि यह सामान्य मामले के रास्ते में नहीं आता है - rकम से कम 1-लंबाई ( sकम से कम 2-लंबाई) होने के कारण - क्योंकि तार केवल 0-लंबाई के होने पर ही गलत होते हैं।)

एक स्ट्रिंग को बढ़ाने के लिए विधि अन्य जेएस प्रविष्टि में उपयोग के समान है: आधार -36 "संख्या" को वास्तविक संख्या में परिवर्तित करें, 1 जोड़ें, फिर इसे वापस बेस -36 में बदल दें। हमें 1'z' ( 'z'-> '10') को बढ़ाने से चिंतित होने की आवश्यकता नहीं है , क्योंकि हम वास्तव में 'z' को कभी नहीं बढ़ाते हैं (पंक्ति 4 और 6 देखें: अंतिम वर्ण केवल बढ़ा हुआ है यदि यह 'z' नहीं है)।

इसके अलावा, हम कभी भी अग्रणी शून्य को त्यागने का जोखिम नहीं उठाते हैं, क्योंकि हम वास्तव में कभी भी एक बार में एक से अधिक वर्णों में हेरफेर नहीं करते हैं - केवल स्ट्रिंग में अंतिम वर्ण। जैसा कि आप किसी भी स्ट्रिंग को स्लाइस करते हैं और उसके बाद आने वाले वर्णों को बाकी पात्रों को साफ-सुथरा कर दिया जाता है।

— फ्लोररी
स्रोत
2

क्लीन , 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]अंतिम चरित्र को बढ़ाता है और ?तब तक लागू होता है जब तक कि मूल्य स्थिर नहीं हो जाता।
— Οurous
स्रोत
1
कम फैंसी, लेकिन काफी छोटा: ऑनलाइन प्रयास करें!
— लकोनी
@ लिकोनी में संपादित, धन्यवाद!
— Οurous
2

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

इसे ऑनलाइन आज़माएं!

यह सभी पाठ हेरफेर है, जो आर कोड गोल्फिंग के साथ हाथ से हाथ नहीं जाता है।

zस्ट्रिंग्स के अंत में सभी को बदलें 0। नए खनन से पहले अंतिम तत्व का स्थान ज्ञात करें 0। अगला आधार 36 अंकों का पता लगाएं। परिवर्तन करना। ऑनलाइन ट्यूरिंग मशीन सिम्युलेटर समाधान को मुश्किल से पीटा जाना खुशी होगी।

— एन जी एम
स्रोत
आप इससे बेहतर तरीके से कर सकते हैं !! मुझे लगता है कि मेरे पास 72 बाइट्स हैं, अगर आप सही तरीके से निर्मित पा सकते हैं ...
— Giuseppe
उफ़ ... लगा कि यह चुनौती कोड बॉलिंग है!
— एन जी एम
अच्छी तरह से निर्मित में strtoiआपको आरंभ करना है; वहाँ कुछ और अधिक करने के लिए इसे नीचे पाने के लिए गोल्फिंग चालें हैं।
— Giuseppe
1
strtoiहालांकि छोटी संख्या तक सीमित है? मैंने कुछ समय पहले इस पर ध्यान दिया था।
— एनसीएम
ओह मैं समझा। यह एहसास नहीं था कि intप्रतिबंध इतना समस्याग्रस्त था। क्षमा! पोस्टरिटी के लिए, यह मेरा असफल समाधान था: इसे ऑनलाइन आज़माएं!
— Giuseppe
2

तारों से , 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
| +   '
— साशा
स्रोत
1

अजगर 3.6+ और gmpy2 , 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

(ध्यान दें कि gmpy2 पायथन मानक पुस्तकालय का हिस्सा नहीं है और अलग स्थापना की आवश्यकता है)

— trolley813
स्रोत
मुझे नहीं लगता कि आपको इसकी आवश्यकता है f=। बेनामी कार्यों को आमतौर पर कोड गोल्फ में पाया जाता है।
— मैथिलियन
1

पाइके , 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 नहीं है)

— नीला
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.