Ao escrever programas de código-golfe , geralmente acabo usando algumas constantes numéricas. Eu sempre os coloco em decimal, porque é assim que penso, mas acabei de perceber que meu idioma suporta outros formatos de números que podem me permitir diminuir um pouco meu código.

Desafio

Dado um número inteiro não negativo menor que 2 ^ 53-1, decida se esse número inteiro tem a menor representação em:

• Decimal
• Hexadecimal
• Notação científica

Decimal

Como esse é o formato padrão do meu idioma, não há notação extra necessária para esse formato. Cada número é representado como de costume para decimal.

Hexadecimal

Meus idiomas usa o 0xprefixo para constantes hexadecimais. Isso significa que, se um número tiver 4 dígitos hexadecimais, serão necessários 6 bytes para representar esse número.

Notação científica

Meu idioma usa o seguinte formato para notação científica:

[Base real] e [Expoente inteiro de 10]

Por exemplo, 700seria representado como 7e3e 699seria representado como 6.99e3, porque a base deve estar entre -10 e 10 (não inclusivo). Para os propósitos deste desafio, a base sempre será pelo menos 0, pois o número inserido não é negativo.

Saída

Você deve retornar uma maneira de identificar qual formato é mais curto (ou seja, 0 para decimal, 1 para hexadecimal, 2 para científico). Como alternativa, você pode gerar a menor representação do número em si.

Casos de teste

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

Pontuação

Isso é código-golfe , então a resposta nos bytes mais curtos para cada idioma vence.

05AB1E , 23 bytes

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

Experimente online!

-1 graças a Emigna .

0para hexadecimal, 1para decimal, 2para científico.

05AB1E , 27 bytes

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

Experimente online!

Explicação

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

Gelatina , 28 bytes

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

Um link monádico retornando 1, 2ou 3hexadecimal, científico ou decimal, respectivamente.

Experimente online! ou veja uma suíte de testes .

Eu pensei que isso seria mais curto, mas não posso vê-lo, então estou postando.

Como essa monstruosidade funciona ...

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 bytes

Retorna 0 para decimal, 1 para hexadecimal, -1 para científico.

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

Explicação

• log(n) / log(10): logaritmo de base 10 de n; aproximadamente o comprimento de ncomo decimal.

• log(n) / log(16) + 2: logaritmo da base 16 de nmais 2; aproximadamente o comprimento de num hexadecimal mais o precedido 0x.

• n.toExponential().length - 1: n.toExponential()retorna uma string nno formato científico (por exemplo 7e+3), mas subtraímos 1 do seu comprimento para explicar o que é estranho +.

Agora que temos os comprimentos de todos os 3 representações D, He S, comparamos:
S<H?-(S<D):+(H<D)

JavaScript (ES6), 97 bytes

Este gera o número no formato com o menor comprimento. Inspirado pela tentativa excluída de @ 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 bytes

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

Irritantemente em C #, o ulong.ToStringespecificador de formato eperde precisão nos números mais altos, então tive que fazer isso manualmente. Provavelmente existe uma maneira mais curta de fazer isso, mas isso funciona por enquanto. Ele também o formata incorretamente para esse desafio, então eu teria que retirar manualmente sua saída de qualquer maneira.

Se eu definir uma string para o valor de n, var s=n+"";pois funciona mais por causa do retorno explícito e de chaves extras.

Retorna o menor valor da matriz de cada valor diferente em que [0] = decimal, [1] = hexadecimal, [2] = scientific.

Versão completa / formatada:

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

A maneira correta de calcular a produção científica é:

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

No entanto, vendo como 0é mais curto do que 0e0eu posso remover esse caso especial.

Python 2, 83 77 bytes

Produz a menor representação do número.

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

Experimente online

Ungolfed:

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)

A regex remove zeros à direita e o ponto decimal, se necessário, além do sinal de mais e zero à esquerda do expoente, se houver um.

Ohm , 35 bytes

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

Experimente online!

Saídas 0 para decimal, 1 para hexadecimal e 2 para científico.

Explicação:

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 bytes

imprime 0 para decimal, 1 para hexadecimal e 2 para científico

em caso de empate, o número mais alto será impresso

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

Experimente online!

PHP , 91 bytes

imprime 0 para decimal, 1 para hexadecimal e 2 para científico

em caso de empate, o número mais baixo será impresso

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

Experimente online!

PHP , 103 bytes

imprime 0 para decimal, 1 para hexadecimal e 2 para científico

em caso de empate, todos os números serão impressos

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;

Experimente online!

PHP , 109 bytes

Saída de uma matriz com as soluções mais curtas

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

Experimente online!

C, 187 185 bytes

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

Descomprimido:

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
}

Imprime 0 para decimal, 1 para hexadecimal, 2 para notação científica.

TI-Basic, 130 bytes

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

Ou alternativamente:

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

Ou, em hexadecimal:

dc4e3eceb84e3ed7303e3170b1c04e04443e3370b1bbbcbbbfbbb642415345104e2b313604483e3004463e3104493ed14e6c4940b8ba4e83493e31304904493e46703104463ed43ec0447131044c3e317044714670104471466c31113e7270b14c117010306fba4c04533e10486c44113210446c53117010486d441110317010486c5311044e3ed6303e4e

Imprime 0 para decimal, 1 para hexadecimal, 2 para notação científica