Menurut http://en.cppreference.com/w/cpp/language/integer_literal , literer bilangan bulat terdiri dari desimal / hex / oktal / biner literal dan akhiran bilangan bulat opsional, yang jelas sama sekali tidak perlu, membuang byte yang berharga dan tidak digunakan dalam tantangan ini.

Literal desimal adalah 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) .

Huruf oktal adalah the digit zero (0) followed by zero or more octal digits (0, 1, 2, 3, 4, 5, 6, 7) .

Huruf heksadesimal adalah 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)(perhatikan case-insensitivity ofabcdefx ).

Huruf biner adalah the character sequence 0b or the character sequence 0B followed by one or more binary digits (0, 1) .

Selain itu, mungkin ada beberapa ' s sebagai pemisah digit. Mereka tidak memiliki makna dan dapat diabaikan.

Memasukkan

Sebuah string yang merepresentasikan integer C ++ 14 literal atau array dari kode-kodenya.

Keluaran

Angka yang diwakili oleh string input pada basis 10, dengan baris tambahan opsional. Output yang benar tidak akan melebihi 2 * 10 ^ 9

Kriteria menang

Para kontributor GCC membutuhkan lebih dari 500 baris kode untuk melakukan ini, oleh karena itu kode kami harus sesingkat mungkin!

Kasus uji:

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

Japt , 6 byte

OxUr"'

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

Cobalah online!

kode mesin x86 (32-bit), 59 57 byte

Fungsi ini digunakan esisebagai penunjuk ke string yang diakhiri dengan nol dan mengembalikan nilai dalam edx. (Daftar di bawah ini adalah input GAS dalam sintaks AT&T.)

        .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

Dan pembongkaran dengan jumlah byte - dalam format Intel kali ini, jika Anda lebih suka yang itu.

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    

Dan jika Anda ingin mencobanya, berikut ini adalah kode driver tes C ++ yang saya tautkan dengannya (termasuk spesifikasi konvensi pemanggilan dalam sintaks asm GCC):

#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 byte karena komentar dari Peter Cordes

-1 byte dari pemutakhiran untuk menggunakan dua pengurangan untuk mengubah 10 ke 8

JavaScript (Babel Node) , 26 byte

lol x2

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

Cobalah online!

C ++ (gcc), 141 138 134 120 byte

Ini adalah fungsi yang mengambil array karakter (ditentukan sebagai sepasang pointer ke awal dan akhir - menggunakan pasangan idiom iterator) dan mengembalikan nomor. Perhatikan bahwa fungsi mem mutasi array input.

