27

Http://en.cppreference.com/w/cpp/language/integer_literal के अनुसार , पूर्णांक शाब्दिक एक दशमलव / हेक्स / अष्टक / द्विआधारी शाब्दिक और एक वैकल्पिक पूर्णांक प्रत्यय से मिलकर बनता है, जो स्पष्ट रूप से पूरी तरह से अनावश्यक है, कीमती बाइट्स बेकार है और है इस चुनौती में इस्तेमाल नहीं किया।

एक दशमलव शाब्दिक है a non-zero decimal digit (1, 2, 3, 4, 5, 6, 7, 8, 9), followed by zero or more decimal digits (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)।

एक अष्टक शाब्दिक है the digit zero (0) followed by zero or more octal digits (0, 1, 2, 3, 4, 5, 6, 7)।

एक हेक्साडेसिमल शाब्दिक है the character sequence 0x or the character sequence 0X followed by one or more hexadecimal digits (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, A, b, B, c, C, d, D, e, E, f, F)(केस-असंवेदनशीलता पर ध्यान दें abcdefx)।

एक द्विआधारी शाब्दिक है the character sequence 0b or the character sequence 0B followed by one or more binary digits (0, 1)।

इसके अतिरिक्त, 'अंक विभाजक के रूप में वैकल्पिक रूप से कुछ s हो सकते हैं । उनका कोई मतलब नहीं है और उन्हें नजरअंदाज किया जा सकता है।

इनपुट

एक स्ट्रिंग जो C ++ 14 पूर्णांक शाब्दिक या उसके चारकोड की एक सरणी का प्रतिनिधित्व करती है।

उत्पादन

बेस 10 में इनपुट स्ट्रिंग द्वारा दर्शाई गई संख्या, एक वैकल्पिक अनुगामी न्यूलाइन के साथ। सही आउटपुट कभी भी 2 * 10 ^ 9 से अधिक नहीं होगा

मानदंड जीतना

GCC योगदानकर्ताओं को ऐसा करने के लिए कोड की 500 से अधिक लाइनों की आवश्यकता होती है, इसलिए हमारा कोड यथासंभव छोटा होना चाहिए!

परीक्षण के मामलों:

0                       ->    0
1                       ->    1
12345                   ->    12345
12345'67890             ->    1234567890
0xFF                    ->    255
0XfF                    ->    255
0xAbCdEf                ->    11259375
0xa'bCd'eF              ->    11259375
0b1111'0000             ->    240
0b0                     ->    0
0B1'0                   ->    2
0b1                     ->    1
00                      ->    0
01                      ->    1
012345                  ->    5349
0'123'4'5               ->    5349

code-golf parsing

— मेरा सर्वनाम monicareinstate है
स्रोत

2

सैंडबॉक्स लिंक

— मेरा सर्वनाम

4

@LuisfelipeDejesusMunoz नहीं; आपने कैसे उम्मीद की कि पार्स किया जाए?

— मेरा सर्वनाम

1

मुझे लगता है कि C ++ 14 में केवल एक फंक्शन लिखना धोखा होगा, है ना? चूंकि संकलक पहले से ही इसे स्वचालित रूप से करता है (भले ही यह आंतरिक रूप से कोड की 500+ पंक्तियां हों ...)

— डारेल हॉफमैन ने

5

@DarrelHoffman आप इसे "C ++ 14 में एक फ़ंक्शन" के साथ नहीं कर सकते हैं, हालांकि, यह एक स्ट्रिंग इनपुट नहीं लेगा। शायद कुछ स्क्रिप्ट के साथ जो C ++ कंपाइलर को आमंत्रित करता है।

— aschepler

2

0जोड़ने के लिए स्ट्रिंग एक अच्छा परीक्षण मामला हो सकता है (यह मेरे हाल के संशोधनों में से एक में बग का पता चला)।

— डैनियल शेपलर

6

जाप , 6 बाइट्स

OxUr"'

OxUr"'  Full Program. Implicit Input U
  Ur"'  Remove ' from U
Ox      Eval as javascript

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत

यह कैसे काम करता है?

— lirtosiast

@lirtosiast मूल रूप से मेरे js उत्तर के समान है। मैं 'इनपुट से

— हटाता

22

x86 (32-बिट) मशीन कोड, 59 57 बाइट्स

यह फ़ंक्शन esiएक संकेतक के रूप में अशक्त-समाप्त स्ट्रिंग में ले जाता है और मान को वापस लौटाता है edx। (नीचे सूचीबद्ध करना AT & T सिंटैक्स में GAS इनपुट है।)

        .globl parse_cxx14_int
        .text
parse_cxx14_int:
        push $10
        pop %ecx                # store 10 as base
        xor %eax,%eax           # initialize high bits of digit reader
        cdq                     # also initialize result accumulator edx to 0
        lodsb                   # fetch first character
        cmp $'0', %al
        jne .Lparseloop2
        lodsb
        and $~32, %al           # uppercase letters (and as side effect,
                                # digits are translated to N+16)
        jz .Lend                # "0" string
        cmp $'B', %al           # after '0' have either digit, apostrophe,
                                # 'b'/'B' or 'x'/'X'
        je .Lbin
        jg .Lhex
        dec %ecx
        dec %ecx                # update base to 8
        jmp .Lprocessdigit      # process octal digit that we just read (or
                                # skip ' if that is what we just read)   
