বেস বেস 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 
— জ্যাক হেলস
সূত্র
@ জোকিং কোড-গল্ফ, দুর্দান্ত ধারণা এবং দক্ষতা আমার ধারণা।
— জ্যাক হেলস
7
আমি কেবলমাত্র ইনক্রিমেন্ট অপারেশন বাস্তবায়নের ধারণাটি পছন্দ করি কারণ এটিতে সেখানে এবং পিছনে বেস-রূপান্তরকরণ ব্যতীত অন্য কৌশলগুলির সম্ভাবনা রয়েছে।
— xnor
2
পিপিসিজিতে আপনাকে স্বাগতম! এটি একটি দুর্দান্ত চ্যালেঞ্জ ধারণা, তবে কিছু মন্তব্য যেমন উল্লেখ করেছে, নির্দিষ্টকরণের কিছু অংশ অস্পষ্ট। ভবিষ্যতের জন্য আমি আমাদের স্যান্ডবক্স ব্যবহার করার পরামর্শ দিচ্ছি যেখানে পোস্ট করার আগে আপনি কোনও চ্যালেঞ্জের বিষয়ে প্রতিক্রিয়া পেতে পারেন।
— লাইকনি
1
আপনি "0zzzzzzzzz"একটি পরীক্ষার কেস হিসাবে (সর্বাধিক স্বাক্ষরের সংখ্যাটি সংশোধন করুন) মতো কিছু যুক্ত করার পরামর্শ দিন । অফ-বাই-ওয়ান-ত্রুটির কারণে এটি আমার সি সমাধানটি ছিন্ন করে।
— ওবালেন্স
1
এটি ঠিক আছে ধরে ধরে একটি এন্ট্রি যুক্ত করেছে - একটি সি এন্ট্রি এটি ইতিমধ্যে করেছে does
— ফেলিক্স Palmen

উত্তর:

6

05 এ বি 1 ই , 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

জাভাস্ক্রিপ্ট (ES6), 45 বাইট

@ ওউবালেন্সের জন্য 4 টি বাইট সংরক্ষণ করা হয়েছে

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

এটি অনলাইন চেষ্টা করুন!

— Arnauld
সূত্র
তুমি পাগল, ভালো। +1
— জ্যাক হেলস
2
45 বাইট: bit.ly/2K5tjw0
— ওওবালেন্স
আমি সর্বশেষ গল্ফের পরে আর ES8 ভাবি না ...
— ডাউনগোট
@ ডাউনগোট ধন্যবাদ! তুমি ঠিক বলছো. আপডেট করা হয়েছে।
— আর্নল্ড
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

এটি অনলাইন চেষ্টা করুন!

স্ট্রিংটি সমস্ত জেডের প্রত্যয় অনুসারে একটি অক্ষর না পৌঁছানো অবধি ডানদিকে পড়ায় যা খালি থাকতে পারে। সেই চরিত্রটি বৃদ্ধি করে এবং 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 বাইট golfing জন্য এবং ceilingcat আরো 3 বাইট golfing জন্য।

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
আপনি স্ট্রিং আগে একটি শূন্য বাইট অনুমান করতে পারে না @Arnauld ...
— জ্যাকব
1
@ জাকব আমি সে সম্পর্কে 100% নিশ্চিত নই। আমরা ভাষা প্রয়োগ করে তাদের সংজ্ঞা দিই। এটি সি (জিসিসি) একটি টিআইও ভিএম-এ চলছে, যেখানে মেমরিটি হতে পারে - আমি মনে করি - প্রাথমিকভাবে সাফ হয়ে গেছে বলে ধরে নেওয়া হয়েছে। (আমি অন্যান্য সি উত্তরগুলি দেখেছি যা একই অনুমানগুলি তৈরি করে))
— আর্নল্ড
2
'বাস্তবায়নে' পরীক্ষার পরিবেশকে অন্তর্ভুক্ত করে আমি এটিকে সত্যই অনেক দূরে নিয়ে যেতে পারি। তবে আপনি এখনও 60-বাইট সংস্করণ ব্যবহার করতে পারেন যা কোনও মেমরি অনুমানের উপর নির্ভর করে না।
— আর্নল্ড
1
@ আরনাউল্ড আমি আরও 4 বাইট গল্ফ করেছি। এটি সত্যিই নিরাপদ হওয়া উচিত, যেহেতু আমাদের পরিচালনা করতে হবে না ZZZZZZZZZZ। এরিকএফের উত্তরও একই রকম, তবে আরও সংক্ষিপ্ত: কোডগল্ফ.সটাকেক্সচেঞ্জ
— 169468
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অপারেটর ফাংশন একত্রিত করার

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

