Sua tarefa é pegar um número positivo como entrada, n , e gerar o comprimento da representação mais longa de dígitos em n em qualquer base. Por exemplo, 7 pode ser representado como qualquer um dos seguintes

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

Como os dígitos repetidos são 111_2e 11_6, 111_2é maior, nossa resposta é 3.

Esta é uma questão de código-golfe, para que as respostas sejam pontuadas em bytes, com menos bytes sendo melhores.

Casos de teste

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

Implementação de amostra

Aqui está uma implementação no Haskell que pode ser usada para gerar mais casos de teste.

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]

Experimente online!

Geléia , 9 bytes

b‘Ḋ$EÐfZL

Um link monádico que aceita e retorna números

Experimente online! ou consulte uma suíte de testes (entradas de 1 a 32 inclusive).

Quão?

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

... ou talvez eu devesse ter feito:

bḊEÐfZLo1

Para o Lo1z.

JavaScript (ES6), 62 bytes

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 bytes

2 bytes salvos graças a Laikoni

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

Experimente online!

Como isso diminuiu um pouco, aqui está minha abordagem. É uma versão em golf do código de amostra que fiz para a pergunta. Eu acho que definitivamente pode ser mais curto. Eu apenas pensei em colocá-lo lá fora.

Casca , 13 11 bytes

-2 bytes graças ao zgarb

L←fȯ¬tuMBtN

Experimente online!

Mathematica, 71 bytes

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

Experimente online!

05AB1E , 8 bytes

L>вʒË}нg

Experimente online!

-1 graças a kalsowerus .

Braquilog , 12 bytes

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

Experimente online!

Python 3 , 92 87 bytes

5 bytes graças a 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)

Experimente online!

Mathematica, 58 bytes

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

Lança um erro (porque a base-1 não é uma base válida), mas é seguro ignorar.

Obviamente, não há problema em assumir o comprimento do primeiro repdigit ( FirstCase), pois os números nas bases inferiores não podem ser mais curtos do que nas bases superiores.

CJam (17 bytes)

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

Conjunto de testes online . Este é um bloco anônimo (função) que pega um número inteiro na pilha e deixa um número inteiro na pilha.

Funciona com força bruta, usando 3como base de fallback para lidar com casos especiais (entrada 1ou 2).

Perl 6 , 49 bytes

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

Experimente online!

Explicação

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

O método polymod é uma generalização do Python divmod: ele executa divisão inteira repetida usando uma determinada lista de divisores e retorna os restantes intermediários.
Pode ser usado para decompor uma quantidade em várias unidades:

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

Ao passar uma sequência lenta como a lista de divisores, polymodpára quando o quociente chega a zero. Assim, dando-lhe uma repetição infinita do mesmo número, decompõe a entrada em dígitos dessa base:

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

Eu uso isso aqui porque permite bases arbitrariamente altas, em contraste com o .basemétodo baseado em string, que suporta apenas a base 36.

TI-BASIC, 37 bytes

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

Solicita N, retorna a saída em Ans.

Explicação

Como uma visão geral, para cada possível base B em seqüência, ele primeiro calcula o número de dígitos de N quando representado na base B, depois verifica se N é divisível pelo valor representado pelo mesmo número de 1 dígito na base 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.

Pitão , 13 bytes

lhf!t{TjLQ}2h

Experimente online!

Java 8, 111 bytes

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

A contagem de bytes de 111 também é um dígito repetitivo. ;)

Explicação:

Experimente aqui.

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 bytes

Um lambda de Integerpara 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 ungolfed

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

Verifica as radições em ordem crescente de 2 até que uma raiz de dígitos repetidos seja encontrada. Baseia-se no fato de que a menor raiz desse tipo corresponderá a uma representação com mais dígitos.

mé uma cópia da entrada, bé a raiz e lé o número de dígitos verificados (e, finalmente, o comprimento da brepresentação da raiz ).

Burlesco, 24 bytes

(veja a solução correta abaixo)

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

Veja em ação .

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.

Pelo menos se minha intuição estiver certa de que uma representação de dígito repetitivo sempre será mais longa? Caso contrário, uhm ...

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

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