Su tarea es tomar un número positivo como entrada, n , y generar la longitud de la representación más larga de rep-dígitos de n en cualquier base. Por ejemplo, 7 puede representarse como cualquiera de los siguientes

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

Los dígitos de rep son 111_2y 11_6, 111_2es más largo, por lo que nuestra respuesta es 3.

Esta es una pregunta de código de golf , por lo que las respuestas se puntuarán en bytes, con menos bytes mejor.

Casos de prueba

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

Implementación de muestra

Aquí hay una implementación en Haskell que puede usarse para generar más casos de prueba.

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]

Pruébalo en línea!

Jalea , 9 bytes

b‘Ḋ$EÐfZL

Un enlace monádico que acepta y devuelve números

Pruébalo en línea! o ver un conjunto de pruebas (entradas 1 a 32 inclusive).

¿Cómo?

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

... o tal vez debería haber hecho:

bḊEÐfZLo1

Por la 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 guardados gracias a Laikoni

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

Pruébalo en línea!

Como esto se ha calmado un poco, aquí está mi enfoque. Es una versión de golf del código de muestra que hice para la pregunta. Creo que definitivamente puede ser más corto. Solo pensé en ponerlo ahí afuera.

Casco , 13 11 bytes

-2 bytes gracias a zgarb

L←fȯ¬tuMBtN

Pruébalo en línea!

Mathematica, 71 bytes

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

Pruébalo en línea!

05AB1E , 8 bytes

L>вʒË}нg

Pruébalo en línea!

-1 gracias a kalsowerus .

Brachylog , 12 bytes

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

Pruébalo en línea!

Python 3 , 92 87 bytes

5 bytes gracias 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)

Pruébalo en línea!

Mathematica, 58 bytes

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

Lanza un error (porque base-1 no es una base válida), pero es seguro ignorarlo.

Por supuesto, está bien tomar la longitud del primer repdigit ( FirstCase), ya que los números en bases más bajas no pueden ser más cortos que en bases más altas.

CJam (17 bytes)

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

Conjunto de pruebas en línea . Este es un bloque anónimo (función) que toma un número entero en la pila y deja un número entero en la pila.

Funciona con fuerza bruta, utilizando 3como base de respaldo para manejar los casos especiales (entrada 1o 2).

Perl 6 , 49 bytes

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

Pruébalo en línea!

Explicación

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

El método polymod es una generalización de Python divmod: realiza una división entera repetida utilizando una lista dada de divisores y devuelve los restos intermedios.
Se puede usar para descomponer una cantidad en varias unidades:

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

Al pasar una secuencia perezosa como la lista de divisores, se polymoddetiene cuando el cociente llega a cero. Por lo tanto, al darle una repetición infinita del mismo número, descompone la entrada en dígitos de esa base:

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

Lo uso aquí porque permite bases arbitrariamente altas, en contraste con el .basemétodo basado en cadenas que solo admite hasta la 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, devuelve la salida en Ans.

Explicación

Como resumen, para cada posible base B en secuencia, primero calcula el número de dígitos de N cuando se representa en la base B, luego verifica si N es divisible por el valor representado por ese mismo número de 1 dígitos en la 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.

Pyth , 13 bytes

lhf!t{TjLQ}2h

Pruébalo en línea!

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

El número de bytes de 111 también es un dígito de repetición. ;)

Explicación:

Pruébalo aquí

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

Una lambda de Integera 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 sin golf

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

Comprueba las radios en orden creciente desde 2 hasta que se encuentra una raíz de dígitos rep. Se basa en el hecho de que la raíz más pequeña corresponderá a una representación con la mayor cantidad de dígitos.

mes una copia de la entrada, bes la raíz y les el número de dígitos marcados (y, en última instancia, la longitud de la brepresentación de la raíz ).

Burlesque, 24 bytes

(ver la solución correcta a continuación)

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

Ver en acción .

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.

Al menos si mi intuición es correcta, ¿una representación de dígitos de repetición siempre será más larga? De lo contrario, uhm ...

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

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