এটি অনলাইন চেষ্টা করুন!

ফাংশন যা আর্গুমেন্টটিকে বেস ৩ to-এ রূপান্তর করে, ১ যোগ করে, আবার রূপান্তর করে এবং তারপরে এটি ফর্ম্যাট করে। নেতৃস্থানীয় শূন্যগুলি সংরক্ষণের জন্য এখন আদনানের উত্তরের মতো কৌশল অবলম্বন করুন।

— জো কিং
সূত্র
{S/.//}o{base :36(1~$_)+1: 36}30 বাইট জন্য।
— নবেহনহো
নিবন্ধ oগল্ফ করার আগে আমি কখনই ব্যবহার করার কথা ভাবি নি, তবে এটি কোথায় কার্যকর হতে পারে তা আমি দেখতে পাচ্ছি!
— জো কিং
আহ, এটি একটি করুণা যে .succ(একের সাথে বৃদ্ধি) কাজ করে না
— জো কিং
4

এমএটিএল , 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
— সূন্দর - মনিকা পুনরায় স্থাপন করুন
সূত্র
4

হাস্কেল , 63 বাইট

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

এটি অনলাইন চেষ্টা করুন! স্ট্রিংটি বিপরীত করে এবং প্রথম চরিত্রটি পরীক্ষা করে:

  • একজন 9 দ্বারা প্রতিস্থাপন করা হয় একটি a।
  • ক zএর পরিবর্তে ক0 এবং পুনরাবৃত্তভাবে পরবর্তী অক্ষরটি পরীক্ষা করা হয়।
  • অন্যান্য সকল অক্ষর ব্যবহার করে বৃদ্ধি করা হয় succ, উত্তরাধিকারী ফাংশন কারণ তারা এর একটি দৃষ্টান্ত যা চর ব্যবহার করা যেতে পারে Enum বর্গ ।

অবশেষে ফলাফলটি স্ট্রিং আবার বিপরীত হয়।

— Laikoni
সূত্র
4

6502 (এনএমওএস *) মেশিন কোড রুটিন, 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 করে, সমস্ত মূল এনএমওএস 6502 চিপগুলিতে কাজ করে, পরে সিএমওএস ভেরিয়েন্টে নয়।

$fb/ এর মধ্যে একটি 10-বর্ণের স্ট্রিংয়ের জন্য একটি পয়েন্টার আশা করে$fc যা একটি বেস-36 number সংখ্যা হবে বলে আশা করা হচ্ছে তার জন্য । জায়গায় এই সংখ্যা বৃদ্ধি করে।

হ্যান্ডেলগুলি - অবৈধ ইনপুট (যেমন একটি সংক্ষিপ্ত স্ট্রিং) তে বুদ্ধিমান কোনও কাজ করে না 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

রুটিন ব্যবহার করে সি 64 এসেম্বলারের প্রোগ্রামের উদাহরণ:

অনলাইন ডেমো

স্ক্রিনশট

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 সংস্করণটি আইএসবি বাতিল করতে পারে, তারপরে এলডিএ (), ওয়াইয়ের পরে আইএনসি ব্যবহার করতে পারে (এবং এক লাইন দিয়ে এগিয়ে চলেছে) এবং এক বাইট দ্বারা সংক্ষিপ্ত হতে পারে।
— পিটার ফেরি
@ পেটারফেরি 65C02 এর জন্য কোন আইএনসি রয়েছে?
— ফেলিক্স পামেন
@ পেটারফেরি ঠিক আছে, এটি খুব ভাল - 6502 তে আমি প্রথম স্থানে হারিয়ে
— যাচ্ছিলাম
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 এর Oআইও প্রয়োজন

  • আপার কেস ব্যবহার করে

— jslip
সূত্র
কেন এক ধাপ এগিয়ে যেতে এবং '1',অংশ না f? তারপরে 1↓তার বিপরীত অংশে পরিণত হবে
— ngn
@ এনএনএন সুন্দর, ধন্যবাদ!
— jslip
এমনকি আরও ছোট: (⎕D,⎕A)⍳'1',->1,(⎕D,⎕A)⍳
— এনজিএন
একটি চূড়ান্ত উন্নতি - এটি ট্রেন হিসাবে (f⍣¯1)1+f←36⊥1,(⎕D,⎕A)⍳⊢
— আবারও
3

পিএইচপি, 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;
  • শুধুমাত্র পিএইচপি 7.1: পুরানো পিএইচপি নেতিবাচক স্ট্রিং সূচকগুলি বুঝতে পারে না,
    কম বয়সী পিএইচপি অপরিজ্ঞাত স্থায়ীদের জন্য সতর্কবার্তা দেবে।
  • বড় হাতের ইনপুট দরকার। ছোট হাতের ইনপুট জন্য ছোট হাতের অক্ষর Yএবং প্রতিস্থাপন Aকরুন।

পাইপ হিসাবে চালান -nR

... অথবা এগুলি অনলাইনে চেষ্টা করুন ।

— তিতাস
সূত্র
— নাইট 2
আর একটি 68 বাইট সংস্করণ: এটি অনলাইনে চেষ্টা করুন! আপনি নিজেরটি ব্যবহার করতে পারেন -Rএবং এটিকে 66 66 বাইটও কল করতে পারেন ।
— রাত 2
1
@ নাইট 2 ভাল পদ্ধতির; তবে এটি আরও ছোট করা যায়: printf('%010s',($b=base_convert)(1+$b($argn,36,10),10,36));- 59 বাইট
— টাইটাস
1
সুন্দর. কি বুঝতে পারে নি যে আমরা এই মত একটি ফাংশন কল পারে: ($b=base_convert)(a,b,c)। আমি আপনার কাছ থেকে অনেক শিখছি
— রাত 2
2

কাঠকয়লা , 14 বাইট

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

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ব্যাখ্যা:

×0⁹

9 0টি মুদ্রণ করুন । এটি ফলাফলকে প্যাড করে।

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

বেস ৩ 36 থেকে ইনপুটটি রূপান্তর করুন, এটিকে বাড়িয়ে তোলেন, তারপরে আবার বেস ৩ to এ রূপান্তর করুন Then

— নিল
সূত্র
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'
— ওওবালেন্স
সূত্র
নিস! পুরানো জাভাতে ভবিষ্যতের রেফারেন্সের জন্য আপনি এমন কিছু দিয়ে প্যাড করতে পারেন"".format("%10s",t).replace(' ','0')
— Jakob
@ জাকব ধন্যবাদ, আমি এটিই খুঁজছিলাম।
— ওবালেন্স
1শুরুতে একটি যুক্ত করার পদ্ধতিকে ব্যবহার করার পরে এটি মুছে ফেলা আরও কম হয় :s->Long.toString(Long.valueOf("1"+s,36)+1,36).substring(1)
— Okx
@ ওকএক্স নিস পদ্ধতির আরও 2 টি বাইট: "1"+s=>1+s
— 21
2

জাভাস্ক্রিপ্ট (ES6), 89 বাইট

এটি অন্য জাভাস্ক্রিপ্ট এন্ট্রি হিসাবে প্রায় বাইট-দক্ষ নয়, তবে আমি এই নিয়মটি লক্ষ্য না করে এটি তৈরি করেছি:

দৈর্ঘ্যের 10 টি স্ট্রিং দেওয়া হয়েছে

সুতরাং এটি কোনও গুরুতর প্রবেশ নয় - কেবল মজাদার জন্য! এটি সাধারণ দৈর্ঘ্যের স্ট্রিংগুলির সাথে কাজ করে, যেমন 0abc, এবং 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, তারপরে বি, তারপরে সি করুন", যা আমি কোডটিতে পুনরায় ব্যবহার করি এমন কিছু ভেরিয়েবল ঘোষণার জন্য ব্যবহার করি। 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 "" সংখ্যা "কে একটি আসল সংখ্যায় রূপান্তর করুন, ১ যোগ করুন, তারপরে আবার বেস -৩ to এ রূপান্তর করুন। 1'জেড' ( 'z'-> '10') বৃদ্ধি করার থেকে আমাদের উদ্বিগ্ন হওয়ার দরকার নেই , যেহেতু আমরা কখনই 'জেড' বৃদ্ধি করি না (লাইন 4 এবং 6 দেখুন: শেষ অক্ষরটি কেবল 'জেড' না হলে কেবল বাড়ানো হবে) incre

এছাড়াও, আমরা কখনই নেতৃস্থানীয় শূন্যগুলি ত্যাগ করার ঝুঁকি রাখি না, কারণ আমরা আসলে কোনও একক চরিত্রের চেয়ে বেশি কখনও হস্তক্ষেপ করি না - কেবল স্ট্রিংয়ের সর্বশেষ চরিত্রটি। আপনি যে কোনও স্ট্রিং টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো করা

— ফ্লোরি
সূত্র
2

পরিষ্কার , 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]শেষ অক্ষরটি বৃদ্ধি করে এবং ?মান স্থিতিশীল না হওয়া পর্যন্ত প্রযোজ্য ।
— Ο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। স্ট্রিংয়ে ফিরে রূপান্তর করুন।

