어떻게 TV 화면에 나타난 6 자리 또는 7 자리 전화 번호를 1 초 동안 기억하지 못합니까?! 아래에 설명 된 특수 기술을 사용하여 걷는 전화 번호부로 바뀝니다!

분명히 숫자 402는 110010010숫자 337377보다 기억하기 쉽고 숫자 는 숫자보다 기억하기 쉽습니다 957472. 즉, 기억 된 숫자는 가능한 한 적은 숫자를 포함해야하며, 다른 한편으로는 가능한 많은 반복 숫자를 포함하는 것이 바람직합니다.

기억하기 어려운 기준으로 숫자의 자릿수와 숫자의 다른 자릿수의 합을 취합니다. 기억 된 숫자는 다른 숫자 시스템에 기록 될 수 있으며, 아마도 기억하기가 더 쉬울 것입니다. 예를 들어 6553516 진수 표기법 의 숫자 는 다음과 같습니다 FFFF.

직무

복잡성 기준을 최소화하기 위해 숫자 시스템의 기준을 선택하기위한 프로그램을 작성해야합니다. 숫자 체계의 밑면은 2에서 36 사이의 범위에서 선택한 다음 숫자 0-9와 영어 문자를 선택해야합니다.A-Z 를 사용하여 숫자를 나타낼 수 있습니다.

입력

입력 값에는 1-999999999의 10 진 정수가 포함됩니다.

산출

출력에는 숫자 시스템의베이스 (2에서 36까지)가 포함되어 있어야하며, 암기 복잡성 기준을 최소화하고 선택한 숫자 시스템의 숫자를 한 칸씩 분리해야합니다. 여러 기준이 기준에 대해 동일한 값을 제공하는 경우 그 중에서 가장 작은 기준을 선택하십시오.

노트

• 글자는 대문자 ( A-Z) 여야합니다 .

테스트 사례

입출력

1              2 1

2              3 2

65535       16 FFFF

123          12 A3

펄 6 , 55 54 바이트

Jo King 덕분에 -1 바이트.

{~map({$^b,.base($b)},2..36).min:{@$_+.Set}o*[1].comb}

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

파이썬 (2) , 150 (149) 127 144 바이트

lambda n:min((len(c(n,b))+len(set(c(n,b))),b,c(n,b))for b in range(2,37))[1:]
c=lambda n,b,s='':n and c(n/b,b,chr(n%b+48+7*(n%b>9))+s)or s or'0'

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

파이썬 3 , 136 바이트

lambda n:min((len((*c(n,b),*{*c(n,b)})),b,c(n,b))for b in range(2,37))[1:]
c=lambda n,b,s='':n and c(n//b,b,chr(n%b+48+7*(n%b>9))+s)or s

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

Python 3.8 (시험판) , 131 바이트

lambda n:min((len((*(x:=c(n,b)),*{*x})),b,x)for b in range(2,37))[1:]
c=lambda n,b,s='':n and c(n//b,b,chr(n%b+48+7*(n%b>9))+s)or s

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

c 10 진수를 10 진수로 변환하고 (2-36) 첫 번째 (익명) 함수는 가장 작은 결과를 찾습니다.

05AB1E , 16 14 바이트

Kevin Cruijssen 덕분에 -1 바이트

₆LBāøΣнDÙìg}1è

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

또는 지정된 출력 형식에 정확하게 일치하도록 끝에 R)»을 추가 하지만 대부분의 다른 답변은 신경 쓰지 않았습니다.

설명:

₆L          # range 1..36
  B         # convert the input to each of those bases
   āø       # enumerate (pair each element with its 1-based index)
Σ     }     # sort by
     g      # length
 н          # of the first element
    ì       # concatenated to
  DÙ        # itself, uniquified
1è          # take the second entry (first will always be base 1)

JavaScript (ES6),  87 85  101 bytes

Edit: +16 useless bytes to comply with the strict output format

n=>(g=m=>--b>2?g(m<(v=new Set(s=n.toString(b)).size+s.length)?m:(o=b+' '+s.toUpperCase(),v)):o)(b=37)

Try it online!

Japt v2.0a0 -gS, 24 23 bytes

Not pretty, but it does the job. +2 bytes for the completely unnecessary requirement that output be uppercase.

37o2@sX u ¸iXÃñÈÌiXÌâ)l

Try it

37o2@sX u ¸iXÃñÈÌiXÌâ)l     :Implicit input of integer
37o2                        :Range [2,37)
    @                       :Map each X
     sX                     :  Convert the input to a base-X string
        u                   :  Uppercase
          ¸                 :  Split on spaces (there are none, so this returns a singleton array)
           iX               :  Prepend X
             Ã              :End map
              ñ             :Sort by
               È            :Pass each X through the following function
                Ì           :  Last element of X
                 i          :  Prepend
                  XÌâ       :    Last element of X, deduplicated
                     )      :  End prepend
                      l     :  Length
                            :Implicit output of the first sub-array, joined with spaces

PHP, 124 119 bytes

for($i=36;$b=strtoupper(base_convert($argn,10,--$i));$o[strlen($b.count_chars($b,3))]="$i $b");krsort($o);echo end($o);

Try it online!

A shame about the +12 bytes in PHP to uppercase the output... but... anyway.

Zsh, 85 bytes

