您的任务是将正数用作输入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。

JavaScript（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字节

-2个字节，感谢zgarb

L←fȯ¬tuMBtN

在线尝试！

Mathematica，71个字节

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

在线尝试！

05AB1E，8个字节

L>вʒË}нg

在线尝试！

-1感谢kalsowerus。

Brachylog，12个字节

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

在线尝试！

Python 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）。

Perl 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方法是Python的一般化divmod：它使用除数的一个给定的列表进行重复整数除法，并返回中间余数。
可用于将一个数量分解为多个单位：

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

当传递惰性序列作为除数列表时，polymod当商为零时停止。因此，给它一个无限重复的相同数字，会将输入分解为该基数的数字：

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的位数，然后检查N是否可被基数B中相同的1位数表示的值整除。

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

在线尝试！

Java 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

Java 8，79字节

从Integer到的Lambda 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"