পুরাতন রুপ

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 বাইট রয়েছে, যদি আপনি সঠিক অন্তর্নির্মিত সন্ধান করতে পারেন ...
— জিউসেপে
উফ ... ভেবেছিল এই চ্যালেঞ্জটি কোড বোলিং!
— এনজিএম
ভাল বিল্ট ইন হয় strtoi আপনাকে শুরু করতে হয়; এটিকে 72 এ নামানোর জন্য আরও কিছু গল্ফিং ট্রিকস রয়েছে
— জিউস্পে
1
strtoiবরং কম সংখ্যায় সীমাবদ্ধ? আমি কিছুক্ষণ আগে এটি ছেড়ে দিয়েছি।
— এনজিএম
আচ্ছা বুঝলাম. intসীমাবদ্ধতা এতটা সমস্যাযুক্ত তা বুঝতে পারেনি । অকর্মা! উত্তরসূরীদের জন্য, এটি আমার ব্যর্থ সমাধান: এটি অনলাইনে চেষ্টা করে দেখুন!
— জিউসেপে
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+ এবং জিএমপি 2 , 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 বাইট সংক্ষিপ্ত হতে পারে: যদি হেক্স মোড ব্যবহার করা হয় তবে সমস্ত বেস_36 এবং বেস_10 ব্যবহারগুলি বেস_92 এ পরিবর্তন করুন (যা যাই হোক না কেন সেই প্রসঙ্গে সত্যই 92 এর ভিত্তিতে নয়)

— নীল
সূত্র
1

সেড , 94 বাইট

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

এটি অনলাইন চেষ্টা করুন!

সেড অক্ষরগুলি দেখার জন্য পরিবর্তন করতে অনেক ক্ষতি করে।

— জিওফ রেডি
সূত্র
@ ইথ প্রডাকশন হুফ, ধরার জন্য ধন্যবাদ thanks
— জিফ রেডি
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.