당신의 임무는 양수를 입력 n 으로 취하고 모든 밑에서 n 의 가장 긴 대표 자릿수 표현의 길이를 출력하는 것 입니다. 예를 들어 7은 다음 중 하나로 나타낼 수 있습니다.

111_2
21_3
13_4
12_5
11_6
10_7
7_8

기라 자리는 111_2하고 11_6, 111_2우리의 대답은 3 그래서 더 길다.

이것은 코드 골프 질문이므로 바이트 수가 적을수록 답이 바이트로 표시됩니다.

테스트 사례

1   -> 1
2   -> 1
3   -> 2
4   -> 2
5   -> 2
6   -> 2
7   -> 3
8   -> 2
9   -> 2
10  -> 2
11  -> 2
26 -> 3
63  -> 6
1023-> 10

샘플 구현

다음은 더 많은 테스트 사례를 생성하는 데 사용할 수있는 Haskell의 구현입니다.

f 0 y=[]
f x y=f(div x y)y++[mod x y]
s x=all(==x!!0)x
g x=maximum$map(length.f x)$filter(s.f x)[2..x+1]

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

젤리 , 9 바이트

b‘Ḋ$EÐfZL

숫자를 받아들이고 돌려주는 모나드 링크

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오(1에서 32까지 입력).

어떻게?

b‘Ḋ$EÐfZL - Link: number, n
   $      - last two links as a monad:
 ‘        -   increment = n+1
  Ḋ       -   dequeue (with implicit range build) = [2,3,4,...,n+1]
b         - convert to those bases
     Ðf   - filter keep if:
    E     -   all elements are equal
       Z  - transpose
        L - length (note:  length of the transpose of a list of lists is the length of the
          -                longest item in the original list, but shorter than L€Ṁ)

... 또는 아마도 내가해야했을 것입니다 :

bḊEÐfZLo1

용 Lo1Z.

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

f=(n,b=2,l=0,d=n)=>d?n%b<1|n%b-d%b?f(n,b+1):f(n,b,l+1,d/b|0):l

<input oninput=o.textContent=f(this.value)><pre id=o>

하스켈 , 86 81 79 바이트

Laikoni 덕분에 2 바이트 절약

0!y=[]
x!y=mod x y:div x y!y
length.head.filter(all=<<(==).head).(<$>[2..]).(!)

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

이것이 조금 죽었으므로 여기에 내 접근 방식이 있습니다. 질문을 위해 만든 샘플 코드의 골프 버전입니다. 나는 그것이 더 짧을 수 있다고 생각합니다. 난 그냥 거기에 넣어 줄 알았는데.

껍질 , 13 11 바이트

zgarb 덕분에 -2 바이트

L←fȯ¬tuMBtN

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

Mathematica, 71 바이트

