Selon http://en.cppreference.com/w/cpp/language/integer_literal , les littéraux entiers se composent d'un littéral décimal / hex / octal / binaire et d'un suffixe entier facultatif, ce qui est évidemment complètement inutile, gaspille de précieux octets et est pas utilisé dans ce défi.

Un littéral décimal est 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 littéral octal est the digit zero (0) followed by zero or more octal digits (0, 1, 2, 3, 4, 5, 6, 7).

Un littéral hexadécimal est 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)(notez l'insensibilité à la casse de abcdefx).

Un littéral binaire est the character sequence 0b or the character sequence 0B followed by one or more binary digits (0, 1).

De plus, il peut éventuellement y avoir des 's comme séparateur de chiffres. Ils n'ont aucun sens et peuvent être ignorés.

Contribution

Une chaîne qui représente un littéral entier C ++ 14 ou un tableau de ses codes de caractères.

Sortie

Le nombre représenté par la chaîne d'entrée en base 10, avec une nouvelle ligne de fin facultative. La sortie correcte ne dépassera jamais 2 * 10 ^ 9

Critères gagnants

Les contributeurs du GCC ont besoin de plus de 500 lignes de code pour ce faire, donc notre code doit être aussi court que possible!

Cas de test:

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 octets

OxUr"'

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

Essayez-le en ligne!

code machine x86 (32 bits), 59 57 octets

Cette fonction prend esicomme pointeur vers une chaîne terminée par un caractère nul et renvoie la valeur dans edx. (La liste ci-dessous est une entrée GAS dans la syntaxe 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

Et un démontage avec nombre d'octets - au format Intel cette fois, au cas où vous préférez celui-là.

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    

Et au cas où vous voudriez l'essayer, voici le code du pilote de test C ++ que j'ai lié avec lui (y compris la spécification de convention d'appel dans la syntaxe 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 octet dû au commentaire de Peter Cordes

-1 octet de mise à jour pour utiliser deux décrémentations pour passer de 10 à 8

JavaScript (nœud Babel) , 26 octets

lol x2

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

Essayez-le en ligne!

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

Il s'agit d'une fonction qui prend un tableau de caractères (spécifié comme une paire de pointeurs au début et à la fin - à l'aide de la paire d'itérateurs idiome) et renvoie le nombre. Notez que la fonction mute le tableau d'entrée.

(Cela dépend du comportement de gcc / libstdc ++ qui #include<cstdlib>place également les fonctions dans une portée globale. Pour du code conforme strictement standard, remplacez-le par #include<stdlib.h>pour un coût d'un caractère de plus.)

Brève description: Le code premières utilisations std::removepour filtrer les 'caractères (ASCII 39). Ensuite, strtolavec une base de 0, les cas décimaux, octaux et hexadécimaux seront déjà traités, de sorte que le seul autre cas à vérifier est un début 0bou 0B, si tel est le cas, définissez la base pour strtol2 et commencez l'analyse après les 2 premiers caractères.

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

Essayez-le en ligne.

Enregistré 3 octets en raison de la suggestion de plafond et d'autres golfs qui ont suivi.

4 octets enregistrés grâce aux suggestions de grastropner.

-2 octets par Lucas

-12 octets par l4m2

Python 2 , 32 octets

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

Essayez-le en ligne!

lol

(nécessite Python 2 car Python 3 a changé les littéraux octaux en 0o(...)).

Perl 5 (-p), 14 octets

y/'/_/;$_=eval

TIO

R , 79 71 69 octets

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

Essayez-le en ligne!

strtoifait tout sauf les conversions en base 2 et en ignorant le ', donc il y a pas mal d'octets juste pour corriger ces choses.

Merci à Aaron Hayman pour -6 octets, et inspirant -4 autres octets (et ça compte!)

Vérifier tous les cas de test (ancienne version)

05AB1E , 16 14 octets

Enregistré 2 octets grâce à Grimy

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

Essayez-le en ligne! ou comme suite de tests

Explication

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

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

Entrée à partir de A1, sortie à l'endroit où vous mettez cette formule. Formule matricielle, utilisez donc Ctrl+ Shift+ Enterpour la saisir.

J'ai ajouté quelques cas de test que vous pouvez voir dans l'image - certaines premières tentatives ont traité correctement tous les cas de test donnés, mais les lignes 16 et / ou 17 étaient incorrectes.

code machine x86-64, 44 octets

(Le même code machine fonctionne également en mode 32 bits.)

La réponse de @Daniel Schepler était un point de départ pour cela, mais cela a au moins une nouvelle idée algorithmique (pas seulement un meilleur golf de la même idée): les codes ASCII pour 'B'( 1000010) et 'X'( 1011000) donnent 16 et 2 après le masquage avec0b0010010 .

Donc, après avoir exclu décimal (premier chiffre non nul) et octal (le caractère après '0'est inférieur à 'B'), nous pouvons simplement définir base = c & 0b0010010et sauter dans la boucle numérique.

Appelable avec x86-64 System V as unsigned __int128 parse_cxx14_int(int dummy, const char*rsi); Extraire la valeur de retour EDX de la moitié supérieure du unsigned __int128résultat avec 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

Les blocs modifiés par rapport à la version de Daniel sont (principalement) indentés moins que les autres instructions. La boucle principale a également sa branche conditionnelle en bas. Cela s'est avéré être un changement neutre car aucun des deux chemins ne pouvait tomber dans le haut, et l' dec ecx / loop .Lentryidée d'entrer dans la boucle s'est avérée ne pas être une victoire après avoir traité octal différemment. Mais il a moins d'instructions à l'intérieur de la boucle avec la boucle sous forme idiomatique faire {} tout en structure, donc je l'ai gardée.

Le harnais de test C ++ de Daniel fonctionne inchangé en mode 64 bits avec ce code, qui utilise la même convention d'appel que sa réponse 32 bits.

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

Démontage, y compris les octets de code machine qui sont la réponse réelle

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   

D'autres changements par rapport à la version de Daniel incluent l'enregistrement de l' sub $16, %alintérieur de la boucle numérique, en utilisant plus subau lieu de testdans le cadre de la détection des séparateurs, et des chiffres par rapport aux caractères alphabétiques.

Contrairement à Daniel, chaque personnage ci '0'- dessous est traité comme un séparateur, pas seulement '\''. (Sauf' ' : and $~32, %al/ jnzdans nos deux boucles traite l'espace comme un terminateur, ce qui est peut-être pratique pour tester avec un entier au début d'une ligne.)

Chaque opération qui se modifie %alà l'intérieur de la boucle a un indicateur de consommation de branche défini par le résultat, et chaque branche va (ou tombe) à un emplacement différent.

Rétine , 96 octets

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

Essayez-le en ligne! Le lien inclut une suite de tests. Explication:

T`'L`_l

Supprimez 's et convertissez tout en minuscules.

\B
:

Séparez les chiffres, car tout chiffre hexadécimal doit être converti en décimal.

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

Identifiez la base du numéro.

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

Convertissez les caractères a-gen nombres 10-16.

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

Effectuez la conversion de base sur la liste des chiffres. $.($`*$1*_*$2*est court pour $.($`*$1*_*$2*_)lequel se multiplie $`et $1ensemble et ajoute $2. ( $`est la partie de la chaîne qui précède ;la base.)

.+;

Supprimez la base.

J , 48 octets

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

Essayez-le en ligne!

Évalue après substitution de chaîne.

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 octets

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

Essayez-le en ligne!

Perl 6 nécessite un 0opréfixe explicite pour octal et ne prend pas en charge les préfixes majuscules comme 0X.

Explication

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

Octave , 29 21 20 octets

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

Essayez-le en ligne!

-8 octets grâce à @TomCarpenter

Bash, 33 octets

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

TIO

Zsh, 29 27 octets

-2 octets grâce à @GammaFunction

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

TIO

Allez, 75

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

JavaScript (ES6), 112 octets

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

Gelée , 27 octets

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

Essayez-le en ligne!

Presque tout cela est en octal. On dirait qu'il pourrait être mieux joué au golf.

Rubis avec -n, 17 octets

Sauter dans le evaltrain, vraiment.

p eval gsub(?'){}

Essayez-le en ligne!

Java (JDK) , 101 octets

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

Essayez-le en ligne!

Long.decode traite de toutes sortes de littéraux à l'exception des binaires.

Modèle emprunté à la réponse de Benjamin

C (gcc) , 120 118 bytes

-1 octet grâce au plafond

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

Essayez-le en ligne!

C (gcc), 101 97 83 octets

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

Essayez-le en ligne

PHP - 43 octets

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

Même méthode que /codegolf//a/185644/45489

C ++, G ++, 189 octets

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

Pas besoin de tests

Nécessite l'installation de g++ avec le support C ++ 14

Maintenant, explications:

Il écrit un fichier appelé a.cpp, utilise GCC pour le compiler et donne un fichier qui affiche le nombre

Pyth , 27 octets

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

Essayez-le en ligne!

Contrairement à la réponse Pyth précédente (maintenant supprimée), celle-ci passe tous les cas de test dans la question, bien qu'elle soit plus longue de 3 octets.

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

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

Essayez-le en ligne!

Java, 158 154 octets

Cela n'attend que d'être surpassé. Essaie juste les expressions rationnelles jusqu'à ce que quelque chose fonctionne et par défaut à hex.
-4 octets grâce à @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);}

Essayez-le en ligne

Utilisation de ScriptEngine, 92 87 octets

Le train Eval passe. Techniquement, cela passe le flambeau à JS, ce n'est donc pas ma principale soumission.

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

TIO