De acordo com http://en.cppreference.com/w/cpp/language/integer_literal , literais inteiros consistem em um literal decimal / hex / octal / binário e um sufixo inteiro opcional, que é obviamente completamente desnecessário, desperdiça bytes preciosos e é não usado neste desafio.

Um literal decimal é 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).

Um literal octal é the digit zero (0) followed by zero or more octal digits (0, 1, 2, 3, 4, 5, 6, 7).

Um literal hexadecimal é 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)(observe a distinção entre maiúsculas e minúsculas de abcdefx).

Um literal binário é the character sequence 0b or the character sequence 0B followed by one or more binary digits (0, 1).

Além disso, opcionalmente, pode haver alguns 's como separador de dígitos. Eles não têm significado e podem ser ignorados.

Entrada

Uma sequência que representa um literal inteiro C ++ 14 ou uma matriz de seus códigos de caracteres.

Saída

O número representado pela sequência de entrada na base 10, com uma nova linha à direita opcional. A saída correta nunca excederá 2 * 10 ^ 9

Critérios de vitória

Os colaboradores do GCC precisam de mais de 500 linhas de código para fazer isso, portanto , nosso código deve ser o mais curto possível!

Casos de teste:

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

Japonês , 6 bytes

OxUr"'

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

Experimente online!

código de máquina x86 (32 bits), 59. 57 bytes

