Analysieren Sie ein ganzzahliges C ++ 14-Literal

27

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
Mein Pronomen ist monicareinstate
quelle
2
Sandbox-Link
mein Pronomen ist monicareinstate
4
@ LuisfelipeDejesusMunoz Nein; Wie haben Sie damit gerechnet, dass das analysiert wird?
Mein Pronomen ist monicareinstate
1
Ich gehe davon aus, dass das Schreiben einer Funktion in C ++ 14 schummeln würde, oder? Da der Compiler es bereits automatisch macht (auch wenn es intern mehr als 500 Codezeilen sind ...)
Darrel Hoffman
5
@ DarrelHoffman Man konnte es aber nicht einfach mit "einer Funktion in C ++ 14" machen, da dies keine Zeichenketteneingabe erforderte. Vielleicht mit einem Skript, das einen C ++ - Compiler aufruft.
Aschepler
2
Die Zeichenfolge ist 0möglicherweise ein guter Testfall (es wurde ein Fehler in einer meiner letzten Überarbeitungen festgestellt).
Daniel Schepler

Antworten:

6

Japt , 6 Bytes

OxUr"'

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

Probieren Sie es online!

Luis Felipe De Jesus Munoz
quelle
Wie funktioniert das?
Lirtosiast
@ Lirtosiast Grundsätzlich das gleiche wie meine js Antwort. Ich entferne 'von der Eingabe und
bewerte
22

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

