Ganzzahlige Literale bestehen laut http://en.cppreference.com/w/cpp/language/integer_literal aus einem dezimalen / hexadezimalen / oktalen / binären Literal und einem optionalen ganzzahligen Suffix, das offensichtlich völlig unnötig ist, und wertvolle Bytes verschwendet nicht in dieser Herausforderung verwendet.

Ein Dezimalwörtchen ist 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).

Ein oktales Literal ist the digit zero (0) followed by zero or more octal digits (0, 1, 2, 3, 4, 5, 6, 7).

Ein hexadezimales Literal ist 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)(beachten Sie die Groß- / Kleinschreibung von abcdefx).

Ein binäres Literal ist the character sequence 0b or the character sequence 0B followed by one or more binary digits (0, 1).

Zusätzlich können optional einige 's als Zifferntrennzeichen vorhanden sein. Sie haben keine Bedeutung und können ignoriert werden.

Eingang

Eine Zeichenfolge, die ein ganzzahliges C ++ 14-Literal oder ein Array seiner Zeichencodes darstellt.

Ausgabe

Die Zahl, die durch die Eingabezeichenfolge in Basis 10 dargestellt wird, mit einer optionalen nachgestellten Newline. Die korrekte Ausgabe wird niemals 2 * 10 ^ 9 überschreiten

Gewinnkriterien

Die GCC-Mitarbeiter benötigen dazu mehr als 500 Codezeilen. Deshalb muss unser Code so kurz wie möglich sein!

Testfälle:

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

Probieren Sie es online!

x86-Computercode (32-Bit) 59 57 Bytes

Diese Funktion nimmt esials Zeiger auf eine nullterminierte Zeichenfolge und gibt den Wert in zurück edx. (Die folgende Auflistung enthält die GAS-Eingabe in der AT & T-Syntax.)

        .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

Und eine Zerlegung mit Byteanzahl - diesmal im Intel-Format, falls Sie das vorziehen.

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    