Esta função tem esicomo um ponteiro para uma cadeia terminada por nulo e devolve o valor em edx. (A listagem abaixo é uma entrada do GAS na sintaxe da 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

E uma desmontagem com contagem de bytes - no formato Intel desta vez, caso você prefira esse.

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    

E caso você queira experimentá-lo, eis o código do driver de teste C ++ que eu vinculei a ele (incluindo a especificação da convenção de chamada na sintaxe GCC asm):

#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 devido ao comentário de Peter Cordes

-1 byte da atualização para usar dois decrementos para alterar 10 para 8

JavaScript (Nó Babel) , 26 bytes

lol x2

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

Experimente online!

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

Essa é uma função que pega uma matriz de caracteres (especificada como um par de ponteiros para o início e o fim - usando o idioma dos pares de iteradores) e retorna o número. Observe que a função modifica a matriz de entrada.

(Isso depende do comportamento do gcc / libstdc ++ que #include<cstdlib>também coloca as funções no escopo global. Para código compatível estritamente padrão, substitua por#include<stdlib.h> por um custo de mais um caractere.)

Breve descrição: O código primeiro usa std::removepara filtrar 'caracteres (ASCII 39). Então, strtolcom uma base de 0, ele já manipulará os casos decimais, octais e hexadecimais, portanto, o único outro caso a ser verificado é um inicial 0bou, em 0Bcaso afirmativo, defina a base para strtol2 e comece a analisar os 2 caracteres iniciais.

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

Experimente online.

Economizou 3 bytes devido à sugestão do tetocat e mais alguns jogos de golfe que se seguiram.

Guardado 4 bytes devido a sugestões de grastropner.

-2 bytes de Lucas

-12 bytes por l4m2

Python 2 , 32 bytes

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

Experimente online!

ri muito

(precisa do Python 2 porque o Python 3 mudou os literais octais para 0o(...)).

Perl 5 (-p), 14 bytes

y/'/_/;$_=eval

TIO

R , 79 71 69 bytes

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

Experimente online!

strtoifaz tudo, exceto as conversões de base 2 e ignorando as ', por isso há muitos bytes apenas para corrigir essas coisas.

Agradecimentos a Aaron Hayman por -6 bytes e inspirando -4 mais bytes (e contando!)

Verifique todos os casos de teste (versão antiga)

05AB1E , 16 14 bytes

Economizou 2 bytes graças ao Grimy

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

Experimente online! ou como um conjunto de testes

Explicação

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

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

Entrada de A1, saída para onde você coloca essa fórmula. Fórmula de matriz, use Ctrl+ Shift+ Enterpara inseri-la.

Adicionei alguns casos de teste que você pode ver na imagem - algumas tentativas anteriores trataram todos os casos de teste corretamente, mas as linhas 16 e / ou 17 estão erradas.

código de máquina x86-64, 44 bytes

(O mesmo código de máquina também funciona no modo de 32 bits.)

A resposta de @Daniel Schepler foi um ponto de partida para isso, mas isso tem pelo menos uma nova ideia algorítmica (não apenas um melhor aproveitamento da mesma idéia): Os códigos ASCII para 'B'( 1000010) e 'X'( 1011000) fornecem 16 e 2 após mascarar0b0010010 .

Então, após excluir decimal (dígito inicial diferente de zero) e octal (char após '0'é menor que 'B'), podemos apenas definir base = c & 0b0010010e pular para o loop de dígitos.

Chamadas com x86-64 System V como unsigned __int128 parse_cxx14_int(int dummy, const char*rsi); Extrai o valor de retorno EDX da metade alta do unsigned __int128resultado com 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

Os blocos alterados em relação à versão de Daniel são (principalmente) recuados menos do que outras instruções. Além disso, o loop principal tem sua ramificação condicional na parte inferior. Isso acabou sendo uma mudança neutra, porque nenhum dos caminhos poderia cair no topo, e odec ecx / loop .Lentry ideia de entrar no circuito acabou não sendo uma vitória depois de lidar com o octal de maneira diferente. Mas ele tem menos instruções dentro do loop com o loop na forma idiomática do {} while estrutura, então eu o mantive.

O equipamento de teste C ++ de Daniel funciona inalterado no modo de 64 bits com esse código, que usa a mesma convenção de chamada que sua resposta de 32 bits.

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

Desmontagem, incluindo os bytes do código da máquina que são a resposta real

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   

Outras alterações da versão de Daniel incluem salvar o sub $16, %alde dentro do loop de dígitos, usando maissub invés detest como parte da detecção de separadores e dígitos vs. caracteres alfabéticos.

Diferentemente de Daniel, todos os personagens abaixo '0'são tratados como separadores, não apenas '\''. (Exceto ' ': and $~32, %al/jnz em ambos os nossos loops trata o espaço como um terminador, o que é possivelmente conveniente para testar com um número inteiro no início de uma linha.)

Toda operação que modifica %aldentro do loop tem uma ramificação consumindo sinalizadores definidos pelo resultado e cada ramificação vai (ou cai) para um local diferente.

Retina , 96 bytes

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

Experimente online! O link inclui o conjunto de testes. Explicação:

T`'L`_l

Exclua se 'converta tudo para minúsculas.

\B
:

Separe os dígitos, pois qualquer dígito hexadecimal precisa ser convertido em decimal.

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

Identifique a base do número.

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

Converta os caracteres a-gem números 10-16.

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

Realize a conversão base na lista de dígitos. $.($`*$1*_*$2*é curto para o $.($`*$1*_*$2*_)qual multiplica $`e $1juntos e adiciona $2. ( $`é a parte da cadeia antes ;da base, por exemplo).

.+;

Exclua a base.

J , 48 bytes

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

Experimente online!

Avaliação após a substituição da corda.

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 bytes

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

Experimente online!

Perl 6 requer um explícito 0o prefixo para octal e não suporta prefixos maiúsculos como 0X.

Explicação

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

Oitava , 29 21 20 bytes

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

Experimente online!

-8 bytes graças a @TomCarpenter

Bash, 33 bytes

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

TIO

Zsh, 29 27 bytes

-2 bytes graças a @GammaFunction

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

TIO

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

Gelatina , 27 bytes

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

Experimente online!

Quase tudo isso é manipulação octal. Parece que poderia ser melhor jogado.

Ruby com-n , 17 bytes

Apenas pulando no evaltrem, realmente.

p eval gsub(?'){}

Experimente online!

Java (JDK) , 101 bytes

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

Experimente online!

Long.decode lida com todos os tipos de literais, exceto os binários.

Modelo emprestado da resposta de Benjamin

C (gcc) , 120 118 bytes

-1 byte graças ao 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;}

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

Experimente online

PHP - 43 bytes

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

Mesmo método que /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");}

Não há necessidade de testes

Requer instalação de g++ com suporte ao C ++ 14

Agora, explicações:

Ele grava um arquivo chamado a.cpp, usa o GCC para compilá-lo e fornece um arquivo que gera o número

Pitão , 27 bytes

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

Experimente online!

Diferentemente da resposta Pyth anterior (agora excluída), esta é aprovada em todos os casos de teste da pergunta, apesar de ser 3 bytes mais longa.

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

Experimente online!

Java, 158 154 bytes

Isso apenas esperando para ser derrotado. Apenas tenta regexes até que algo funcione e o padrão seja hexadecimal.
-4 bytes graças a @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);}

Experimente online

Usando ScriptEngine, 92 87 bytes

Trem Eval chegando. Tecnicamente, isso está passando a tocha para JS, então não é minha principal submissão.

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

TIO