Khi viết chương trình golf-code , tôi thường kết thúc bằng cách sử dụng một số hằng số. Tôi luôn đặt chúng ở dạng thập phân vì đó là cách tôi nghĩ, nhưng tôi chỉ nhận ra rằng ngôn ngữ của tôi hỗ trợ các định dạng số khác có thể giúp tôi rút ngắn mã của mình một chút.

Thử thách

Cho một số nguyên không âm nhỏ hơn 2 ^ 53-1, hãy quyết định xem số nguyên đó có biểu diễn ngắn nhất trong:

• Số thập phân
• Hệ thập lục phân
• Ký hiệu khoa học

Số thập phân

Vì đây là định dạng mặc định của ngôn ngữ của tôi, nên không cần thêm ký hiệu nào cho định dạng này. Mỗi số được biểu diễn như bình thường cho số thập phân.

Hệ thập lục phân

Ngôn ngữ của tôi sử dụng 0xtiền tố cho hằng số thập lục phân. Điều này có nghĩa là nếu một số có 4 chữ số thập lục phân, nó sẽ mất 6 byte để biểu thị số đó.

Ký hiệu khoa học

Ngôn ngữ của tôi sử dụng định dạng sau cho ký hiệu khoa học:

[Cơ sở thực] e [Số nguyên của 10]

Ví dụ, 700sẽ được biểu diễn dưới dạng 7e3và 699sẽ được biểu diễn dưới dạng 6.99e3, vì cơ sở phải nằm trong khoảng từ -10 đến 10 (không bao gồm). Đối với mục đích của thử thách này, cơ sở sẽ luôn có ít nhất là 0, vì số được nhập là không âm.

Đầu ra

Bạn nên trả về cách xác định định dạng nào ngắn nhất (nghĩa là 0 cho số thập phân, 1 cho hex, 2 cho khoa học). Ngoài ra, bạn có thể xuất đại diện nhỏ nhất của chính số đó.

Các trường hợp thử nghiệm

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

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời bằng byte ngắn nhất cho mỗi ngôn ngữ sẽ thắng.

05AB1E , 23 byte

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

Hãy thử trực tuyến!

-1 cảm ơn Emigna .

0cho thập lục phân, 1cho thập phân, 2cho khoa học.

05AB1E , 27 byte

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

Hãy thử trực tuyến!

Giải trình

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

Thạch , 28 byte

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

Một liên kết đơn âm trở lại 1, 2hoặc 3cho thập lục phân, khoa học hoặc thập phân tương ứng.

Hãy thử trực tuyến! hoặc xem một bộ thử nghiệm .

Tôi nghĩ rằng nó sẽ ngắn hơn, nhưng tôi không thể thấy nó được đăng.

Làm thế nào sự quái dị này hoạt động ...

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 byte

Trả về 0 cho số thập phân, 1 cho số thập lục phân, -1 cho tính khoa học.

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

Giải trình

• log(n) / log(10): logarit cơ sở 10 của n; gần bằng chiều dài của nmột số thập phân.

• log(n) / log(16) + 2: logarit cơ sở-16 ncộng 2; gần bằng chiều dài của nmột thập lục phân cộng với tiền tố 0x.

• n.toExponential().length - 1: n.toExponential() trả về một chuỗi có nđịnh dạng khoa học (ví dụ 7e+3) nhưng chúng tôi trừ đi 1 từ chiều dài của chuỗi để tính đến phần bên ngoài +.

Bây giờ chúng ta có độ dài của tất cả 3 cơ quan đại diện D, Hvà S, chúng ta so sánh:
S<H?-(S<D):+(H<D)

JavaScript (ES6), 97 byte

Cái này xuất ra số ở định dạng với độ dài ngắn nhất. Lấy cảm hứng từ nỗ lực bị xóa của @ 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 byte

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

Khó chịu trong C #, trình ulong.ToStringxác định định dạng emất độ chính xác ở các số cao hơn nên tôi phải thực hiện thủ công. Có lẽ có một cách ngắn hơn để làm điều đó nhưng bây giờ nó hoạt động. Nó cũng định dạng không chính xác cho thử thách này vì vậy tôi sẽ phải tự gỡ bỏ đầu ra của nó.

Nếu tôi đặt một chuỗi thành giá trị nvì var s=n+"";nó hoạt động lâu hơn vì trả về rõ ràng và thêm dấu ngoặc nhọn.

Nó trả về giá trị ngắn nhất từ ​​mảng của mỗi giá trị khác nhau trong đó [0] = decimal, [1] = hexadecimal, [2] = scientific.

Phiên bản đầy đủ / được định dạng:

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

Cách chính xác để tính toán đầu ra khoa học là:

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

Tuy nhiên, thấy như 0là ngắn hơn 0e0tôi có thể loại bỏ trường hợp đặc biệt đó.

Con trăn 2 83 77 byte

Xuất ra đại diện nhỏ nhất của số.

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

Dùng thử trực tuyến

Ung dung:

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)

Regex loại bỏ các số 0 ở cuối và dấu thập phân nếu cần, cũng như dấu cộng và dẫn 0 từ số mũ nếu có.

Ồ , 35 byte

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

Hãy thử trực tuyến!

Đầu ra 0 cho số thập phân, 1 cho hex và 2 cho khoa học.

Giải trình:

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 byte

in 0 cho thập phân, 1 cho thập lục phân và 2 cho khoa học

trong trường hợp hòa, số cao nhất sẽ được in

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

Hãy thử trực tuyến!

PHP , 91 byte

in 0 cho thập phân, 1 cho thập lục phân và 2 cho khoa học

trong trường hợp hòa, số thấp nhất sẽ được in

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

Hãy thử trực tuyến!

PHP , 103 byte

in 0 cho thập phân, 1 cho thập lục phân và 2 cho khoa học

trong trường hợp hòa, tất cả các số sẽ được in

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;

Hãy thử trực tuyến!

PHP , 109 byte

Xuất ra một mảng với các giải pháp ngắn nhất

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

Hãy thử trực tuyến!

C, 187 185 byte

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

Giải né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
}

In 0 cho số thập phân, 1 cho hex, 2 cho ký hiệu khoa học.

TI-Basic, 130 byte

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

Hay cách khác:

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

Hoặc, trong hex:

dc4e3eceb84e3ed7303e3170b1c04e04443e3370b1bbbcbbbfbbb642415345104e2b313604483e3004463e3104493ed14e6c4940b8ba4e83493e31304904493e46703104463ed43ec0447131044c3e317044714670104471466c31113e7270b14c117010306fba4c04533e10486c44113210446c53117010486d441110317010486c5311044e3ed6303e4e

In 0 cho số thập phân, 1 cho hex, 2 cho ký hiệu khoa học