(Ini bergantung pada perilaku gcc / libstdc ++ yang #include<cstdlib>juga menempatkan fungsi dalam lingkup global. Untuk kode yang benar-benar sesuai standar, ganti dengan #include<stdlib.h>untuk biaya satu karakter lagi.)

Deskripsi singkat: Kode pertama kali digunakan std::removeuntuk memfilter 'karakter (ASCII 39). Kemudian, strtoldengan basis 0 sudah akan menangani case desimal, oktal, dan heksadesimal, jadi satu-satunya case lain yang perlu diperiksa adalah leading 0batau 0Bdan jika demikian, atur base untuk strtol2 dan mulai parsing setelah 2 karakter utama.

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

Cobalah online.

Disimpan 3 byte karena saran oleh ceilingcat dan beberapa lagi golf yang diikuti.

Disimpan 4 byte karena saran oleh grastropner.

-2 byte oleh Lucas

-12 byte oleh l4m2

Python 2 , 32 byte

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

Cobalah online!

lol

(perlu Python 2 karena Python 3 mengubah literal oktal ke 0o(...)).

Perl 5 (-p), 14 byte

y/'/_/;$_=eval

TIO

R , 79 71 69 byte

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

Cobalah online!

strtoimelakukan segalanya kecuali untuk konversi basis 2 dan mengabaikan ', jadi ada cukup banyak byte hanya untuk memperbaiki hal-hal itu.

Terima kasih kepada Aaron Hayman untuk -6 byte, dan menginspirasi -4 lebih banyak byte (dan terus bertambah!)

Verifikasi semua kasus uji (versi lama)

05AB1E , 16 14 byte

Disimpan 2 byte berkat Grimy

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

Cobalah online! atau sebagai Test Suite

Penjelasan

''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

Excel, 115 byte

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

Input dari A1, output ke mana pun Anda meletakkan formula ini. Array rumus, jadi gunakan Ctrl+ Shift+ Enteruntuk memasukkannya.

Saya menambahkan beberapa test case yang dapat Anda lihat dalam gambar - beberapa upaya awal menangani semua test case yang diberikan dengan benar tetapi mendapat baris 16 dan / atau 17 salah.

kode mesin x86-64, 44 byte

(Kode mesin yang sama juga berfungsi dalam mode 32-bit.)

Jawaban @Daniel Schepler adalah titik awal untuk ini, tetapi ini memiliki setidaknya satu ide algoritmik baru (bukan hanya bermain golf dengan ide yang sama): Kode ASCII untuk 'B'( 1000010) dan 'X'(1011000 ) memberi 16 dan 2 setelah masking dengan0b0010010 .

Jadi setelah mengecualikan desimal (digit angka tidak nol) dan oktal (angka char '0'kurang dari'B' ), kita bisa mengatur base = c & 0b0010010dan melompat ke loop digit.

Callable dengan x86-64 System V sebagai unsigned __int128 parse_cxx14_int(int dummy, const char*rsi); Ekstrak nilai pengembalian EDX dari setengah unsigned __int128hasil dengan tmp>>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

Blok yang diubah vs versi Daniel (sebagian besar) indentasi kurang dari instruksi lainnya. Juga loop utama memiliki cabang kondisional di bagian bawah. Ini ternyata menjadi perubahan netral karena tidak ada jalan yang bisa jatuh ke atasnya, dandec ecx / loop .Lentry ide untuk memasuki loop ternyata bukan kemenangan setelah menangani oktal secara berbeda. Tetapi memiliki lebih sedikit instruksi di dalam loop dengan loop dalam bentuk idiomatis do {} while structure, jadi saya menyimpannya.

Alat uji C ++ Daniel bekerja tidak berubah dalam mode 64-bit dengan kode ini, yang menggunakan konvensi panggilan yang sama dengan jawaban 32-bitnya.

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

Disassembly, termasuk byte kode mesin yang merupakan jawaban sebenarnya

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   

Perubahan lain dari versi Daniel termasuk menyimpan sub $16, %aldari dalam digit-loop, dengan menggunakan lebih banyaksub daripadatest sebagai bagian dari mendeteksi pemisah, dan digit vs karakter alfabet.

Berbeda dengan Daniel, setiap karakter di bawah '0'ini diperlakukan sebagai pemisah, bukan hanya '\''. (Kecuali' ' : and $~32, %al/jnz di kedua loop kami memperlakukan ruang sebagai terminator, yang mungkin nyaman untuk pengujian dengan integer pada awal baris.)

Setiap operasi yang memodifikasi %aldi dalam loop memiliki flag mengkonsumsi cabang ditetapkan oleh hasilnya, dan setiap cabang pergi (atau jatuh melalui) ke lokasi yang berbeda.

Retina , 96 byte

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*
.+;

Cobalah online! Tautan termasuk test suite. Penjelasan:

T`'L`_l

Hapus 's dan konversikan semuanya menjadi huruf kecil.

\B
:

Pisahkan digit, karena setiap digit hex perlu dikonversi menjadi desimal.

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

Identifikasi basis nomor.

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

Ubah karakter a-gmenjadi angka 10-16.

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

Lakukan konversi basis pada daftar digit. $.($`*$1*_*$2*adalah singkatan $.($`*$1*_*$2*_)yang mengalikan $`dan $1bersama-sama dan menambahkan $2. ( $`adalah bagian dari string sebelum ;pangkalan yaitu.)

.+;

Hapus basisnya.

J , 48 byte

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

Cobalah online!

Eval setelah pergantian string.

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

Perl 6 , 29 byte

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

Cobalah online!

Perl 6 membutuhkan 0oawalan eksplisit untuk oktal dan tidak mendukung awalan huruf besar seperti0X .

Penjelasan

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

Oktaf , 29 21 20 byte

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

Cobalah online!

-8 byte terima kasih kepada @TomCarpenter

Bash, 33 byte

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

TIO

Zsh, 29 27 byte

-2 byte terima kasih kepada @GammaFunction

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

TIO

Pergi, 75

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

JavaScript (ES6), 112 bytes

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

Jelly, 27 bytes

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

Try it online!

Almost all of this is handling octal. Feels like it could be better golfed.

Ruby with -n, 17 bytes

Just jumping on the eval train, really.

p eval gsub(?'){}

Try it online!

Java (JDK), 101 bytes

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

Try it online!

Long.decode deals with all kinds of literals except the binary ones.

Template borrowed from Benjamin's answer

C (gcc), 120 118 bytes

-1 byte thanks to ceilingcat

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

Try it online!

C (gcc), 101 97 83 bytes

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

Try it online

PHP - 43 Byte

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

Same method as /codegolf//a/185644/45489

C++, G++, 189 bytes

#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");}

No need for tests

Requires installation of g++ with C++14 support

Now, explanations :

It writes a file called a.cpp, uses GCC to compile it and gives a file that output the number

Pyth, 27 bytes

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

Try it online!

Unlike the previous (now deleted) Pyth answer, this one passes all test cases in the question, though it is 3 bytes longer.

C (gcc) / Bash / C++, 118 bytes

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

Try it online!

Java, 158 154 bytes

This just waiting to be outgolfed. Just tries regexes until something works and default to hex.
-4 bytes thanks to @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);}

Try it online

Using ScriptEngine, 92 87 bytes

Eval train coming through. Technically this is passing the torch to JS, so it's not my main submission.

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

TIO