Daniel Schepler
quelle
1
Es fehlen nur Tests auf Überläufe ... Compiler melden eine zu große Anzahl.
Alexis Wilke
2
Können Sie Ihre Registerverwendung für Swap rdxund RBX ? Then you can use 1-byte cdq` auf Null rdxab eax.
Peter Cordes
1
Dies sollte entweder die Byteanzahl Ihrer Assembly auflisten oder als 59 Bytes x86-Maschinencode gekennzeichnet sein.
Potato44
2
@PeterCordes Danke, wusste nichts davon. (Auch als ich es mir noch einmal ansah, bemerkte ich, dass das Ändern der Basis von 10 auf 8 2 Bytes - von zwei Dekrementierungsanweisungen - anstelle von 3 Bytes sein kann.)
Daniel Schepler
3
@AlexisWilke Es wird auch nicht auf ungültige Formate geprüft (z. B. Ziffern außerhalb des Bereichs der angegebenen Basis), was Compiler ebenfalls tun würden. Laut Problemanweisung ist die Eingabe jedoch garantiert gültig und es wird kein 32-Bit-Integer mit Vorzeichen überlaufen.
Daniel Schepler
12

JavaScript (Babel Node) , 26 Byte

lol x2

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

Probieren Sie es online!

Luis Felipe De Jesus Munoz
quelle
4
Dies ist nicht BabelJS exklusiv, es funktioniert ab ES6
Bassdrop Cumberwubwubwub
1
@BassdropCumberwubwubwub, der Header wurde wahrscheinlich von TIO kopiert.
Shaggy
Nizza, ich habe zuerst versucht zu verwenden, Numberweil es binär und hex behandelt, aber anscheinend nicht oktalNumber("010") === 10
Carl Walsh
7

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

Daniel Schepler
quelle
134 Bytes
Gastropner
Incorporated, danke.
Daniel Schepler
Wenn eine ungültige Eingabe undefiniertes Verhalten ist, muss nicht überprüft werden, ob das erste 0
Zeichen
so 124
14m2
5

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(...)).

HyperNeutrino
quelle
3
Wir haben zu diesem Zeitpunkt wirklich den Kreis geschlossen
osuka_
4

Perl 5 (-p), 14 Bytes

y/'/_/;$_=eval

TIO

Nahuel Fouilleul
quelle
4

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)

Giuseppe
quelle
kann ein Byte speichern, das sub("0b|B"durch ersetzt wird sub("b|B", da die führende "0" den Wert nicht beeinflusst. Kann eine andere durch Umbenennen bekommenstrtoi
Aaron Hayman
1
74 bytes: Probieren Sie es online!
Aaron Hayman
1
@ Aaron Hayman Wow, ich habe noch nie na.omitzuvor gesehen . Super praktisch hier und ich hab ein bisschen mehr golfen :-)
Giuseppe
1
Wenn wir annehmen, dass jeder Fehler des ersten strtoieine Binärdatei ist, können Sie substringstattdessen Folgendes verwenden sub, um ein weiteres Byte zu speichern: Probieren Sie es online aus!
Aaron Hayman
1
@AaronHayman wir können die ersten 2 Zeichen der sVerwendung abstreifen substatt mitsub('..','',s) dem ein weiteres Byte kürzer!
Giuseppe
4

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
Emigna
quelle
-2 Bytes
Grimmy
Und hier ist eine gefälschte 13 (besteht alle Testfälle, scheitert aber zB 0010).
Grimmy
@ Grimy: Danke! Coole Verwendung von ï!
Emigna
4

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.

Bildbeschreibung hier eingeben

Sophia Lechner
quelle
Verstößt es gegen die Regeln, die letzten beiden schließenden Klammern wegzulassen und die Tatsache auszunutzen, dass der „Compiler“ (Drücken der Eingabetaste oder der Tabulatortaste) für Sie fehlerkorrigiert?
Lucas
Meiner persönlichen Meinung nach ja. Ich glaube nicht, dass es einen Site-Konsens gibt. Das Hinzufügen der Klammern in Excel fühlt sich wie das Äquivalent einer Code-Vervollständigungs-Funktion in der IDE einer anderen Sprache an, die für die Byte-Zählung ignoriert werden sollte. (Aber ich denke, "?" Sollte als 1 Byte in BASIC gezählt werden, obwohl es stillschweigend zu "PRINT" erweitert wird, so dass ich hier möglicherweise nicht ganz konsistent bin).
Sophia Lechner
3

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

Peter Cordes
quelle
eaxBenötigen Sie überhaupt die Initialisierung , dass AIUI im 64-Bit-Modus Opcodes mit kleinem Ziel die höheren Bits auf 0 zurücksetzt?
Daniel Schepler
@ Daniel: Das Schreiben eines 32-Bit-Registers erstreckt sich von null auf 64-Bit . Durch das Schreiben eines 8- oder 16-Bit-Registers wird das Verhalten anderer Modi beibehalten: Zusammenführen mit dem vorhandenen Wert. AMD64 nicht die falsche Abhängigkeit für 8 und 16-Bit - Register beheben, und änderte sich nicht setcc r/m8in setcc r/m32, so dass wir immer noch eine dumme 2-Befehl benötigen xor-Nullsignal / set flags / setcc %alSequenz eine 32/64-Bit erstellen 0 oder 1 Variable, und es benötigt das Nullregister vor dem Setzen des Flags. (Oder verwenden Sie mov $0, %eaxstattdessen oder movzxauf dem kritischen Pfad).
Peter Cordes
1

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.

Neil
quelle
Ich schätze den wörtlichen Programmieransatz, den Sie gewählt haben, um den Code zu erklären :-)
grooveplex
1

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
FrownyFrog
quelle
Es scheint nicht richtig mit Hexadezimalzahlen zu funktionieren, die Folgendes enthalten 0b: tio.run/##FcwxCsIwFAbg/…
Galen Ivanov
1
@GalenIvanov netter Fund, behoben
FrownyFrog
1

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
nwellnhof
quelle
1

Oktave , 29 21 20 Bytes

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

Probieren Sie es online!

-8 Bytes dank @TomCarpenter

Abgelaufene Daten
quelle
Für 22 Bytes:@(x)str2num(x(x~="'"))
Tom Carpenter
Was für 21 Bytes wird:@(x)str2num(x(x~=39))
Tom Carpenter
Octal scheint nicht zu funktionieren (zumindest bei TIO) ... f=("077")kehrt zum Beispiel zurück, ans = 77wenn es 63 sein sollte. Oder, wie im Testfall in OP, f=("012345")sollte es stattdessen 5349 zurückgebenans = 12345
brhfl
1

Bash, 33 Bytes

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

TIO

Zsh, 29 27 Bytes

-2 Bytes dank @GammaFunction

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

TIO

Nahuel Fouilleul
quelle
Klug! Ich hätte gedacht, setopt octalzeroeswäre für Zsh notwendig.
GammaFunction
Sie können 2 Bytes in Zsh mit <<<$[...]anstelle vonecho $[...]
GammaFunction
danke, ich wusste nicht, dass der Befehl zsh empty mit Umleitung die Ausgabe anzeigen kann, ich weiß nicht viel über zsh, ich weiß viel besser bash
Nahuel Fouilleul
ich wusste, dass bash automatisch zahlen mit führender null bis oktal interpretiert und zum beispiel in datum / zeit entfernt werden muss
nahuel fouilleul
0

Geh, 75

import "strconv"
func(i string)int64{n,_:=strconv.ParseInt(i,0,0);return n}
vityavv
quelle
Dies scheint weder für Binärliterale noch für Ziffernbegrenzer mit einfachen Anführungszeichen zu funktionieren.
Nick Matteo
Oh Mist. Ich werde es bald beheben. Vollständig vergessen die Begrenzer
Vityavv
0

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
Naruyoko
quelle
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.

Nick Kennedy
quelle
0

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

Shieru Asakoto
quelle
Nett. Ich muss mehr auf die Funktionen schauen, die primitive Wrapper haben
Benjamin Urquhart
0

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

Johan du Toit
quelle
0

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

HatsuPointerKun
quelle
175 Bytes
Ceilingcat
0

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.

randomdude999
quelle
Willkommen auf der Seite!
Weizen-Assistent
0

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!

Johan du Toit
quelle
Ich habe Code gespielt. Dann habe ich gemerkt, dass es überhaupt keinen Grund dafür gibt, zu arbeiten, aber es scheint zu funktionieren; 158 Bytes .
Mein Pronomen ist monicareinstate
@jemand, es ist böse, aber ich mag es!
Johan du Toit,
148 Bytes durch Zusammenführen popenundsystem . Ich denke -x, G ++ hat ein Flag , das man aus stdin lesen kann. Das ist vielleicht kürzer als offenes Zeug, aber ich weiß nicht, wie ich mit stdin in C aufrufen soll
mein Pronomen ist monicareinstate
@ jemand, alles ist jetzt in den popenBefehl zusammengeführt
Johan du Toit
printf-> echoscheint zu funktionieren. Sie werden bald in Bash programmieren.
Mein Pronomen ist monicareinstate
0

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

Benjamin Urquhart
quelle
Verwenden Sie [bBxX]und 0[bB].+für einige schnelle Regex-Optimierungen.
Value Ink
@ValueInk danke
Benjamin Urquhart
Das ist nicht ein Integer Es ist ein lang, der Titel sagt klar Integer, eine einfache oder doppelte Genauigkeit IEEE754 aufgrund falsch werden könnte die Methode die Zahl , wenn aufgrund der Dezimalstelle System in IEEE754 speichern verwendet en.wikipedia.org/wiki/ IEEE_754 # Roundings_to_nearest , es unterstützt auch eine Zahl höher als 2 Billionen ( 0x9999999999)
Martin Barker
@MartinBarker ist es erlaubt zu verwenden , Longanstatt Integerfür Golf Zwecke. Wenn Sie korrekt sind, kann Python auch nicht mithalten, da es über Ganzzahlen mit willkürlicher Genauigkeit verfügt. Außerdem ist a longin Java eine Ganzzahl, die mit 64 Bits anstelle von 32 dargestellt wird. Es gibt keine Dezimalstellen.
Benjamin Urquhart
Die lange Sache war nur, dass Sie lange keine ganze Zahl verwenden und Sie sich in Bezug auf die Golf-Zwecke irren. The correct output never will exceed 2*10^9Sie besagt ganz klar, dass lange nicht alleine verwendet werden kann, weil ich es geben kann 0x9999999999und es eine Zahl hervorbringen wird höher als 2 * 10 ^ 9, während C ++ ein Speicherüberlaufproblem verursachen würde, da Sie mehr als 32 Bit im Speicher verwenden, wenn Sie dieser Nummer nur 32 Bit Speicher zugewiesen haben
Martin Barker,