Il tuo compito è quello di prendere un numero positivo come input, n e produrre la lunghezza della rappresentazione della cifra ripetuta più lunga di n in qualsiasi base. Ad esempio 7 può essere rappresentato come uno dei seguenti

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

Le cifre di ripetizione sono 111_2e 11_6, 111_2è più lunga, quindi la nostra risposta è 3.

Questa è una domanda di code-golf, quindi le risposte verranno classificate in byte, con un numero minore di byte migliori.

Casi test

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

Implementazione di esempio

Ecco un'implementazione in Haskell che può essere utilizzata per generare più casi di test.

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]

Provalo online!

Gelatina , 9 byte

b‘Ḋ$EÐfZL

Un collegamento monadico che accetta e restituisce numeri

Provalo online! o vedere una suite di test (input da uno a 32 inclusi).

Come?

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 forse avrei dovuto fare:

bḊEÐfZLo1

Per la 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

2 byte salvati grazie a Laikoni

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

Provalo online!

Dal momento che questo è diminuito un po ', ecco il mio approccio. È una versione giocata a golf del codice di esempio che ho creato per la domanda. Penso che possa essere sicuramente più breve. Ho solo pensato di metterlo fuori.

Buccia , 13 11 byte

-2 byte grazie a zgarb

L←fȯ¬tuMBtN

Provalo online!

Mathematica, 71 byte

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

Provalo online!

05AB1E , 8 byte

L>вʒË}нg

Provalo online!

-1 grazie a kalsowerus .

Brachylog , 12 byte

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

Provalo online!

Python 3 , 92 87 byte

5 byte grazie 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)

Provalo online!

Mathematica, 58 byte

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

Genera un errore (perché base-1 non è una base valida), ma è sicuro da ignorare.

Naturalmente, va bene prendere la lunghezza del primo repdigit ( FirstCase), poiché i numeri nelle basi inferiori non possono essere più brevi rispetto alle basi più alte.

CJam (17 byte)

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

Suite di test online . Questo è un blocco (funzione) anonimo che accetta un numero intero nello stack e lascia un numero intero nello stack.

Funziona con forza bruta, utilizzando 3come base di fallback per gestire i casi speciali (input 1o 2).

Perl 6 , 49 byte

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

Provalo online!

Spiegazione

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

Il metodo polymod è una generalizzazione di Python divmod: esegue ripetute divisioni intere usando un dato elenco di divisori e restituisce i resti intermedi.
Può essere utilizzato per scomporre una quantità in più unità:

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

Quando si passa una sequenza pigra come elenco di divisori, si polymodinterrompe quando il quoziente raggiunge lo zero. Quindi, dandogli una ripetizione infinita dello stesso numero, decompone l'input in cifre di quella base:

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

Lo uso qui perché consente basi arbitrariamente alte, in contrasto con il .basemetodo basato su stringhe che supporta solo fino alla base 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

Richiede N, restituisce output in Ans.

Spiegazione

Come panoramica, per ogni possibile base B in sequenza, prima calcola il numero di cifre di N quando rappresentato nella base B, quindi controlla se N è divisibile per il valore rappresentato da quello stesso numero di 1 cifre nella 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 byte

lhf!t{TjLQ}2h

Provalo online!

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

Anche il conteggio dei byte di 111 è una cifra ripetitiva. ;)

Spiegazione:

Provalo qui.

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

Un lambda da 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 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;
    }
}

Controlla i radici in ordine crescente da 2 fino a quando non viene trovata una radix ripetuta. Si basa sul fatto che il più piccolo di tali radix corrisponderà a una rappresentazione con il maggior numero di cifre.

mè una copia dell'input, bè la radice ed lè il numero di cifre controllate (e in definitiva la lunghezza della brappresentazione della radice ).

Burlesque, 24 byte

(vedi la soluzione corretta di seguito)

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

Vedi in azione .

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.

Almeno se il mio intuito ha ragione sul fatto che una rappresentazione a cifra ripetuta sarà sempre la più lunga? Altrimenti uhm ...

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

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