Code-golf programlarını yazarken genellikle bazı sayısal sabitleri kullanırım. Onları her zaman ondalık koydum, çünkü böyle düşünüyorum, ancak dilimin kodumu biraz kısaltmama izin verecek diğer sayı biçimlerini desteklediğini fark ettim.

Meydan okuma

2 ^ 53-1 den küçük negatif olmayan bir tamsayı verildiğinde, tamsayı için aşağıdaki en kısa gösterime sahip olup olmadığına karar verin:

• Ondalık
• onaltılık
• Bilimsel gösterim

Ondalık

Bu, dilimin varsayılan biçimi olduğundan, bu biçim için fazladan bir gösterim yoktur. Her sayı ondalık için her zamanki gibi gösterilir.

onaltılık

Dillerim 0xonaltılık sabitler için ön eki kullanır . Bu, bir sayının 4 onaltılık basamağı varsa, bu sayıyı temsil etmesi 6 bayt alacağı anlamına gelir.

Bilimsel gösterim

Dilim bilimsel gösterimde aşağıdaki formatı kullanıyor:

[Gerçek baz] e [Tam sayı üssü 10]

Örneğin, 700olarak temsil edilen 7e3, ve 699ile temsil edilir 6.99e3, çünkü, temel -10 ila 10 arasında olması gerekir (dahil değildir). Bu zorluğun amaçları doğrultusunda, girilen sayı negatif olmadığından taban her zaman en az 0 olacaktır.

Çıktı

Hangi biçimin en kısa olduğunu belirlemenin bir yolunu döndürmelisiniz (örneğin, ondalık için 0, altıgen için 1, bilimsel için 2). Alternatif olarak, sayının kendisinin en küçük gösterimini yazdırabilirsiniz.

Test durumları

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

puanlama

Bu kod golf , yani her dil için en kısa bayttaki cevap kazanıyor.

05AB1E , 23 bayt

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

Çevrimiçi deneyin!

-1, Emigna'ya teşekkürler .

0Onaltılık için, 1ondalık 2için, bilimsel için.

05AB1E , 27 bayt

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

Çevrimiçi deneyin!

açıklama

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

Jöle , 28 bayt

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

Bir monadic bağlantı dönen 1, 2ya da 3sırasıyla onaltılık, bilimsel veya ondalık için.

Çevrimiçi deneyin! veya bir test odasına bakın .

Bunun daha kısa olacağını düşündüm, ancak göremiyorum bu yüzden gönderiyorum.

Bu canavarlık nasıl çalışır?

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 bayt

Ondalık için 0, onaltılık için 1, bilimsel için -1 döndürür.

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

açıklama

• log(n) / log(10): 10 baz logaritması n; kabaca nbir ondalık olarak uzunluğu .

• log(n) / log(16) + 2: nartı 16'nın baz-16 logaritması ; kabaca nonaltılık artı belirtilen uzunluk olarak 0x.

• n.toExponential().length - 1: bilimsel formatta n.toExponential()bir dize döndürür n(örneğin 7e+3), ancak yabancıyı hesaba katan uzunluktan 1 çıkardık +.

Şimdi hepimiz 3 temsiller uzunlukları sahip olduğunu D, Hve Sbiz karşılaştırmak:
S<H?-(S<D):+(H<D)

JavaScript (ES6), 97 bayt

Bu, sayıyı en kısa uzunluktaki biçimde verir. @ Shaggy tarafından silinen girişimden ilham alındı .

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 bayt

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

Can sıkıcı ulong.ToStringbiçimde C # dilinde format belirteci edaha yüksek sayılardaki hassasiyetini kaybeder, bu yüzden manuel olarak yapmak zorunda kaldım. Bunu yapmak için muhtemelen daha kısa bir yol var ama bu şimdilik işe yarıyor. Ayrıca bu zorluk için yanlış biçimlendirir, bu yüzden yine de çıktısını elle çıkarmam gerekirdi.

Ben değerine bir dize ayarlarsanız nolarak var s=n+"";bunun nedeni açık getiri ve ekstra küme parantezleri uzun dışarı çalışır.

Her farklı değerin dizisindeki en kısa değeri döndürür [0] = decimal, [1] = hexadecimal, [2] = scientific.

Tam / Biçimli sürüm:

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

Bilimsel çıktıyı hesaplamanın doğru yolu:

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

Ancak, bu özel durumu kaldırabildiğimden 0daha kısa olarak görmek 0e0.

Python 2, 83 77 bayt

Sayının en küçük gösterimini verir.

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

Çevrimiçi deneyin

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)

Düzenli ifade, izleyen sıfırları ve gerekirse ondalık noktasını, artı işaretini ve varsa sıfırdan üstteki sıfırı kaldırır.

Ohm , 35 bayt

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

Çevrimiçi deneyin!

Ondalık için 0, hex için 1 ve bilimsel için 2 çıktılar.

Açıklama:

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 bayt

ondalık için 0, onaltılık için 1 ve bilimsel için 2

beraberlik durumunda en yüksek numara yazdırılır

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

Çevrimiçi deneyin!

PHP , 91 bayt

ondalık için 0, onaltılık için 1 ve bilimsel için 2

beraberlik durumunda en düşük numara yazdırılır

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

Çevrimiçi deneyin!

PHP , 103 bayt

ondalık için 0, onaltılık için 1 ve bilimsel için 2

beraberlik durumunda tüm numaralar basılacaktır

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;

Çevrimiçi deneyin!

PHP , 109 bayt

En kısa çözümlerle bir dizi çıktısı alın

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

Çevrimiçi deneyin!

C, 187 185 bayt

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

dekompresyonlu:

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
}

Ondalık için 0, altı için 1, bilimsel gösterim için 2 yazdırabilir.

TI-Basic, 130 bayt

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

Veya alternatif olarak:

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

Veya, altıgen cinsinden:

dc4e3eceb84e3ed7303e3170b1c04e04443e3370b1bbbcbbbfbbb642415345104e2b313604483e3004463e3104493ed14e6c4940b8ba4e83493e31304904493e46703104463ed43ec0447131044c3e317044714670104471466c31113e7270b14c117010306fba4c04533e10486c44113210446c53117010486d441110317010486c5311044e3ed6303e4e

Ondalık basım için 0, altıgen basım için 1, bilimsel gösterim için 2 basım