.Lbin:
        sub $14, %ecx           # with below will update base to 2
.Lhex:
        add $6, %ecx            # update base to 16
.Lparseloop:
        lodsb                   # fetch next character
.Lparseloop2:
        and $~32, %al           # uppercase letters (and as side effect,
                                # digits are translated to N+16)
        jz .Lend
.Lprocessdigit:
        cmp $7, %al             # skip ' (ASCII 39 which would have been
                                # translated to 7 above)
        je .Lparseloop
        test $64, %al           # distinguish letters and numbers
        jz .Lnum
        sub $39, %al            # with below will subtract 55 so e.g. 'A'==65
                                # will become 10
.Lnum:
        sub $16, %al            # translate digits to numerical value
        imul %ecx, %edx
#        movzbl %al, %eax
        add %eax, %edx          # accum = accum * base + newdigit
        jmp .Lparseloop
.Lend:
        ret

और बाइट काउंट्स के साथ एक डिस्सैम्फ़ - इस बार इंटेल फॉर्मेट में, अगर आप इसे पसंद करते हैं।

Disassembly of section .text:

00000000 <parse_cxx14_int>:
   0:   6a 0a                   push   0xa
   2:   59                      pop    ecx
   3:   31 c0                   xor    eax,eax
   5:   99                      cdq    
   6:   ac                      lods   al,BYTE PTR ds:[esi]
   7:   3c 30                   cmp    al,0x30
   9:   75 16                   jne    21 <parse_cxx14_int+0x21>
   b:   ac                      lods   al,BYTE PTR ds:[esi]
   c:   24 df                   and    al,0xdf
   e:   74 28                   je     38 <parse_cxx14_int+0x38>
  10:   3c 42                   cmp    al,0x42
  12:   74 06                   je     1a <parse_cxx14_int+0x1a>
  14:   7f 07                   jg     1d <parse_cxx14_int+0x1d>
  16:   49                      dec    ecx
  17:   49                      dec    ecx
  18:   eb 0b                   jmp    25 <parse_cxx14_int+0x25>
  1a:   83 e9 0e                sub    ecx,0xe
  1d:   83 c1 06                add    ecx,0x6
  20:   ac                      lods   al,BYTE PTR ds:[esi]
  21:   24 df                   and    al,0xdf
  23:   74 13                   je     38 <parse_cxx14_int+0x38>
  25:   3c 07                   cmp    al,0x7
  27:   74 f7                   je     20 <parse_cxx14_int+0x20>
  29:   a8 40                   test   al,0x40
  2b:   74 02                   je     2f <parse_cxx14_int+0x2f>
  2d:   2c 27                   sub    al,0x27
  2f:   2c 10                   sub    al,0x10
  31:   0f af d1                imul   edx,ecx
  34:   01 c2                   add    edx,eax
  36:   eb e8                   jmp    20 <parse_cxx14_int+0x20>
  38:   c3                      ret

और यदि आप इसे आज़माना चाहते हैं, तो यहां C ++ परीक्षण ड्राइवर कोड है जिसे मैंने इसके साथ जोड़ा है (GCC asm syntax में कॉलिंग कन्वेंशन विनिर्देश सहित):

#include <cstdio>
#include <string>
#include <iostream>

inline int parse_cxx14_int_wrap(const char *s) {
    int result;
    const char* end;
    __asm__("call parse_cxx14_int" :
            "=d"(result), "=S"(end) :
            "1"(s) :
            "eax", "ecx", "cc");
    return result;
}

int main(int argc, char* argv[]) {
    std::string s;
    while (std::getline(std::cin, s))
        std::printf("%-16s -> %d\n", s.c_str(), parse_cxx14_int_wrap(s.c_str()));
    return 0;
}

पीटर कॉर्ड्स की टिप्पणी के कारण -1 बाइट

-1 बाइट को 10 से 8 में बदलने के लिए दो घटाव का उपयोग करने के लिए अद्यतन करने से

— डैनियल शेपलर
स्रोत

1

केवल आप ओवरफ्लो के लिए परीक्षण याद कर रहे हैं ... बहुत बड़ी संख्या कंपाइलरों द्वारा रिपोर्ट की जाती है।

— एलेक्सिस विल्के

2

क्या आप अपने रजिस्टर उपयोग के लिए rdxऔर rbx ? Then you can use 1-byte cdq` को शून्य rdxसे स्वैप कर सकते हैं eax।

— पीटर कॉर्डेस

1

यह या तो आपके असेंबली के बाइट काउंट को सूचीबद्ध करना चाहिए, या x86 मशीन कोड के 59 बाइट्स के रूप में लेबल किया जाना चाहिए।

— आलू ४४

2

@PeterCordes धन्यवाद, उस एक के बारे में पता नहीं था। (इसके अलावा, इसे फिर से देखने पर, मैंने देखा कि 10 से 8 तक आधार को बदलने पर 2 बाइट्स हो सकते हैं - दो घटने के निर्देशों से - 3 बाइट्स के बजाय।)

— डैनियल शेप्लर

3

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

— डैनियल शेपलर

12

जावास्क्रिप्ट (बैबेल नोड) , 26 बाइट्स

lol x2

_=>eval(_.split`'`.join``)

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत

4

यह एक्सक्लूसिव नहीं है, यह ES6 के बाद से काम करता है

— बैसब्रांड कंबरवॉबवबब

1

@BassdropCumberwubwubwub, हेडर शायद TIO से कॉपी किया गया था।

— झबरा

अच्छा, मैंने पहली बार उपयोग करने की कोशिश की Numberक्योंकि यह बाइनरी और हेक्स को संभालता है, लेकिन स्पष्ट रूप से अष्टाकार नहीं हैNumber("010") === 10

— कार्ल वॉल्श

7

C ++ (gcc), 141 138 134 120 बाइट्स

यह एक ऐसा फ़ंक्शन है जो वर्णों की एक सरणी लेता है (शुरुआत और अंत में चलने वाले जोड़े की एक जोड़ी के रूप में निर्दिष्ट - पुनरावृत्तियों की जोड़ी का उपयोग करके) और नंबर देता है। ध्यान दें कि फ़ंक्शन इनपुट सरणी को बदल देता है।

(यह gcc / libstdc ++ के व्यवहार पर निर्भर करता है #include<cstdlib>जो वैश्विक कार्यक्षेत्रों में भी कार्य करता है। कड़ाई से मानक अनुरूप कोड के लिए, #include<stdlib.h>एक और चरित्र की लागत के साथ प्रतिस्थापित करता है ।)

संक्षिप्त विवरण: कोड पहले अक्षर (ASCII 39) std::removeको फ़िल्टर करने के लिए उपयोग करता है '। फिर, strtol0 के आधार के साथ पहले से ही दशमलव, अष्टक और षोडश आधारी मामलों को संभाल लेंगे, इसलिए जांच करने के लिए एकमात्र अन्य मामला एक अग्रणी है 0bया 0Bयदि ऐसा है, तो strtol2 के लिए आधार सेट करें और अग्रणी 2 वर्णों के बाद पार्स करना शुरू करें।

#import<algorithm>
#import<cstdlib>
int f(char*s,char*e){e=s[*std::remove(s,e,39)=1]&31^2?s:s+2;return strtol(e,0,e-s);}

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

सीसेट के सुझाव के कारण 3 बाइट्स बचीं और कुछ और गोल्फिंग के बाद।

Grastropner द्वारा सुझावों के कारण 4 बाइट्स सहेजे गए।

लुकास द्वारा -2 बाइट्स

-12 बाइट्स l4m2 द्वारा

— डैनियल शेपलर
स्रोत

134 बाइट्स

— गैस्ट्रोपनर

शामिल, धन्यवाद।

— डैनियल शेपलर

के बजाय पदावनत का उपयोग करके#import#include 132 बाइट्स ?

— लुकास

यदि अमान्य इनपुट अपरिभाषित व्यवहार है, तो यह जांचने की कोई आवश्यकता नहीं है कि क्या 1 char 0आधार 2 के लिए है

— l4m2

तो 124

— l4m2

5

पायथन 2 , 32 बाइट्स

lambda a:eval(a.replace("'",""))

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

जबरदस्त हंसी

(पाइथन 2 की आवश्यकता है क्योंकि पाइथन 3 ने अष्टक शाब्दिक को बदल दिया है 0o(...))।

— HyperNeutrino
स्रोत

3

हम वास्तव में इस बिंदु पर पूर्ण चक्र चले गए हैं

— osuka_

4

पर्ल 5 (-पी), 14 बाइट्स

y/'/_/;$_=eval

TIO

— नहुएल फौलीउल
स्रोत

4

आर , 79 71 69 बाइट्स

`+`=strtoi;s=gsub("'","",scan(,""));na.omit(c(+s,sub("..",0,s)+2))[1]

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

strtoiबेस 2 रूपांतरणों और अनदेखी के अलावा सब कुछ करता है ', इसलिए उन चीजों को ठीक करने के लिए बहुत सारे बाइट्स हैं।

हारून हेमैन के लिए धन्यवाद -6 बाइट्स, और प्रेरणादायक -4 और बाइट्स (और गिनती!)

सभी परीक्षण मामलों (पुराने संस्करण) की पुष्टि करें

— ग्यूसेप
स्रोत

एक बाइट की जगह बचा सकता है sub("0b|B"के साथ sub("b|B"अग्रणी "0" को प्रभावित नहीं करेगा मूल्य के बाद से,। नाम बदलकर दूसरा प्राप्त कर सकते हैंstrtoi

— हारून हेमैन

1

74 बाइट्स: इसे ऑनलाइन आज़माएं!

— आरोन हेमैन

1

@AaronHayman वाह, मैंने पहले कभी नहीं देखा na.omit। सुपर यहाँ काम, और मैं थोड़ा और दूर पहुंचा :-)

— ग्यूसेप

1

यदि हम मान लें कि पहली असफलता strtoiएक बाइनरी है, तो आप बाइट बचाने substringके subलिए उपयोग कर सकते हैं : इसे ऑनलाइन आज़माएं!

— हारून हेमैन

1

@AaronHayman हम इसके बजाय sउपयोग subकरने के पहले 2 पात्रों को छीन सकते हैं sub('..','',s)जिसके साथ एक और बाइट छोटी है!

— ग्यूसेप

4

05AB1E , 16 14 बाइट्स

2 बाइट्स ग्रिम के लिए धन्यवाद बचा लिया

''KlÐïK>i8ö}.E

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

''K                # remove "'" from input
   l               # and convert to lower-case
    Ð              # triplicate
     ï             # convert one copy to integer
      K            # and remove it from the second copy
       >i  }       # if the result is 0
         8ö        # convert from base-8 to base-10
            .E     # eval

