Nhiệm vụ của bạn là lấy một số dương làm đầu vào, n và xuất độ dài của biểu diễn chữ số lặp lại dài nhất của n trong bất kỳ cơ sở nào. Ví dụ 7 có thể được biểu diễn dưới dạng bất kỳ thứ nào sau đây

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

Các đại diện chữ số là 111_2và 11_6, 111_2dài nên câu trả lời của chúng tôi là 3.

Đây là một câu hỏi golf-code vì vậy câu trả lời sẽ được tính bằng byte, với ít byte hơn sẽ tốt hơn.

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

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

Mẫu thực hiện

Đây là một triển khai trong Haskell có thể được sử dụng để tạo ra nhiều trường hợp thử nghiệm hơn.

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]

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

Thạch , 9 byte

b‘Ḋ$EÐfZL

Một liên kết đơn và chấp nhận số

Hãy thử trực tuyến! hoặc xem bộ kiểm tra (bao gồm một đến 32).

Làm sao?

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

... hoặc có lẽ tôi nên làm:

bḊEÐfZLo1

Đối với Lo1z.

JavaScript (ES6), 62 byte

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>

Haskell , 86 81 79 byte

Lưu 2 byte nhờ Laikoni

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

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

Vì điều này đã giảm xuống một chút, đây là cách tiếp cận của tôi. Đây là phiên bản đánh gôn của mã mẫu tôi đã tạo cho câu hỏi. Tôi nghĩ rằng nó chắc chắn có thể ngắn hơn. Tôi chỉ nghĩ rằng tôi sẽ đưa nó ra khỏi đó.

Husk , 13 11 byte

-2 byte nhờ zgarb

L←fȯ¬tuMBtN

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

Toán học, 71 byte

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

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

05AB1E , 8 byte

L>вʒË}нg

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

-1 nhờ kalsowerus .

Brachylog , 12 byte

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

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

Python 3 , 92 87 byte

5 byte nhờ Halvard Hummel.

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)

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

Toán học, 58 byte

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

Ném một lỗi (vì cơ sở 1 không phải là cơ sở hợp lệ), nhưng nó an toàn để bỏ qua.

Tất nhiên, có thể lấy độ dài của chữ số đầu tiên ( FirstCase), vì các số ở các cơ sở thấp hơn không thể ngắn hơn trong các cơ sở cao hơn.

CJam (17 byte)

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

Bộ kiểm tra trực tuyến . Đây là một khối ẩn danh (hàm) lấy một số nguyên trên ngăn xếp và để lại một số nguyên trên ngăn xếp.

Hoạt động với lực lượng vũ phu, sử dụng 3làm cơ sở dự phòng để xử lý các trường hợp đặc biệt (đầu vào 1hoặc 2).

Perl 6 , 49 byte

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

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

Giải trình

{                                               }  # 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.

Các polymod phương pháp là một sự tổng quát của Python divmod: Nó thực hiện phân chia số nguyên lặp đi lặp lại sử dụng một danh sách nhất định ước, và trả về dư trung gian.
Nó có thể được sử dụng để phân tách một số lượng thành nhiều đơn vị:

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

Khi vượt qua một chuỗi lười biếng như danh sách các ước, polymod dừng lại khi thương số bằng không. Do đó, cho nó một sự lặp lại vô hạn của cùng một số, phân tách đầu vào thành các chữ số của cơ sở đó:

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

Tôi sử dụng điều này ở đây vì nó cho phép các cơ sở cao tùy ý, trái ngược với .basephương pháp dựa trên chuỗi chỉ hỗ trợ tối đa cơ sở 36.

TI-BASIC, 37 byte

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

Nhắc cho N, trả về đầu ra trong Ans.

Giải trình

Về tổng quan, đối với mỗi cơ sở B có thể theo trình tự, trước tiên, nó sẽ tính số chữ số của N khi được biểu thị trong cơ sở B, sau đó kiểm tra xem N có chia hết cho giá trị được biểu thị bằng cùng một số có 1 chữ số trong cơ sở B.

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.

Bình thường , 13 byte

lhf!t{TjLQ}2h

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

Java 8, 111 byte

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

Số byte của 111 cũng là một chữ số lặp lại. ;)

Giải trình:

Hãy thử nó ở đây.

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 byte

Một lambda từ Integerđến 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;}}

Lambda

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

Kiểm tra radice theo thứ tự tăng dần từ 2 cho đến khi tìm thấy một cơ số có chữ số lặp lại. Dựa vào thực tế là cơ số nhỏ nhất như vậy sẽ tương ứng với một đại diện có nhiều chữ số nhất.

mlà một bản sao của đầu vào, blà cơ số và llà số chữ số được kiểm tra (và cuối cùng là độ dài của bbiểu diễn cơ số).

Burlesque, 24 byte

(xem giải pháp đúng dưới đây)

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

Xem trong hành động .

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.

Ít nhất nếu trực giác của tôi là đúng rằng một đại diện chữ số sẽ luôn dài nhất? Nếu không thì ...

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

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