Und für den Fall, dass Sie es versuchen möchten, finden Sie hier den C ++ - Testtreibercode, den ich damit verknüpft habe (einschließlich der Spezifikation der Aufrufkonvention in der 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 Byte aufgrund eines Kommentars von Peter Cordes

-1 Byte vom Aktualisieren, um mit zwei Dekrementen 10 auf 8 zu ändern

JavaScript (Babel Node) , 26 Byte

lol x2

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

Probieren Sie es online!

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

Hierbei handelt es sich um eine Funktion, die ein Array von Zeichen (angegeben als Zeigerpaar zum Anfang und zum Ende - unter Verwendung der beiden Iteratoren) verwendet und die Zahl zurückgibt. Beachten Sie, dass die Funktion das Eingabearray mutiert.

(Dies hängt vom Verhalten von gcc / libstdc ++ ab, #include<cstdlib>das die Funktionen auch in den globalen Bereich einordnet . Ersetzen Sie Code, der den strengen Standards entspricht, durch Code, #include<stdlib.h>der ein weiteres Zeichen kostet.)

Kurzbeschreibung: Der Code wird zuerst std::removezum Herausfiltern von 'Zeichen verwendet (ASCII 39). Dann strtolmit einer Basis von 0 bereits die Dezimal, Oktal handhaben , und hexadezimal Fällen, so dass der einzige andere Fall zu prüfen , ist ein führender 0boder 0Bund wenn ja, für den Basissatz strtolauf 2 und starten , nachdem die führenden 2 Zeichen Parsen.

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

Probieren Sie es online aus.

Sparte 3 Bytes aufgrund des Vorschlags von Ceilingcat und etwas mehr Golfspielen, das folgte.

4 Bytes aufgrund von Vorschlägen von Grastropner gespeichert.

-2 Bytes von Lucas

-12 bytes von l4m2

Python 2 , 32 Bytes

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

Probieren Sie es online!

lol

(Benötigt Python 2, da Python 3 Oktal-Literale in geändert hat 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]

Probieren Sie es online!

strtoiTut alles bis auf die Base 2-Konvertierungen und ignoriert die ', so gibt es ziemlich viele Bytes, nur um diese Dinge zu beheben.

Vielen Dank an Aaron Hayman für -6 Bytes und inspirierende -4 weitere Bytes (und das Zählen!)

Überprüfen Sie alle Testfälle (alte Version)

05AB1E , 16 14 Bytes

2 Bytes dank Grimy gespart

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

Probieren Sie es online! oder als Testsuite

Erläuterung

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

Eingabe von A1, Ausgabe an die Stelle, an der Sie diese Formel eingeben. Matrixformel, verwenden Sie also Ctrl+ Shift+ Enter, um sie einzugeben.

Ich habe ein paar Testfälle hinzugefügt, die Sie im Bild sehen können. Einige frühe Versuche haben alle angegebenen Testfälle korrekt behandelt, aber die Zeilen 16 und / oder 17 sind falsch.

x86-64-Maschinencode, 44 Byte

(Der gleiche Maschinencode funktioniert auch im 32-Bit-Modus.)

@Daniel Scheplers Antwort war ein Ausgangspunkt dafür, aber dies hat mindestens eine neue algorithmische Idee (nicht nur besseres Golfen derselben Idee): Die ASCII-Codes für 'B'( 1000010) und 'X'( 1011000) ergeben nach dem Maskieren mit 16 und 20b0010010 .

Nachdem wir also Dezimalstellen (führende Ziffer ungleich Null) und Oktalstellen (Zeichen danach '0'ist kleiner als 'B') ausgeschlossen haben, können wir einfach base = setzen c & 0b0010010und in die Ziffernschleife springen.

Aufrufbar mit x86-64 System V als unsigned __int128 parse_cxx14_int(int dummy, const char*rsi); Extrahieren Sie den EDX-Rückgabewert aus der oberen Hälfte des unsigned __int128Ergebnisses mit 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

Die geänderten Blöcke gegenüber Daniels Version sind (meistens) weniger eingerückt als andere Anweisungen. Auch die Hauptschleife hat unten ihren bedingten Zweig. Es stellte sich heraus, dass dies eine neutrale Änderung war, da keiner der Pfade in den oberen Bereich fallen konntedec ecx / loop .Lentry Idee, in die Schleife einzutreten, sich nicht als Gewinn herausstellte, nachdem man das Oktal anders gehandhabt hatte. Aber es gibt weniger Anweisungen in der Schleife, wobei die Schleife in der idiomatischen Form do {} while-Struktur ist, also habe ich sie beibehalten.

Daniels C ++ - Test-Harness funktioniert mit diesem Code unverändert im 64-Bit-Modus. Dabei wird dieselbe Aufrufkonvention wie bei seiner 32-Bit-Antwort verwendet.

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

Demontage, einschließlich der Maschinencode-Bytes, die die eigentliche Antwort sind

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   

Andere Änderungen von Daniels Version beinhalten das Speichern des Codes sub $16, %alaus der Ziffernschleife heraus, indem mehr subanstelle von verwendet wirdtest als Teil der Erfassungs Separatoren und Ziffern vs. alphabetischen Zeichen.

Im Gegensatz zu Daniel wird jedes Zeichen '0'als Trennzeichen behandelt, nicht nur '\''. (Außer ' ': and $~32, %al/ jnzin beiden Schleifen wird das Leerzeichen als Abschlusszeichen behandelt, was möglicherweise zum Testen mit einer Ganzzahl am Zeilenanfang nützlich ist.)

Jede Operation, die %alinnerhalb der Schleife geändert wird, weist Verzweigungsverbrauchsflags auf, die vom Ergebnis gesetzt werden, und jede Verzweigung wird an eine andere Position verschoben (oder fällt durch).

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

Probieren Sie es online! Link enthält Testsuite. Erläuterung:

T`'L`_l

Löschen Sie 's und konvertieren Sie alles in Kleinbuchstaben.

\B
:

Trennen Sie die Ziffern, da Hexadezimalzahlen in Dezimalzahlen umgewandelt werden müssen.

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

Identifizieren Sie die Basis der Nummer.

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

Wandle die Zeichen a-gin Zahlen um 10-16.

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

Führen Sie eine Basiskonvertierung für die Ziffernliste durch. $.($`*$1*_*$2*ist kurz für $.($`*$1*_*$2*_)welche multipliziert $`und $1zusammen und addiert $2. ( $`Ist der Teil der Zeichenkette vor ;der Basis.)

.+;

Löschen Sie die Basis.

J , 48 Bytes

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

Probieren Sie es online!

Auswertung nach String-Ersetzung.

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

Probieren Sie es online!

Perl 6 erfordert ein explizites 0oPräfix für Oktal und unterstützt keine Präfixe in Großbuchstaben wie 0X.

Erläuterung

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

Oktave , 29 21 20 Bytes

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

Probieren Sie es online!

-8 Bytes dank @TomCarpenter

Bash, 33 Bytes

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

TIO

Zsh, 29 27 Bytes

-2 Bytes dank @GammaFunction

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

TIO

Geh, 75

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

JavaScript (ES6), 112 Byte

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

Gelee , 27 Bytes

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

Probieren Sie es online!

Fast alles davon ist Umgang mit Oktal. Ich glaube, es könnte besser sein, Golf zu spielen.

Ruby mit -n17 Bytes

Einfach in den evalZug springen , wirklich.

p eval gsub(?'){}

Probieren Sie es online!

Java (JDK) , 101 Byte

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

Probieren Sie es online!

Long.decode befasst sich mit allen Arten von Literalen mit Ausnahme der binären.

Vorlage aus Benjamins Antwort entlehnt

C (GCC) , 120 118 Bytes

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

Probieren Sie es 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);}

Probieren Sie es online aus

PHP - 43 Byte

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

Gleiche Methode wie https://codegolf.stackexchange.com/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");}

Keine Notwendigkeit für Tests

Erfordert die Installation von g++mit C ++ 14-Unterstützung

Nun zu den Erklärungen:

Es schreibt eine aufgerufene Datei a.cpp, kompiliert sie mit GCC und gibt eine Datei aus, die die Nummer ausgibt

Pyth , 27 Bytes

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

Probieren Sie es online!

Im Gegensatz zur vorherigen (jetzt gelöschten) Pyth-Antwort besteht diese alle Testfälle in der Frage, obwohl sie 3 Byte länger ist.

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

Probieren Sie es online!

Java, 158 bis 154 Bytes

Das wartet nur darauf, übervorteilt zu werden. Versucht nur reguläre Ausdrücke, bis etwas funktioniert, und verwendet standardmäßig Hex.
-4 Bytes dank @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);}

Probieren Sie es online aus

Mit ScriptEngine 92 87 Bytes

Eval Zug kommt durch. Technisch gesehen reicht das die Fackel an JS weiter, es ist also nicht meine Hauptaufgabe.

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

TIO