Під час написання програм з кодом-гольфу я зазвичай закінчую використання деяких числових констант. Я завжди ставлю їх у десяткові, бо так я думаю, але я просто зрозумів, що моя мова підтримує інші формати чисел, які можуть дозволити мені трохи скоротити код.

Виклик

З огляду на невід'ємне ціле число менше 2 ^ 53-1, вирішіть, чи має це ціле число найкоротше представлення у:

• Десяткові
• Шестидесятковий
• Наукове позначення

Десяткові

Оскільки це формат моєї мови за замовчуванням, для цього формату не потрібні додаткові позначення. Кожне число представлене, як правило, для десятків.

Шестидесятковий

Мої мови використовують 0xприставку для шістнадцяткових констант. Це означає, що якщо число має 4 шістнадцяткових цифри, це знадобиться 6 байтів.

Наукові позначення

Моя мова використовує такий формат для наукових позначень:

[Реальна база] e [Коефіцієнт цілого числа 10]

Наприклад, 700буде представлено як 7e3, і 699буде представлено як 6.99e3, тому що база повинна бути між -10 та 10 (не включно). Для цілей цього виклику база завжди буде принаймні 0, оскільки введене число невід'ємне.

Вихідні дані

Вам слід повернути спосіб визначення того, який формат найкоротший (тобто 0 для десяткової, 1 для шестигранної, 2 для наукової). Крім того, ви можете вивести найменше представлення самого числа.

Тестові справи

Decimal       | Hexadecimal  | Scientific        | Winner
--------------|--------------|-------------------|-------------
0             | 0x0          | 0e0               | Decimal
15            | 0xF          | 1.5e1             | Decimal
6999          | 0x1B57       | 6.999e3           | Decimal
7000          | 0x1B58       | 7e3               | Scientific
1000000000000 | 0xE8D4A51000 | 1e12              | Scientific
1000000000001 | 0xE8D4A51001 | 1.000000000001e12 | Hexadecimal
1000000001000 | 0xE8D4A513E8 | 1.000000001e12    | Hexadecimal
1000001000000 | 0xE8D4B45240 | 1.000001e12       | Scientific

Оцінка балів

Це код-гольф , тому відповідь у найкоротших байтах для кожної мови виграє.

05AB1E , 23 байти

hg̹gD<g>¹ÀðìÁ0ÜðÜg+)Wk

Спробуйте в Інтернеті!

-1 завдяки Еміньї .

0для шістнадцяткової, 1для десяткової, 2для наукової.

05AB1E , 27 байт

Dg<¹À'.ìÁ0Ü'.Ü…ÿeÿIh…0xÿ)é¬

Спробуйте в Інтернеті!

Пояснення

D                            # duplicate input, one copy will be used as decimal notation
 g<                          # len(input)-1
   ¹À                        # push input and rotate left
     '.ìÁ                    # prepend a dot and rotate right
         0Ü'.Ü               # remove trailing zeroes and then any trailing dot
              …ÿeÿ           # format scientific notation
                  Ih         # input converted to hex
                    …0xÿ     # format hex
                        )    # wrap in a list
                         é   # sort by length
                          ¬  # get the first (shortest) item

Желе , 28 байт

TṀµỊ¬+‘
DµL’DL+Ç,L
b⁴L+2;ÇỤḢ

Монадичне посилання, що повертається 1, 2або 3для шістнадцяткової, наукової чи десяткової відповідно.

Спробуйте в Інтернеті! або переглянути тестовий набір .

Я думав, що це буде коротше, але я не бачу цього, тому розміщую повідомлення.

Як працює ця жахливість ...

TṀµỊ¬+‘    - Link 1, length of mantissa + "e": list of decimal digits  e.g. [7,0,1,0]
T          - truthy indexes                                                 [1,  3  ]
 Ṁ         - maximum                                                             3
  µ        - monadic chain separation, call that m
   Ị       - insignificant? (abs(m)<=1) -- here: 1 for m=1, 0 otherwise          0
    ¬      - logical not                  i.e. 1 if a "." will be used           1
     +     - add m                                                               4
      ‘    - increment                    always uses an 'e'                     5

