Ваша задача - взять положительное число в качестве входных данных 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

Для Lo1Я.

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>

Haskell , 86 81 79 байтов

2 байта сохранены благодаря Laikoni

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 .

Брахилог , 12 байт

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

Попробуйте онлайн!

Python 3 , 92 87 байт

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 не является действительной базой), но ее можно игнорировать.

Конечно, можно взять длину первого repdigit ( 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 в последовательности сначала вычисляется количество цифр N, когда оно представлено в основании B, а затем проверяется, делится ли N на значение, представленное тем же количеством 1-цифр в основании 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.

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в 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"