for b ({36..2})x=$[[#$b]$1]&&x=${x#*\#}&&a[$#x+${#${(us::)x}}]=$b\ $x
a=($a)
<<<$a[1]

For this number of statements inside the for loop, using ...&&...&&... is shorter than {...;...;...;}.

for b ({36..2})                   # order decreasing: smaller bases overwrite larger ones
    x=$[[#$b]$1] && \             # set x to [base]#[num] 
    x=${x#*\#} && \               # strip leading [base]#
    a[$#x+${#${(us::)x}}]=$b\ $x  # use score as index to store "[base] [number]"
#            ${(us::) }           # (s::)plit into characters, take (u)nique
a=($a)                            # remove empty elements from array
<<<$a[1]                          # print out the first element (smallest score)

Try it online!

Here's an 81-byte solution which prints in the form [base]#[num] instead:

for b ({36..2})x=$[[#$b]$1]&&y=${x#*\#}&&a[$#y+${#${(us::)y}}]=$x
a=($a)
<<<$a[1]

Try it online!

J, 67 bytes

(];'0123456789ABCDEF'{~b)[:(2+]i.<./)](#+#@~.)@(b=:#.inv~)"+2+i.@35

Try it online!

Charcoal, 38 bytes

Ｎθ≔ＥＥ³⁴↨θ⁺²ιＬ⁺ιΦι⁼λ⌕ικη≔⁺²⌕η⌊ηηＩη ↥⍘θη

Try it online! Link is to verbose version of code. Explanation:

Ｎθ

Input the integer.

≔ＥＥ³⁴↨θ⁺²ι

Convert it from base 2 to base 36...

Ｌ⁺ιΦι⁼λ⌕ικη

... deduplicate, concatenate, and take the length.

≔⁺²⌕η⌊ηη

Take the index of the minimum complexity and add 2 to get the base.

Ｉη ↥⍘θη

Print the base and the integer converted to that base in upper case.

Stax, 19 bytes

Ç╛;ⁿY3█↕(╖S♪*ò▌?½╦l

Run and debug it

No fancy algorithm, just straightforward brute force. About a third of the program is format-wrangling for the precise output rules.

Bonus program: Output for [1..1000]

Jelly, 25 bytes

bⱮ36µQL+LN)Mḟ1Ḣ,ị‘ịØBʋ¥⁸K

Try it online!

A monadic link taking an integer as its argument and returning a Jelly string of the desired format. If a two-item list was acceptable output (as per most challenges), could save 2 bytes. If base 1 were acceptable for the edge case of 1 as input, could save a further 2 bytes.

Brachylog, 44 bytes

∧Y≜∧36≥Xℕ₂≜&ḃ↙X Zd,Zl≡Y∧XwṢwZ{-₁₀;Ạụᵗ∋₍|}ᵐwᵐ

Try it online!

This hurt a bit to write.

Perl 5, 161 bytes

sub f{$X=99;for$b(2..36){$_=c($_[0],$b);$x=uniq(/./g)+y///c;($X,$B,$C)=($x,$b,$_)if$x<$X}$B,$C}
sub c{my($n,$b)=@_;$n?c(int$n/$b,$b).chr(48+$n%$b+7*($n%$b>9)):''}

Try it online!

Python 2, 140 135 bytes

lambda n:min([(b,g(n,b))for b in range(2,36)],key=lambda(b,s):len(s)+len(set(s)))
g=lambda n,b:n and g(n/b,b)+chr(n%b+48+7*(n%b>9))or''

Try it online!

Perl 5 -Minteger -MList::Util=uniq,first -ap, 123 112 bytes

$"=$,;map{@r=();$t="@F";do{unshift@r,(0..9,A..Z)[$t%$_]}while$t/=$_;$a[@r+uniq@r]||="$_ @r"}2..36;$_=first{$_}@a

Try it online!

Wolfram Language (Mathematica), 109 111 bytes

Print[a=OrderingBy[#~IntegerDigits~Range@36,Tr[1^#]+Tr[1^Union@#]&,1][[1]]," ",ToUpperCase[#~IntegerString~a]]&

+2: fixed. Thanks for the catch @Roman

OrderingBy was introduced in Mathematica 12.0, which TIO does not seem to have updated to yet.

C (clang), 165 bytes

n,i=2,j,p=99,r,m,x;char*g,*_,b[74][37];t(n){for(;g=b[i],i<37;r=j<p?_=g,p=j,i:r,++i)for(j=0,m=n;m;m/=i,*--g=x+=x>9?87:48)j+=b[i+36][x=m%i]++?1:2;printf("%i,%s",r,_);}

Try it online!

n//input

,i=2//iterator from base 2 to 36

,j//current complexity

,p=99//best complexity

,r//result = iterator

,m// temp copy of n

,x ;// m%i

char*g // current string ptr

,*_ // best str ptr

,b[74][37];//buffer

/* [37+37] = [strings obtained + test for used characters ] */

t(n){

for(; g=b[i], // move ptr

   i<37 ; 
   r=j<p?_=g,p=j,i:r, // save best solution

   ++i){//for every base

for( j=0,m=n; m ; m/=i, // extract digit

   *--g=x+=x>9?87:48)
   // move ptr backward for printf use and transform to ascii value

j+=b[i+36][x=m%i]++?1:2; // increment byte relative to the character

// and if it was 0 increments j by 2 : 1 for the new character used and 1 for digit count

// else incr only digits count + move pointer

//printf("%s - ",g);// test

// printf("r%i p%i j%i\n",r,p,j);// test

}

printf("%i,%s",r,_);//output

}

Japt v2.0a0, 31 bytes

2o37 ñ@sX Ê+UsX â ÊÃÎ
+S+NÎsU u

Try it