DµL’DL+Ç,L - Link 2, lengths of scientific and decimal notations: non-negative-integer, n
D          - cast to decimal list
 µ         - monadic chain separation, call that d
  L        - length of d (number of decimal digits of n)
   ’       - decrement (value of exponent)
    D      - cast to decimal list (exponent's digits)
     L     - length (number of characters in the exponent)
       Ç   - call last link (1) as a monad(d) (number of characters in mantissa + "e")
         L - length of d (number of decimal digits of n)
        ,  - pair

b⁴L+2;ÇỤḢ - Main link: non-negative-integer, n
 ⁴        - literal 16
b         - convert n to base 16
  L       - length (number of hexadecimal digits)
   +2     - add two (number of characters including the "0x")
      Ç   - call the last link (2) as a monad (characters in scientific and decimal)
     ;    - concatenate ([charsInHexadecimal, charsInScientific, charsInDecimal])
       Ụ  - sort indexes by value
        Ḣ - head (1-based-index in the above list of (one of) the shortest)

JavaScript (ES6), 90 байт

Повертає 0 для десяткової, 1 для шістнадцяткової, -1 для наукової.

n=>(l=Math.log,D=l(n)/l(10),H=l(n)/l(16)+2,S=n.toExponential().length-1,S<H?-(S<D):+(H<D))

f=
n=>(l=Math.log,D=l(n)/l(10),H=l(n)/l(16)+2,S=n.toExponential().length-1,S<H?-(S<D):+(H<D))

console.log(
    f(0),
    f(15),
    f(6999),
    f(7000),
    f(1000000000000),
    f(1000000000001),
    f(1000000001000),
    f(1000001000000)
)

Пояснення

• log(n) / log(10): основа-10 логарифм n; приблизно довжина nяк десятковий.

• log(n) / log(16) + 2: база-16 логарифм nплюс 2; приблизно довжина nяк шістнадцяткова плюс плюс передбачувана 0x.

• n.toExponential().length - 1: n.toExponential()повертає рядок nу науковому форматі (наприклад 7e+3), але ми віднімаємо 1 від його довжини для врахування сторонніх +.

Тепер, коли ми маємо довжину всіх 3 -х уявлень D, Hі Sми порівнюємо:
S<H?-(S<D):+(H<D)

JavaScript (ES6), 97 байт

Цей виводить число у форматі з найменшою довжиною. Натхненний видаленою спробою @ Shaggy .

n=>[n+'','0x'+n.toString(16),n.toExponential().replace('+','')].sort((x,y)=>x.length-y.length)[0]

f=
n=>[n+'','0x'+n.toString(16),n.toExponential().replace('+','')].sort((x,y)=>x.length-y.length)[0]

console.log(
    f(0),
    f(15),
    f(6999),
    f(7000),
    f(1000000000000),
    f(1000000000001),
    f(1000000001000),
    f(1000001000000)
)

C #, 106 97 96 143 132 байт

using System.Linq;n=>new[]{n+"",$"0x{n:X}",(n+"").Insert(1,".").TrimEnd('0','.')+"e"+((n+"").Length-1)}.OrderBy(s=>s.Length).First()

Прикро в C # ulong.ToStringспецифікатор формату eвтрачає точність на більші числа, тому мені довелося це робити вручну. Мабуть, існує коротший спосіб зробити це, але це працює зараз. Він також форматує його неправильно для цього виклику, тому мені доведеться все одно вручну знімати його вихід.

Якщо я встановив рядок у значення, nоскільки var s=n+"";воно працює довше через явне повернення та додаткові фігурні дужки.

Він повертає найменше значення з масиву кожного різного значення де [0] = decimal, [1] = hexadecimal, [2] = scientific.

Повна / відформатована версія:

using System.Linq;
Func<ulong, string> f = n =>
    new[]
    {
        n + "",
        $"0x{n:X}",
        (n + "").Insert(1, ".").TrimEnd('0', '.') + "e" + ((n + "").Length - 1)
    }.OrderBy(s => s.Length).First();

Правильний спосіб розрахунку наукових результатів:

(n < 1 ? n + "" : (n + "").Insert(1, ".").TrimEnd('0', '.')) + "e" + ((n + "").Length - 1)

Однак, побачивши, що 0коротше, 0e0я можу зняти цей особливий випадок.

Python 2, 83 77 байт

Виводить найменше представлення числа.

import re
lambda n:min(`n`,hex(n),re.sub('\.?0*e\+0?','e','%.15e'%n),key=len)

Спробуйте в Інтернеті

Безголівки:

import re
n=input()
d=`n`
h=hex(n)
s=re.sub('(.)\.?0*e\+0?',r'\1e','%.15e'%n)
print min(d,h,s,key=len)

Регекс при необхідності видаляє проміжні нулі та десяткову крапку, а також знак плюс і ведучий нуль із показника, якщо такий є.

Ом , 35 байт

l┼xl2+┼DRîsRl≥al≤Dla°┼îa/ì\?≥;+WD╤k

Спробуйте в Інтернеті!

Виходи 0 для десяткової, 1 для шестигранної та 2 для наукової.

Пояснення:

l                                      Implicit input, get length                                          
 ┼                                     Input again
  x                                    To hex
   l                                   Get length
    2+                                 Add 2 because of "0x"
      ┼                                Get input again
       D                               Duplicate on the stack
        RîsR                           Remove zeroes at the end (reverse, to int, to string, reverse)
            l                          Get length (= length of base)
             ≥                         Add 1 because to count "e" in the scientific notation
              a                        Swap top two values on the stack
               l≤                      Get length - 1 ( = get the exponent of 10 in scientific notation)
                 D                     Duplicate on the stack
                  l                    Get length ( = length of the exponent)
                   a                   Swap. Now on top of the stack we have the exponent again
                    °                  10^exponent
                     Ō                Get input for the fourth time
                       a/              Divide input by the 10^exp calculated earlier
                         ì\?           If this thing is not an integer...
                            ≥;         ...add one to count the "."
                              +        Sum base length ( + "e") + exponent length ( + ".")
                               W       Wrap stack in array
                                D      Duplicate
                                 ╤k    Get index of min value

PHP , 90 байт

відбитки 0 для десяткової, 1 для шістнадцяткової та 2 для наукової

у випадку краватки найвищим числом буде друк

<?=array_flip($m=[$l=log10($a=$argn)^0,2+(log($a,16)^0),strlen(($a/10**$l).$l)])[min($m)];

Спробуйте в Інтернеті!

PHP , 91 байт

відбитки 0 для десяткової, 1 для шістнадцяткової та 2 для наукової

у випадку краватки найменшим числом буде друк

<?=array_search(min($m=[$l=log10($a=$argn)^0,2+(log($a,16)^0),strlen(($a/10**$l).$l)]),$m);

Спробуйте в Інтернеті!

PHP , 103 байти

відбитки 0 для десяткової, 1 для шістнадцяткової та 2 для наукової

у випадку краватки всі номери будуть надруковані

foreach($m=[$l=log10($a=$argn)^0,2+(log($a,16)^0),strlen(($a/10**$l).$l)]as$k=>$v)echo$v-min($m)?"":$k;

Спробуйте в Інтернеті!

PHP , 109 байт

Виведіть масив з найкоротшими рішеннями

for(;!$p=preg_grep("#^.{".++$i."}$#",[$a=$argn,"0x".dechex($a),$a/10**($l=log10($a)^0)."e$l"]););print_r($p);

Спробуйте в Інтернеті!

C, 187 185 байт

main(){long long N;scanf("%lli",&N);long long D=log10(N)+1,H=log(N)/log(16)+3,F,S,i=1;while(N>i&&!(N%i))i*=10,F++;S=ceil(log10(D-1))+1+D-F+(D-F>1);printf("%i",N?H>D?2*(D>S):1+(H>S):N);}

Декомпресія:

void main(){
    long long N;
    scans("%lli", &N);
    long long D = log10(N) + 1; // Length of number (decimal)
    long long H = log(N)/log(16) + 3; // Length of number (hexadecimal)
    long long F; // Number of 0s at the end of decimal number
    long long S; // Length of number (scientific notation)
    long long i; // Counter (more or less)
    // Get number of zeros at the end of decimal number
    while(N > i && (N % i) == 0){
        i = i * 10;
        F++;
    }
    S = ceil(log10(D - 1)) + 1 + D - F + (D-F>1); // (Power) + (e) + (multiplier + (1 if len(multiplier) > 1))
    printf("%i", N!=0 ?
                (H > D ? 2 * (D > S) : 1 + (H > S)) 
              : 0); // Print the shortest number
}

Відбитки 0 для десяткової, 1 для шістнадцяткової, 2 для наукової нотації.

TI-Basic, 130 байт

Input N:If not(N:Goto 0:1+int(log(N→D:3+int(logBASE(N,16→H:0→F:1→I:While N>I and not(fPart(N/I:10I→I:F+1→F:End:log(D-1→L:1+D-F+(D-F>1):Ans+int(L)+(0≠fPart(L→S:(H>D)2(D>S)+(H≤D)(1+(H>S)→N:Lbl 0:N

Або, як варіант:

�N>θN>�0>1p��ND>3p�������BASEN+16H>0F>1I>�NlI@��N�I>10II>Fp1F>�>�Dq1L>1pDqFpDqFl1>rp�Lp0o�LS>HlD2DlSpHmD1pHlSN>�0>N

Або шістнадцятково:

dc4e3eceb84e3ed7303e3170b1c04e04443e3370b1bbbcbbbfbbb642415345104e2b313604483e3004463e3104493ed14e6c4940b8ba4e83493e31304904493e46703104463ed43ec0447131044c3e317044714670104471466c31113e7270b14c117010306fba4c04533e10486c44113210446c53117010486d441110317010486c5311044e3ed6303e4e

Відбитки 0 для десяткової, 1 для шестигранної, 2 для наукових позначень