— Emigna
स्रोत

-2 बाइट्स

— ग्रैमी

और यहाँ एक नकली 13 (सभी परीक्षण मामलों को पास करता है, लेकिन उदाहरण के लिए विफल रहता है 0010)।

— ग्रिम्मी

@ जिमी: धन्यवाद! का ठंडा उपयोग ï!

— एमीना

4

एक्सेल, 115 बाइट्स

=DECIMAL(SUBSTITUTE(REPLACE(A1,2,1,IFERROR(VALUE(MID(A1,2,1)),)),"'",),VLOOKUP(A1,{"0",8;"0B",2;"0X",16;"1",10},2))

A1 से इनपुट, आउटपुट को जहाँ भी आपने यह सूत्र रखा है। सूत्र सूत्र, इसलिए इसे दर्ज करने के लिए Ctrl+ Shift+ Enterका उपयोग करें।

मैंने एक युगल परीक्षण के मामले जोड़े, जिन्हें आप छवि में देख सकते हैं - कुछ शुरुआती प्रयासों ने सभी दिए गए परीक्षण मामलों को सही ढंग से संभाला लेकिन पंक्तियों को 16 और / या 17 गलत पाया।

— सोफिया लेचनर
स्रोत

क्या यह अंतिम दो समापन कोष्ठक को छोड़ना और इस तथ्य का लाभ उठाना है कि "संकलक" (रिटर्न या टैब दबाने) आपके लिए त्रुटि-सही होगा?

— लुकास

