Согласно http://en.cppreference.com/w/cpp/language/integer_literal , целочисленные литералы состоят из десятичного / шестнадцатеричного / восьмеричного / двоичного литерала и необязательного целочисленного суффикса, который, очевидно, совершенно не нужен, тратит драгоценные байты и является не используется в этом вызове.

Десятичный литерал есть 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).

Восьмеричное буквальное обозначение есть the digit zero (0) followed by zero or more octal digits (0, 1, 2, 3, 4, 5, 6, 7).

Шестнадцатеричный литерал 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)(обратите внимание на регистр символов abcdefx).

Бинарный литерал есть the character sequence 0b or the character sequence 0B followed by one or more binary digits (0, 1).

Кроме того, могут быть некоторые 's в качестве разделителя цифр. Они не имеют смысла и могут быть проигнорированы.

вход

Строка, представляющая целочисленный литерал C ++ 14 или массив его кодов.

Выход

Число, представленное входной строкой в ​​базе 10, с необязательным завершающим переводом строки. Правильный вывод никогда не будет превышать 2 * 10 ^ 9

Критерии победы

Для этого участникам GCC требуется более 500 строк кода, поэтому наш код должен быть как можно короче!

Тестовые случаи:

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 байт

OxUr"'

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

Попробуйте онлайн!

32-разрядный машинный код x86, 59 57 байт