Max[L/@Select[Array[a~IntegerDigits~#&,a=#,2],(L=Length)@Union@#==1&]]&

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

05AB1E , 8 바이트

L>вʒË}нg

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

kalsowerus 에게 -1 감사합니다 .

Brachylog , 12 바이트

+₁⟦₁b∋;?ḃ₍=l

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

파이썬 3 , 92 87 바이트

Halvard Hummel 덕분에 5 바이트.

g=lambda n,b,s=1:s*(n<b)or(n%b**2%-~b<1)*g(n//b,b,s+1)
f=lambda n,b=2:g(n,b)or f(n,b+1)

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

Mathematica, 58 바이트

FirstCase[#~IntegerDigits~Range[#+1],l:{a_ ..}:>Tr[1^l]]&

base-1이 유효한 base가 아니기 때문에 오류가 발생하지만 무시해도됩니다.

물론, FirstCase낮은베이스의 숫자는 높은베이스의 숫자보다 짧을 수 없으므로 첫 번째 반복 숫자 ( ) 의 길이를 가져도 됩니다.

CJam (17 바이트)

{_,2>3+fb{)-!}=,}

온라인 테스트 스위트 . 이것은 익명 블록 (함수)이며 스택에서 정수를 가져 와서 스택에 정수를 남깁니다.

3특수한 경우 (입력 1또는 2) 를 처리하기 위해 대체 기반으로 사용하는 무차별 대입

펄 6 , 49 바이트

{+first {[==] $_},map {[.polymod($^b xx*)]},2..*}

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

설명

{                                               }  # A lambda.
                  map {                   },2..*   # For each base from 2 to infinity...
                        .polymod($^b xx*)          #   represent the input in that base,
                       [                 ]         #   and store it as an array.
  first {[==] $_},                                 # Get the first array whose elements
                                                   # are all the same number.
 +                                                 # Return the length of that array.

polymod에 있어서 파이썬의 일반화 divmod:이 약수의 지정된 목록을 사용하여 반복되는 정수 나눗셈을 수행하고, 상기 중간 나머지를 반환한다.
수량을 여러 단위로 분해하는 데 사용할 수 있습니다.

my ($sec, $min, $hrs, $days, $weeks) = $seconds.polymod(60, 60, 24, 7);

제수 목록으로 게으른 시퀀스를 전달할 때 polymod 하면 몫이 0에 도달하면 중지됩니다. 따라서, 같은 수의 무한 반복을 제공하면 입력을 그 밑의 숫자로 분해합니다.

my @digits-in-base-37 = $number.polymod(37 xx *);

.base최대 36을 지원 하는 문자열 기반 방법 과 달리 임의로 높은베이스를 허용하기 때문에 이것을 사용 합니다.

TI-BASIC, 37 바이트

Input N
For(B,2,2N
int(log(NB)/log(B
If fPart(N(B-1)/(B^Ans-1
End

N을 입력하라는 메시지가 표시되고 Ans로 출력이 반환됩니다.

설명

개괄적으로, 가능한 모든 기본 B에 대해 순서대로 기본 B에 표시 될 때 N의 자릿수를 먼저 계산 한 다음, 기본 B에 동일한 수의 1 자리로 표시되는 값으로 N을 나눌 수 있는지 확인합니다.

Input N            Ask the user for the value of N.
For(B,2,2N         Loop from base 2 to 2N. We are guaranteed a solution
                   at base N+1, and this suffices since N is at least 1.
int(log(NB)/log(B  Calculate the number of digits of N in base B,
                   placing the result in Ans.
                   This is equivalent to floor(log_B(N))+1.
          (B-1)/(B^Ans-1   The value represented by Ans consecutive
                           1-digits in base B, inverted.
If fpart(N         Check whether N is divisible by the value with Ans
                   consecutive 1-digits, by multiplying it by the inverse
                   and checking its fractional part.
                   Skips over the End if it was divisible.
End                Continue the For loop, only if it was not divisible.
                   The number of digits of N in base B is still in Ans.

Pyth , 13 바이트

lhf!t{TjLQ}2h

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

자바 8, 111 바이트

n->{int r=0,i=1,l;for(String t;++i<n+2;r=(l=t.length())>r&t.matches("(.)\\1*")?l:r)t=n.toString(n,i);return r;}

111의 바이트 수는 또한 대표 숫자입니다. ;)

설명:

여기에서 시도하십시오.

n->{                            // Method with Integer as parameter return-type
  int r=0,                      //  Result-integer
      i=1,                      //  Index-integer
      l;                        //  Length-integer
  for(String t;                 //  Temp-String
      ++i<n+2;                  //  Loop from 2 to `n+2` (exclusive)
      r=                        //    After every iteration, change `r` to:
        (l=t.length())>r        //     If the length of `t` is larger than the current `r`
        &t.matches("(.)\\1*")?  //     and the current `t` is a rep-digit:
         l                      //      Change `r` to `l` (the length of the rep-digit)
        :                       //     Else:
         r)                     //      Leave `r` as is
    t=n.toString(n,i);          //   Set String representation of `n` in base-`i` to `t`
                                //  End of loop (implicit / single-line body)
  return r;                     //  Return the result-integer
}                               // End of method

자바 8, 79 바이트

발 람다 Integer로 Integer.

n->{int m,b=2,l;for(;;b++){for(m=n,l=0;m>0&m%b==n%b;l++)m/=b;if(m<1)return l;}}

언 골프 람다

n -> {
    int m, b = 2, l;
    for (; ; b++) {
        for (m = n, l = 0; m > 0 & m % b == n % b; l++)
            m /= b;
        if (m < 1)
            return l;
    }
}

담당자 숫자 기수가 발견 될 때까지 2부터 증가하는 기수를 점검합니다. 그러한 기수가 가장 작을수록 숫자가 가장 많은 표현에 해당한다는 사실에 의존합니다.

m는 입력의 사본이고 b기수이며, l확인 된 자릿수 (및 궁극적으로 기수 b표현 의 길이 )입니다.

해 학적 인, 24 바이트

(아래 올바른 해결책 참조)

J2jr@jbcz[{dgL[}m^>]

를 참조하십시오 행동 .

J2jr@ -- boiler plate to build a list from 2..N
jbcz[ -- zip in N
{dgL[}m^ -- calculate base n of everything and compute length
>]    -- find the maximum.

적어도 내 직감이 옳다면 담당자 숫자 표현이 항상 가장 길다는 것입니까? 그렇지 않으면 ...

J2jr@jbcz[{dg}m^:sm)L[>]

:sm -- filter for "all elements are the same"