मेरी निजी राय में, हाँ। मुझे नहीं लगता कि कोई साइट आम सहमति है। कोष्ठकों को जोड़ने वाले एक्सेल को किसी अन्य भाषा के IDE में कोड-पूरा करने की सुविधा के बराबर लगता है, जिसे बाइट की गिनती के लिए अनदेखा किया जाना चाहिए। (लेकिन, मुझे लगता है ""? "को BASIC में 1 बाइट के रूप में गिना जाना चाहिए, भले ही इसे चुपचाप" PRINT "में विस्तारित किया जाएगा, इसलिए शायद मैं यहां पूरी तरह से सुसंगत नहीं हूं)।

— सोफिया लेचनर

3

x86-64 मशीन कोड, 44 बाइट्स

(एक ही मशीन कोड 32-बिट मोड में भी काम करता है।)

@ डैनियल शेप्लेर का जवाब इसके लिए एक शुरुआती बिंदु था, लेकिन इसमें कम से कम एक नया एल्गोरिदमिक विचार (समान विचार का सिर्फ बेहतर गोल्फिंग नहीं) है: एएससीआईआई कोड 'B'( 1000010) और 'X'( 1011000) के लिए मास्किंग के बाद 16 और 2 देते हैं0b0010010 ।

इसलिए दशमलव (गैर-शून्य अग्रणी अंक) और ऑक्टल (चार '0'से कम है 'B') को छोड़कर , हम बस आधार सेट कर सकते हैं c & 0b0010010और अंक लूप में कूद सकते हैं।

X86-64 सिस्टम V के साथ कॉल करने के साथ परिणाम unsigned __int128 parse_cxx14_int(int dummy, const char*rsi); के उच्च आधे से EDX रिटर्न मान निकालें ।unsigned __int128tmp>>64

        .globl parse_cxx14_int
## Input: pointer to 0-terminated string in RSI
## output: integer in EDX
## clobbers: RAX, RCX (base), RSI (points to terminator on return)
parse_cxx14_int:
        xor %eax,%eax           # initialize high bits of digit reader
        cdq                     # also initialize result accumulator edx to 0
        lea 10(%rax), %ecx      # base 10 default
        lodsb                   # fetch first character
        cmp $'0', %al
        jne .Lentry2
    # leading zero.  Legal 2nd characters are b/B (base 2), x/X (base 16)
    # Or NUL terminator = 0 in base 10
    # or any digit or ' separator (octal).  These have ASCII codes below the alphabetic ranges
    lodsb

    mov    $8, %cl              # after '0' have either digit, apostrophe, or terminator,
    cmp    $'B', %al            # or 'b'/'B' or 'x'/'X'  (set a new base)
    jb   .Lentry2               # enter the parse loop with base=8 and an already-loaded character
         # else hex or binary. The bit patterns for those letters are very convenient
    and    $0b0010010, %al      # b/B -> 2,   x/X -> 16
    xchg   %eax, %ecx
    jmp  .Lentry

.Lprocessdigit:
    sub  $'0' & (~32), %al
    jb   .Lentry                 # chars below '0' are treated as a separator, including '
    cmp  $10, %al
    jb  .Lnum
    add  $('0'&~32) - 'A' + 10, %al   # digit value = c-'A' + 10.  we have al = c - '0'&~32.
                                        # c = al + '0'&~32.  val = m+'0'&~32 - 'A' + 10
.Lnum:
        imul %ecx, %edx
        add %eax, %edx          # accum = accum * base + newdigit
.Lentry:
        lodsb                   # fetch next character
.Lentry2:
        and $~32, %al           # uppercase letters (and as side effect,
                                # digits are translated to N+16)
        jnz .Lprocessdigit      # space also counts as a terminator
.Lend:
        ret

डैनियल के संस्करण बनाम बदले हुए ब्लॉक (अधिकतर) अन्य अनुदेशों की तुलना में कम हैं। इसके अलावा मुख्य लूप में नीचे स्थित इसकी सशर्त शाखा है। यह एक तटस्थ परिवर्तन निकला क्योंकि न तो मार्ग इसके शीर्ष में गिर सकता था, और dec ecx / loop .Lentryलूप में प्रवेश करने का विचार अलग-अलग अष्टकोणीय रूप से संभालने के बाद एक जीत नहीं था। लेकिन यह संरचना के दौरान लूप के साथ लूप के अंदर कम निर्देश है, संरचना करते समय {} करते हैं, इसलिए मैंने इसे रखा।

डैनियल के C ++ टेस्ट हार्नेस इस कोड के साथ 64-बिट मोड में अपरिवर्तित काम करता है, जो अपने 32-बिट उत्तर के समान कॉलिंग कन्वेंशन का उपयोग करता है।

g++ -Og parse-cxx14.cpp parse-cxx14.s &&
./a.out < tests | diff -u -w - tests.good

मशीन कोड बाइट्स सहित डिस्सैसम, जो वास्तविक उत्तर हैं

0000000000000000 <parse_cxx14_int>:
   0:   31 c0                   xor    %eax,%eax
   2:   99                      cltd   
   3:   8d 48 0a                lea    0xa(%rax),%ecx
   6:   ac                      lods   %ds:(%rsi),%al
   7:   3c 30                   cmp    $0x30,%al
   9:   75 1c                   jne    27 <parse_cxx14_int+0x27>
   b:   ac                      lods   %ds:(%rsi),%al
   c:   b1 08                   mov    $0x8,%cl
   e:   3c 42                   cmp    $0x42,%al
  10:   72 15                   jb     27 <parse_cxx14_int+0x27>
  12:   24 12                   and    $0x12,%al
  14:   91                      xchg   %eax,%ecx
  15:   eb 0f                   jmp    26 <parse_cxx14_int+0x26>
  17:   2c 10                   sub    $0x10,%al
  19:   72 0b                   jb     26 <parse_cxx14_int+0x26>
  1b:   3c 0a                   cmp    $0xa,%al
  1d:   72 02                   jb     21 <parse_cxx14_int+0x21>
  1f:   04 d9                   add    $0xd9,%al
  21:   0f af d1                imul   %ecx,%edx
  24:   01 c2                   add    %eax,%edx
  26:   ac                      lods   %ds:(%rsi),%al
  27:   24 df                   and    $0xdf,%al
  29:   75 ec                   jne    17 <parse_cxx14_int+0x17>
  2b:   c3                      retq

डैनियल संस्करण से अन्य परिवर्तनों को सहेजे शामिल sub $16, %alअंकों लूप के अंदर से, का उपयोग करके अधिक subके बजाय testका पता लगाने विभाजक, और अक्षर पात्रों बनाम अंक के हिस्से के रूप।

नीचे डैनियल के हर चरित्र '0'को एक विभाजक के रूप में माना जाता है, न कि केवल '\''। (सिवाय इसके ' ': and $~32, %al/ jnzहमारे दोनों छोरों में एक टर्मिनेटर के रूप में जगह का व्यवहार किया जाता है, जो संभवतः एक लाइन की शुरुआत में पूर्णांक के साथ परीक्षण के लिए सुविधाजनक है।)

%alलूप के अंदर संशोधित होने वाले प्रत्येक ऑपरेशन में परिणाम द्वारा निर्धारित झंडे का उपभोग करने वाली एक शाखा होती है, और प्रत्येक शाखा एक अलग स्थान पर जाती है (या गिरती है)।

— पीटर कॉर्डेस
स्रोत

क्या आपको eaxदिए गए के आरंभ की भी आवश्यकता है कि छोटे गंतव्य के साथ 64-बिट मोड opcodes में AIUI उच्च बिट्स को 0 पर रीसेट करेगा?

— डैनियल शेपलर

@ डैनियल: एक 32-बिट रजिस्टर शून्य-64-बिट तक फैलता है । एक 8 या 16-बिट रजिस्टर लिखना अन्य मोड से व्यवहार रखता है: मौजूदा मूल्य में विलय। AMD64 ने 8 और 16-बिट रजिस्टरों के लिए गलत निर्भरता को ठीक नहीं किया, और इसमें बदलाव नहीं setcc r/m8किया setcc r/m32, इसलिए हमें अभी भी एक 32/64-बिट 0 या 1 बनाने के लिए एक बेवकूफ 2-निर्देश xor-zero / सेट झंडे / setcc %alअनुक्रम की आवश्यकता है चर, और इसे ध्वज-सेटिंग से पहले शून्य रजिस्टर की आवश्यकता है। (या mov $0, %eaxइसके बजाय का उपयोग करें , या movzxमहत्वपूर्ण पथ पर उपयोग करें )।

— पीटर कॉर्ड्स

1

रेटिना , 96 बाइट्स

T`'L`_l
\B
:
^
a;
a;0:x:
g;
a;0:b:
2;
a;0:
8;
[a-g]
1$&
T`l`d
+`;(\d+):(\d+)
;$.($`*$1*_$2*
.+;

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

T`'L`_l

डिलीट 's और सब कुछ लोअर केस में कन्वर्ट करें।

\B
:

अंकों को अलग करें, क्योंकि किसी भी हेक्स अंकों को दशमलव में बदलना होगा।

^
a;
a;0:x:
g;
a;0:b:
2;
a;0:
8;

संख्या के आधार को पहचानें।

[a-g]
1$&
T`l`d

वर्णों a-gको संख्याओं में परिवर्तित करें 10-16।

+`;(\d+):(\d+)
;$.($`*$1*_$2*

अंकों की सूची पर आधार रूपांतरण करें। $.($`*$1*_*$2*के लिए कम है $.($`*$1*_*$2*_)जो पलता $`और $1एक साथ और कहते हैं $2। ( आधार $`से पहले स्ट्रिंग का हिस्सा है ;।)

