De acuerdo con http://en.cppreference.com/w/cpp/language/integer_literal , los literales enteros consisten en un literal decimal / hexadecimal / octal / binario y un sufijo entero opcional, que obviamente es completamente innecesario, desperdicia bytes preciosos y es No se utiliza en este desafío.

Un literal decimal es 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).

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

Un literal hexadecimal es 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)(tenga en cuenta la mayúsculas y minúsculas de abcdefx).

Un literal binario es the character sequence 0b or the character sequence 0B followed by one or more binary digits (0, 1).

Además, opcionalmente puede haber algunos 's como separador de dígitos. No tienen significado y pueden ser ignorados.

Entrada

Una cadena que representa un literal entero C ++ 14 o una matriz de sus códigos de caracteres.

Salida

El número representado por la cadena de entrada en la base 10, con una nueva línea final opcional. La salida correcta nunca excederá 2 * 10 ^ 9

Criterios ganadores

Los contribuyentes de GCC necesitan más de 500 líneas de código para hacer esto, por lo tanto , nuestro código debe ser lo más corto posible.

Casos de prueba:

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 bytes

OxUr"'

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

Pruébalo en línea!

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

Esta función toma esicomo puntero a una cadena terminada en nulo y devuelve el valor en edx. (El listado a continuación es una entrada de GAS en la sintaxis de 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

Y un desmontaje con recuento de bytes, esta vez en formato Intel, en caso de que prefiera ese.

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    

Y en caso de que quiera probarlo, aquí está el código del controlador de prueba de C ++ que vinculé con él (incluida la especificación de la convención de llamada en la sintaxis asm de 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 debido al comentario de Peter Cordes

-1 byte desde la actualización para usar dos decrementos para cambiar de 10 a 8

JavaScript (nodo de Babel) , 26 bytes

lol x2

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

Pruébalo en línea!

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

Esta es una función que toma una matriz de caracteres (especificada como un par de punteros al inicio y al final, usando el par de expresiones idiomáticas) y devuelve el número. Tenga en cuenta que la función muta la matriz de entrada.

(Esto se basa en el comportamiento de gcc / libstdc ++ que #include<cstdlib>también coloca las funciones en el ámbito global. Para un código estrictamente compatible, reemplácelo #include<stdlib.h>por un costo de un carácter más).

Breve descripción: El código primero se usa std::removepara filtrar 'caracteres (ASCII 39). Luego, strtolcon una base de 0 ya manejará los casos decimales, octales y hexadecimales, por lo que el único otro caso para verificar es un inicio 0bo, de 0Bser así, establecer la base para strtol2 y comenzar a analizar después de los 2 caracteres iniciales.

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

Pruébalo en línea.

Guardado 3 bytes debido a la sugerencia de ceilingcat y un poco más de golf que siguió.

Guardado 4 bytes debido a sugerencias de grastropner.

-2 bytes por Lucas

-12 bytes por l4m2

Python 2 , 32 bytes

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

Pruébalo en línea!

jajaja

(necesita Python 2 porque Python 3 cambió los literales octales a 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]

Pruébalo en línea!

strtoihace todo excepto las conversiones de base 2 e ignora las ', por lo que hay bastantes bytes solo para arreglar esas cosas.

Gracias a Aaron Hayman por -6 bytes, e inspirando -4 bytes más (¡y contando!)

Verificar todos los casos de prueba (versión anterior)

05AB1E , 16 14 bytes

Guardado 2 bytes gracias a Grimy

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

Pruébalo en línea! o como un conjunto de pruebas

Explicación

''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 desde A1, salida a donde sea que coloque esta fórmula. Fórmula de matriz, así que usa Ctrl+ Shift+Enter para ingresarla.

Agregué un par de casos de prueba que puede ver en la imagen: algunos intentos iniciales manejaron todos los casos de prueba dados correctamente pero obtuvieron las filas 16 y / o 17 incorrectas.

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

(El mismo código de máquina también funciona en modo de 32 bits).

La respuesta de @Daniel Schepler fue un punto de partida para esto, pero tiene al menos una nueva idea algorítmica (no solo un mejor golf de la misma idea): los códigos ASCII para 'B'( 1000010) y 'X'( 1011000) dan 16 y 2 después de enmascarar con0b0010010 .

Entonces, después de excluir decimal (dígito inicial distinto de cero) y octal (char después '0' es menor que 'B'), podemos establecer base = c & 0b0010010y saltar al ciclo de dígitos.

Se puede llamar con x86-64 System V como unsigned __int128 parse_cxx14_int(int dummy, const char*rsi); Extrae el valor de retorno EDX de la mitad alta del unsigned __int128resultado con 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

Los bloques modificados contra la versión de Daniel tienen (en su mayoría) sangría menos que otras instrucciones. Además, el bucle principal tiene su rama condicional en la parte inferior. Esto resultó ser un cambio neutral porque ninguno de los dos caminos podía caer en la parte superior y eldec ecx / loop .Lentry idea de ingresar al bucle resultó no ser una victoria después de manejar el octal de manera diferente. Pero tiene menos instrucciones dentro del bucle con el bucle en forma idiomática do {} mientras estructura, así que lo guardé.

El arnés de prueba C ++ de Daniel funciona sin cambios en el modo de 64 bits con este código, que utiliza la misma convención de llamada que su respuesta de 32 bits.

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

Desmontaje, incluidos los bytes del código de máquina que son la respuesta 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   

Otros cambios de la versión de Daniel incluyen guardar el sub $16, %al desde el interior del bucle de dígitos, usando más en sublugar detest como parte de la detección de separadores, y dígitos versus caracteres alfabéticos.

A diferencia de Daniel, cada personaje a continuación '0'se trata como un separador, no solo '\''. (Excepto ' ':and $~32, %al / jnzen nuestros dos bucles trata el espacio como un terminador, lo que posiblemente sea conveniente para probar con un número entero al comienzo de una línea).

Cada operación que se modifica %aldentro del bucle tiene una rama que consume banderas establecidas por el resultado, y cada rama va (o cae) a una ubicación 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*
.+;

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Explicación:

T`'L`_l

Eliminar 'sy convertir todo a minúsculas.

\B
:

Separe los dígitos, ya que cualquier dígito hexadecimal debe convertirse a decimal.

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

Identifica la base del número.

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

Convierte los caracteres a-gen números 10-16.

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

Realice la conversión de base en la lista de dígitos. $.($`*$1*_*$2*es la abreviatura de $.($`*$1*_*$2*_)lo que multiplica $`y $1juntos y añade $2. ( $`es la parte de la cadena antes de, ;es decir, la base).

.+;

Eliminar la base.

J , 48 bytes

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

Pruébalo en línea!

Eval después de la sustitución de la cadena.

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/\'//}

Pruébalo en línea!

Perl 6 requiere un 0oprefijo explícito para octal y no admite prefijos en mayúscula como 0X.

Explicación

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

Octava , 29 21 20 bytes

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

Pruébalo en línea!

-8 bytes gracias a @TomCarpenter

Bash, 33 bytes

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

TIO

Zsh, 29 27 bytes

-2 bytes gracias 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

Jalea , 27 bytes

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

Pruébalo en línea!

Casi todo esto es manejo octal. Siente que podría ser mejor golfizado.

Rubí con-n 17 bytes

Solo saltando en el evaltren, de verdad.

p eval gsub(?'){}

Pruébalo en línea!

Java (JDK) , 101 bytes

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

Pruébalo en línea!

Long.decode trata con todo tipo de literales, excepto los binarios.

Plantilla tomada de la respuesta de Benjamin

C (gcc) , 120 118 bytes

-1 byte gracias a 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;}

Pruébalo en línea!

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

Pruébalo en línea

PHP: 43 bytes

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

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

No hay necesidad de pruebas

Requiere instalación g++con soporte C ++ 14

Ahora, explicaciones:

Escribe un archivo llamado a.cpp, usa GCC para compilarlo y le da un archivo que genera el número

Pyth , 27 bytes

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

Pruébalo en línea!

A diferencia de la respuesta Pyth anterior (ahora eliminada), esta pasa todos los casos de prueba en la pregunta, aunque es 3 bytes más larga.

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

Pruébalo en línea!

Java, 158154 bytes

Esto solo esperando ser superado. Solo intenta expresiones regulares hasta que algo funciona y por defecto es hexadecimal.
-4 bytes gracias 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);}

Pruébalo en línea

Usando ScriptEngine, 92 87 bytes

Tren de evaluación llegando. Técnicamente, esto está pasando la antorcha a JS, por lo que no es mi presentación principal.

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

TIO