코드 골프 프로그램을 작성할 때 일반적으로 숫자 상수를 사용합니다. 나는 항상 그렇게 생각하기 때문에 10 진수로 넣었습니다. 그러나 언어가 코드를 약간 단축시킬 수있는 다른 숫자 형식을 지원한다는 것을 깨달았습니다.

도전

음수가 아닌 정수가 2 ^ 53-1보다 작은 경우 다음에서 정수가 가장 짧은 표현인지 여부를 결정하십시오.

• 소수
• 16 진수
• 과학적 표기법

소수

이것이 내 언어의 기본 형식이므로이 형식에 대한 추가 표기법이 필요하지 않습니다. 모든 숫자는 평소와 같이 10 진수로 표시됩니다.

16 진수

내 언어는 0x16 진 상수에 접두사를 사용합니다 . 즉, 숫자에 4 개의 16 진수가있는 경우 해당 숫자를 나타내는 데 6 바이트가 필요합니다.

과학적 표기법

내 언어는 과학 표기법에 다음 형식을 사용합니다.

[실수] e [정수 지수 10]

예를 들어, 700같은 표현 될 것입니다 7e3, 그리고 699로 표현 될 수 6.99e3있기 때문에, 기본 -10과 10 사이 여야합니다 (비 포함). 입력 된 숫자가 음수가 아니기 때문에이 문제를 해결하기 위해 기준은 항상 0 이상입니다.

산출

가장 짧은 형식을 식별하는 방법을 반환해야합니다 (예 : 10 진수는 0, 16 진수는 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

채점

이것은 code-golf 이므로 각 언어에 대한 최단 바이트의 답이 이깁니다.

05AB1E , 23 바이트

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

온라인으로 사용해보십시오!

Emigna 에게 -1 감사합니다 .

016 진수, 110 진수, 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각각 진수, 과학, 또는 10 진수합니다.

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

나는 이것이 더 짧을 것이라고 생각했지만 게시 할 수는 없습니다.

이 괴물이 어떻게 작동 하는가 ...

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)

자바 스크립트 (ES6), 90 바이트

10 진수는 0, 16 진수는 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; 대략 n10 진수 길이입니다 .

• log(n) / log(16) + 2: n더하기 2 의 밑이 16 인 로그 ; 대략 n16 진수 + 앞에 붙인 0x.

• n.toExponential().length - 1: 과학적 형식 (예 :)으로 n.toExponential()문자열을 반환 하지만 외래를 설명하기 위해 길이에서 1을 뺍니다 .n7e+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.

파이썬 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)

정규식은 필요한 경우 후행 0과 소수점을 제거하고 지수에서 더하기 부호와 선행 0을 제거합니다.

옴 , 35 바이트

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

온라인으로 사용해보십시오!

10 진수는 0, 16 진수는 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 바이트

10 진수는 0, 16 진수는 1, 과학은 2를 출력합니다

동점 인 경우 가장 높은 숫자가 인쇄됩니다

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

온라인으로 사용해보십시오!

PHP , 91 바이트

10 진수는 0, 16 진수는 1, 과학은 2를 출력합니다

동점 인 경우 가장 낮은 숫자가 인쇄됩니다

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

온라인으로 사용해보십시오!

PHP , 103 바이트

10 진수는 0, 16 진수는 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
}

10 진수는 0, 16 진수는 1, 과학적 표기법은 2를 인쇄합니다.

TI 기본, 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

또는 16 진수로 :

dc4e3eceb84e3ed7303e3170b1c04e04443e3370b1bbbcbbbfbbb642415345104e2b313604483e3004463e3104493ed14e6c4940b8ba4e83493e31304904493e46703104463ed43ec0447131044c3e317044714670104471466c31113e7270b14c117010306fba4c04533e10486c44113210446c53117010486d441110317010486c5311044e3ed6303e4e

십진수는 0, 16 진수는 1, 과학적 표기법은 2를 인쇄합니다