Votre tâche consiste à prendre un nombre positif en entrée, n , et à sortir la longueur de la représentation de chiffres de rep la plus longue de n dans n'importe quelle base. Par exemple, 7 peut être représenté par l'un des éléments suivants

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

Les rep-chiffres sont 111_2et 11_6, 111_2est plus long, donc notre réponse est 3.

Il s'agit d'une question de code-golf, donc les réponses seront notées en octets, avec moins d'octets étant mieux.

Cas de 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

Exemple d'implémentation

Voici une implémentation dans Haskell qui peut être utilisée pour générer plus de cas de 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]

Essayez-le en ligne!

Gelée , 9 octets

b‘Ḋ$EÐfZL

Un lien monadique acceptant et renvoyant des numéros

Essayez-le en ligne!ou consultez une suite de tests (entrées 1 à 32 inclus).

Comment?

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 j'aurais peut-être dû faire:

bḊEÐfZLo1

Pour le Lo1z.

JavaScript (ES6), 62 octets

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 octets

2 octets économisés grâce à Laikoni

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

Essayez-le en ligne!

Puisque cela s'est un peu atténué, voici mon approche. C'est une version golfée de l'exemple de code que j'ai créé pour la question. Je pense que cela peut certainement être plus court. Je pensais juste que je le mettrais là-bas.

Husk , 13 11 octets

-2 octets grâce à zgarb

L←fȯ¬tuMBtN

Essayez-le en ligne!

Mathematica, 71 octets

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

Essayez-le en ligne!

05AB1E , 8 octets

L>вʒË}нg

Essayez-le en ligne!

-1 grâce à kalsowerus .

Brachylog , 12 octets

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

Essayez-le en ligne!

Python 3 , 92 87 octets

5 octets grâce à 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)

Essayez-le en ligne!

Mathematica, 58 octets

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

Lance une erreur (car la base-1 n'est pas une base valide), mais il est sûr de l'ignorer.

Bien sûr, il est correct de prendre la longueur du premier repdigit ( FirstCase), car les nombres dans les bases inférieures ne peuvent pas être plus courts que dans les bases supérieures.

CJam (17 octets)

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

Suite de tests en ligne . Il s'agit d'un bloc (fonction) anonyme qui prend un entier sur la pile et laisse un entier sur la pile.

Fonctionne avec la force brute, en utilisant 3comme base de secours pour gérer les cas spéciaux (entrée 1ou 2).

Perl 6 , 49 octets

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

Essayez-le en ligne!

Explication

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

La méthode polymod est une généralisation de Python divmod: elle effectue des divisions entières répétées en utilisant une liste donnée de diviseurs, et renvoie les restes intermédiaires.
Il peut être utilisé pour décomposer une quantité en plusieurs unités:

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

Lors du passage d'une séquence paresseuse en tant que liste de diviseurs, polymods'arrête lorsque le quotient atteint zéro. Ainsi, en lui donnant une répétition infinie du même nombre, décompose l'entrée en chiffres de cette base:

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

Je l'utilise ici car il autorise des bases arbitrairement élevées, contrairement à la .baseméthode basée sur les chaînes qui ne prend en charge que la base 36.

TI-BASIC, 37 octets

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

Demande N, renvoie la sortie dans Ans.

Explication

À titre de vue d'ensemble, pour chaque base B possible en séquence, il calcule d'abord le nombre de chiffres de N lorsqu'il est représenté dans la base B, puis vérifie si N est divisible par la valeur représentée par ce même nombre de 1 chiffres dans 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 octets

lhf!t{TjLQ}2h

Essayez-le en ligne!

Java 8, 111 octets

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

Le nombre d'octets de 111 est également un chiffre de répétition. ;)

Explication:

Essayez-le ici.

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 octets

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

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

Vérifie les radices dans l'ordre croissant de 2 jusqu'à ce qu'une base de chiffres de rep soit trouvée. S'appuie sur le fait que le plus petit de ces radix correspondra à une représentation avec le plus de chiffres.

mest une copie de l'entrée, best le radix, et lest le nombre de chiffres vérifiés (et finalement la longueur de la radix- breprésentation).

Burlesque, 24 octets

(voir la bonne solution ci-dessous)

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

Voir en action .

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.

Au moins, si mon intuition est juste qu'une représentation à deux chiffres sera toujours la plus longue? Sinon euh ...

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

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