.+;

आधार हटाओ।

— नील
स्रोत

मैं शाब्दिक प्रोग्रामिंग दृष्टिकोण की सराहना करता हूं जो आपने कोड को समझाने के लिए लिया :-)

— नाली १x

1

जे , 48 बाइट्स

cut@'0x 16b +0b 2b +0 8b0 '''do@rplc~'+',tolower

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

स्ट्रिंग प्रतिस्थापन के बाद ईवैल।

0XfF -> +16bff -> 255
0xa'bCd'eF -> +16babcdef -> 11259375
0B1'0 -> +2b10 -> 2
0 -> 8b0 -> 0
01 -> 8b01 -> 1
0'123'4'5 -> 8b012345 -> 5349

— FrownyFrog
स्रोत

यह हेक्साडेसिमल युक्त सही ढंग से काम नहीं करता है 0b: tio.run/##FcwxCsIwFAbg/…

— गैलेन इवानोव

1

@GalenIvanov अच्छा लगता है, तय

— FrownyFrog

1

पर्ल 6 , 29 बाइट्स

{+lc S/^0)>\d/0o/}o{S:g/\'//}

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

Perl 6 को 0oऑक्टल के लिए एक स्पष्ट उपसर्ग की आवश्यकता होती है और जैसे अपरकेस उपसर्गों का समर्थन नहीं करता है 0X।

व्याख्या

                   {S:g/\'//}  # remove apostrophes
{                }o  # combine with function
     S/^0)>\d/0o/    # 0o prefix for octal
  lc  # lowercase
 +    # convert to number

— nwellnhof
स्रोत

1

ऑक्टेव , 29 21 20 बाइट्स

@(x)str2num(x(x>39))

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

-8 बाइट्स @TomCarpenter को धन्यवाद

— समय सीमा समाप्त डेटा
स्रोत

22 बाइट्स के लिए:@(x)str2num(x(x~="'"))

— टॉम कारपेंटर

जो 21 बाइट्स के लिए बन जाता है:@(x)str2num(x(x~=39))

— टॉम कारपेंटर

ऑक्टल काम करने ... उदाहरण के लिए (TIO पर कम से कम), प्रकट नहीं होता f=("077")रिटर्न ans = 77जब यह 63. होना चाहिए या, ओपी में परीक्षण मामले में f=("012345")5349 लौट लेकिन इसके बजाय चाहिएans = 12345

— brhfl

1

बैश, 33 बाइट्स

x=${1//\'};echo $[${x/#0[Bb]/2#}]

TIO

Zsh, 29 27 बाइट्स

-2 बाइट्स @GammaFunction की बदौलत

<<<$[${${1//\'}/#0[Bb]/2#}]

TIO

— नहुएल फौलीउल
स्रोत

चतुर! मैंने सोचा setopt octalzeroesहोगा कि Zsh के लिए आवश्यक होगा।

— गामाफंक्शन जंक्शन

आप Zsh में 2 बाइट्स बचा सकते <<<$[...]हैंecho $[...]

— गामाफंक्शन जंक्शन

धन्यवाद, मुझे नहीं पता था कि पुनर्निर्देशन के साथ zsh खाली कमांड आउटपुट प्रदर्शित कर सकता है, मुझे zsh के बारे में ज्यादा जानकारी नहीं है, मैं बहुत बेहतर बाश जानता हूं

— नहुएल फौलीउल

मुझे पता था कि

— ओट से

0

जाओ, 75५

import "strconv"
func(i string)int64{n,_:=strconv.ParseInt(i,0,0);return n}

— vityavv
स्रोत

यह द्विआधारी शाब्दिक के लिए काम नहीं करता है, न ही एकल-उद्धरण अंकों के लिए।

— निक मैट्टो

ओह बकवास। मैं जल्द ही इसे ठीक कर दूंगा। पूरी तरह से सीमांकक के बारे में भूल गए

— vityavv

0

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

n=>+(n=n.toLowerCase().replace(/'/g,""))?n[1]=="b"?parseInt(n.substr(2),2):parseInt(n,+n[0]?10:n[1]=="x"?16:8):0

— Naruyoko
स्रोत

0

जेली , 27 बाइट्स

ØDiⱮḢ=1aƲȦ
ṣ”';/Ḋ⁾0o;Ɗ¹Ç?ŒV

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

लगभग यह सब अष्टक संभाल रहा है। ऐसा लगता है कि यह बेहतर गोल्फ हो सकता है।

— निक केनेडी
स्रोत

0

रूबी के साथ `-n`, 17 बाइट्स

बस evalट्रेन में कूदना , सचमुच।

p eval gsub(?'){}

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

— मूल्य स्याही
स्रोत

0

जावा (JDK) , 101 बाइट्स

n->{n=n.replace("'","");return n.matches("0[bB].+")?Long.parseLong(n.substring(2),2):Long.decode(n);}

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

Long.decode द्विआधारी को छोड़कर सभी प्रकार के शाब्दिकों से संबंधित है।

बेंजामिन के जवाब से टेम्पलेट उधार लिया गया

— शायरु असकोतो
स्रोत

अच्छा लगा। मुझे उन कार्यों पर अधिक ध्यान देने की आवश्यकता है जो आदिम आवरणों में हैं

— बेंजामिन अर्कहार्ट

0

सी (जीसीसी) , 120 118 बाइट्स

सीटिंग के लिए -1 बाइट धन्यवाद

f(char*s){int r=0,c=s[1]&31,b=10;for(s+=2*(*s<49&&(b=c^24?c^2?8:2:16)-8);c=*s++;)r=c^39?r*b+(c>57?c%32+9:c-48):r;c=r;}

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

— gastropner
स्रोत

0

सी (जीसीसी), 101 97 83 बाइट्स

*d;*s;n;f(int*i){for(s=d=i;*d=*s;d+=*s++>39);i=wcstol(i+n,0,n=!i[1]||i[1]&29?0:2);}

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

— जोहान डू टिट
स्रोत

0

PHP - 43 बाइट

eval("return ".str_replace($a,"'","").";");

समान विधि /codegolf//a/185644/45489 के रूप में

— मार्टिन बार्कर
स्रोत

0

सी ++, जी ++, 189 बाइट्स

#include<fstream>
#include<string>
void v(std::string s){{std::ofstream a("a.cpp");a<<"#include<iostream>\nint main(){std::cout<<"<<s<<";}";}system("g++ -std=c++14 a.cpp");system("a.exe");}

परीक्षणों की आवश्यकता नहीं

g++C ++ 14 समर्थन के साथ स्थापना की आवश्यकता है

अब, स्पष्टीकरण:

यह नामक एक फाइल लिखता है a.cpp, इसे संकलित करने के लिए GCC का उपयोग करता है और एक फाइल देता है जो संख्या को आउटपुट करता है

— HatsuPointerKun
स्रोत

175 बाइट्स

— छत

0

पायथ , 27 बाइट्स

Jscz\'?&qhJ\0}@J1r\0\7iJ8vJ

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

पिछले (अब हटाए गए) पायथ उत्तर के विपरीत, यह एक प्रश्न में सभी परीक्षण मामलों से गुजरता है, हालांकि यह 3 बाइट्स लंबा है।

— randomdude999
स्रोत

साइट पर आपका स्वागत है!

— गेहूं जादूगर

0

C (gcc) / बैश / C ++, 118 बाइट्स

f(i){asprintf(&i,"echo \"#import<iostream>\nmain(){std::cout<<%s;}\">i.C;g++ i.C;./a.out",i);fgets(i,i,popen(i,"r"));}

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

— जोहान डू टिट
स्रोत

मैंने कुछ कोड गॉकेट किए हैं। तब मैंने महसूस किया कि इसके काम करने का कोई कारण नहीं है, लेकिन यह काम करने लगता है; 158 बाइट्स ।

— मेरा सर्वनाम 12

@someone, यह बुरा है, लेकिन मुझे यह पसंद है!

— जोहान डू टिट

मर्ज करके 148 बाइट्स popenऔरsystem । जी ++ में एक झंडा है, मुझे लगता है -x, स्टड से पढ़ना है। यह फोपेन सामान से कम हो सकता है, लेकिन मुझे नहीं पता कि सी

— में स्टड के

@someone, सब कुछ अब popenकमांड में मिला दिया गया है

— जोहान डू टिट

printf-> मुझे echoकाम लगता है। आप जल्द ही bash में प्रोग्रामिंग करने जा रहे हैं।

— मेरा सर्वनाम 13

0

जावा, 158 154 बाइट्स

यह सिर्फ प्रकोप होने की प्रतीक्षा कर रहा है। बस कुछ काम करता है और हेक्स के लिए डिफ़ॉल्ट जब तक regexes की कोशिश करता है।
-4 बाइट्स @ValueInk को धन्यवाद

n->{n=n.replace("'","");var s=n.split("[bBxX]");return Long.parseLong(s[s.length-1],n.matches("0[bB].+")?2:n.matches("0\\d+")?8:n.matches("\\d+")?10:16);}

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

ScriptEngine का उपयोग करना, 92 87 बाइट्स

के माध्यम से आने वाली एवल ट्रेन। तकनीकी रूप से यह जेएस को मशाल दे रहा है, इसलिए यह मेरा मुख्य सबमिशन नहीं है।

n->new javax.script.ScriptEngineManager().getEngineByName("js").eval(n.replace("'",""))

TIO

— बेंजामिन अर्कहार्ट
स्रोत

उपयोग [bBxX]और 0[bB].+कुछ त्वरित रेगेक्स अनुकूलन के लिए।

— मूल्य स्याही

@ValueInk धन्यवाद

— बेंजामिन

यही कारण है कि यह एक लोंग नहीं है, यह स्पष्ट रूप से कहा जाता है, शीर्षक स्पष्ट रूप से कहता है कि आईईईई 754 en.wikipedia.org -wiki/ में दशमलव स्थान प्रणाली के कारण नंबर को बचाने के लिए उपयोग की जाने वाली विधि के कारण एक एकल या दोहरी सटीकता IEEE754 गलत हो सकती है। IEEE_754 # Roundings_to_nearest , यह 2 ट्रिलियन ( 0x9999999999) से भी अधिक संख्या का समर्थन करता है

— मार्टिन बार्कर

@MartinBarker को गोल्फ के उद्देश्यों के Longबजाय उपयोग करने की अनुमति Integerहै। इसके अलावा, यदि आप सही हैं, तो पायथन प्रतिस्पर्धा नहीं कर सकता है क्योंकि इसमें प्रभावी रूप से मनमाना-सटीक पूर्णांक हैं। इसके अलावा, longजावा में 32 के बजाय 64 बिट्स के साथ प्रतिनिधित्व पूर्णांक है। कोई दशमलव स्थान नहीं हैं।

— बेंजामिन अर्कहार्ट

लंबी बात यह थी कि आप लंबे समय से पूर्णांक का उपयोग कर रहे हैं और आप गोल्फ के उद्देश्यों के बारे में गलत हैं, The correct output never will exceed 2*10^9यह स्पष्ट रूप से बताता है कि लंबे समय का उपयोग अपने आप नहीं किया जा सकता है क्योंकि मैं इसे दे सकता हूं 0x9999999999और यह एक संख्या का उत्पादन करेगा। 2 * 10 ^ 9 से अधिक जबकि C ++ यह एक मेमोरी ओवरफ्लो समस्या पैदा करेगा क्योंकि आपके द्वारा मेमोरी पर 32 से अधिक बिट्स का उपयोग करने पर जब आपने इस नंबर पर केवल 32 बिट्स मेमोरी आवंटित की है

— मार्टिन बार्कर

पार्स एक सी ++ 14 पूर्णांक शाब्दिक

इनपुट

उत्पादन

मानदंड जीतना

परीक्षण के मामलों:

जाप , 6 बाइट्स

x86 (32-बिट) मशीन कोड, 59 57 बाइट्स

जावास्क्रिप्ट (बैबेल नोड) , 26 बाइट्स

C ++ (gcc), 141 138 134 120 बाइट्स

पायथन 2 , 32 बाइट्स

पर्ल 5 (-पी), 14 बाइट्स

आर , 79 71 69 बाइट्स

05AB1E , 16 14 बाइट्स

एक्सेल, 115 बाइट्स

x86-64 मशीन कोड, 44 बाइट्स

रेटिना , 96 बाइट्स

जे , 48 बाइट्स

पर्ल 6 , 29 बाइट्स

व्याख्या

ऑक्टेव , 29 21 20 बाइट्स

बैश, 33 बाइट्स

Zsh, 29 27 बाइट्स

जाओ, 75५

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

जेली , 27 बाइट्स

रूबी के साथ -n, 17 बाइट्स

जावा (JDK) , 101 बाइट्स

सी (जीसीसी) , 120 118 बाइट्स

सी (जीसीसी), 101 97 83 बाइट्स

सी ++, जी ++, 189 बाइट्स

पायथ , 27 बाइट्स

C (gcc) / बैश / C ++, 118 बाइट्स

जावा, 158 154 बाइट्स

ScriptEngine का उपयोग करना, 92 87 बाइट्स

रूबी के साथ `-n`, 17 बाइट्स