Эта функция берет esiуказатель на строку с нулевым символом в конце и возвращает значение в edx. (Ниже приведен вход GAS в синтаксисе 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

И разборка с количеством байтов - на этот раз в формате Intel, если вы предпочитаете этот.

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    

И если вы хотите попробовать это, вот код тестового драйвера C ++, который я с ним связал (включая спецификацию соглашения о вызовах в синтаксисе 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 байт из-за комментария Питера Кордеса

-1 байт от обновления, чтобы использовать два декремента, чтобы изменить 10 на 8

JavaScript (Babel Node) , 26 байт

лол х2

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

Попробуйте онлайн!

C ++ (gcc), 141 138 134 120 байт

Это функция, которая принимает массив символов (заданный в виде пары указателей на начало и конец - с использованием пары итераторов идиомы) и возвращает число. Обратите внимание, что функция мутирует входной массив.

(Это зависит от поведения gcc / libstdc ++, которое #include<cstdlib>также помещает функции в глобальную область видимости. Для строго стандартного кода замените его #include<stdlib.h>на стоимость еще одного символа.)

Краткое описание: Код сначала используется std::removeдля фильтрации 'символов (ASCII 39). Затем strtolс основанием 0 уже будут обрабатываться десятичные, восьмеричные и шестнадцатеричные регистры, поэтому единственный другой случай, который нужно проверить, это ведущий 0bили, 0Bи если так, установите основание для strtol2 и начните анализ после первых 2 символов.

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

Попробуйте онлайн.

Сэкономлено 3 байта благодаря предложению потолка и последующему игре в гольф.

Сохранено 4 байта благодаря предложениям grastropner.

-2 байта от Лукаса

-12 байтов на l4m2

Python 2 , 32 байта

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

Попробуйте онлайн!

смешно

(нужен Python 2, потому что Python 3 изменил восьмеричные литералы на 0o(...)).

Perl 5 (-p), 14 байтов

y/'/_/;$_=eval

TIO

R , 79 71 69 байт

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

Попробуйте онлайн!

strtoiделает все, кроме преобразований base 2 и игнорирования ', так что для исправления этих вещей достаточно много байтов.

Спасибо Аарону Хейману за -6 байтов и за вдохновляющие -4 байта (и считая!)

Проверьте все контрольные примеры (старая версия)

05AB1E , 16 14 байтов

Сохранено 2 байта благодаря Grimy

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

Попробуйте онлайн! или как тестовый набор

объяснение

''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 байт

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

Ввод от А1, вывод туда, куда вы положили эту формулу. Формула массива, поэтому используйте Ctrl+ Shift+, Enterчтобы ввести его.

Я добавил пару тестовых случаев, которые вы можете видеть на картинке - некоторые ранние попытки корректно обрабатывали все данные тестовые примеры, но строки 16 и / или 17 были ошибочными.

машинный код x86-64, 44 байта

(Тот же машинный код работает и в 32-битном режиме.)

Ответ @Daniel Schepler был отправной точкой для этого, но у него есть по крайней мере одна новая алгоритмическая идея (а не просто лучшая игра в ту же идею): ASCII-коды для 'B'( 1000010) и 'X'( 1011000) дают 16 и 2 после маскирования с0b0010010 .

Таким образом, после исключения десятичной (ненулевая начальная цифра) и восьмеричной (символ после '0'меньше 'B'), мы можем просто установить base = c & 0b0010010и перейти в цикл цифр.

Вызывается с x86-64 System V as unsigned __int128 parse_cxx14_int(int dummy, const char*rsi); Извлеките возвращаемое значение EDX из верхней половины unsigned __int128результата с помощью 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

Измененные блоки по сравнению с версией Дэниела (в основном) имеют отступ меньше, чем другие инструкции. Также основной цикл имеет свою условную ветвь внизу. Это оказалось нейтральным изменением, потому что ни один путь не мог попасть в его верхнюю часть, и dec ecx / loop .Lentryидея войти в цикл оказалась не победой после обработки восьмеричного числа по-другому. Но внутри цикла меньше инструкций с циклом в идиоматической форме do {} while struct, поэтому я сохранил его.

Испытание Даниэля C ++ в этом коде работает без изменений в 64-битном режиме, который использует то же соглашение о вызовах, что и его 32-битный ответ.

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

Разборка, включая байты машинного кода, которые являются фактическим ответом

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   

Другие изменения по сравнению с версией Дэниела включают в себя сохранение sub $16, %alизнутри цифрового цикла с использованием большего subвместо testопределения разделителей, а также цифр и буквенных символов.

В отличие от Даниэля, каждый символ ниже '0'рассматривается как разделитель, а не просто '\''. (За исключением ' ': and $~32, %al/ jnzв обоих наших циклах пространство рассматривается как терминатор, что, возможно, удобно для тестирования с целым числом в начале строки.)

Каждая операция, которая изменяется %alвнутри цикла, имеет флаги потребления ветвей, установленные результатом, и каждая ветвь проходит (или проваливается) в другое место.

Сетчатка , 96 байт

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

Попробуйте онлайн! Ссылка включает тестовый набор. Объяснение:

T`'L`_l

Удалить 's и преобразовать все в нижний регистр.

\B
:

Разделяйте цифры, так как любые шестнадцатеричные цифры должны быть преобразованы в десятичные.

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

Определите базу числа.

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

Преобразуйте символы a-gв числа 10-16.

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

Выполните базовое преобразование по списку цифр. $.($`*$1*_*$2*это сокращение для $.($`*$1*_*$2*_)которого умножается $`и $1вместе и добавляет $2. ( $`является частью строки перед ;т. е. основанием.)

.+;

Удалить базу.

J , 48 байтов

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

Попробуйте онлайн!

Eval после подстановки строки.

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 байт

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

Попробуйте онлайн!

Perl 6 требует явного 0oпрефикса для восьмеричного кода и не поддерживает прописные префиксы, такие как 0X.

объяснение

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

Октава , 29 21 20 байт

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

Попробуйте онлайн!

-8 байт благодаря @TomCarpenter

Баш, 33 байта

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

TIO

Зш, 29 27 байт

-2 байта благодаря функции @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 байт

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

Желе , 27 байт

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

Попробуйте онлайн!

Почти все это восьмеричное обращение. Чувствуется, что это может быть лучше в гольф.

Рубин с -n17 байтами

Просто прыгаю в evalпоезде, правда.

p eval gsub(?'){}

Попробуйте онлайн!

Java (JDK) , 101 байт

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

Попробуйте онлайн!

Long.decode имеет дело со всеми видами литералов, кроме двоичных.

Шаблон заимствован из ответа Бенджамина

C (gcc) , 120 118 байтов

-1 байт благодаря возрастанию

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

Попробуйте онлайн!

C (gcc) 101 97 83 байта

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

Попробуйте онлайн

PHP - 43 байта

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

Тот же метод, что и /codegolf//a/185644/45489

C ++, G ++, 189 байт

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

Нет необходимости в тестах

Требуется установка g++с поддержкой C ++ 14

Теперь объяснения:

Он записывает файл с именем a.cpp, использует GCC для его компиляции и дает файл, который выводит число

Pyth , 27 байт

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

Попробуйте онлайн!

В отличие от предыдущего (теперь удаленного) ответа Pyth, он проходит все тестовые случаи в вопросе, хотя он на 3 байта длиннее.

C (gcc) / Bash / C ++, 118 байт

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

Попробуйте онлайн!

Java, 158 154 байта

Это просто ожидание, чтобы обойтись. Просто пытается регулярные выражения, пока что-то работает, и по умолчанию в hex.
-4 байта благодаря @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);}

Попробуйте онлайн

Используя ScriptEngine, 92 87 байт

Eval поезд приближается. Технически это передача факела JS, так что это не моя основная подача.

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

TIO