Ihre Aufgabe ist es, eine positive Zahl als Eingabe n zu nehmen und die Länge der längsten Wiederholungsstellendarstellung von n in einer beliebigen Basis auszugeben . Zum Beispiel kann 7 wie folgt dargestellt werden

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

Die Wiederholungsziffern sind 111_2und 11_6, 111_2ist länger, also ist unsere Antwort 3.

Dies ist eine Code-Golf- Frage, daher werden die Antworten in Bytes bewertet, wobei weniger Bytes besser sind.

Testfälle

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

Beispielimplementierung

Hier ist eine Implementierung in Haskell, mit der weitere Testfälle generiert werden können.

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]

Probieren Sie es online!

Gelee , 9 Bytes

b‘Ḋ$EÐfZL

Ein monadischer Link, der Nummern akzeptiert und zurückgibt

Probieren Sie es online! oder sehen Sie sich eine Testsuite an (Eingaben eins bis einschließlich 32).

Wie?

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

... oder vielleicht hätte ich das tun sollen:

bḊEÐfZLo1

Für die 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 Bytes

2 Bytes gespart dank Laikoni

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

Probieren Sie es online!

Da dies ein wenig nachgelassen hat, ist hier mein Ansatz. Es ist eine Golfversion des Beispielcodes, den ich für die Frage erstellt habe. Ich denke, es kann definitiv kürzer sein. Ich dachte nur, ich würde es da rausbringen.

Schale , 13 11 Bytes

-2 Bytes dank Zgarb

L←fȯ¬tuMBtN

Probieren Sie es online!

Mathematica, 71 Bytes

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

Probieren Sie es online!

05AB1E , 8 Bytes

L>вʒË}нg

Probieren Sie es online!

-1 dank kalsowerus .

Brachylog , 12 Bytes

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

Probieren Sie es online!

Python 3 , 92 87 Bytes

5 Bytes dank 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)

Probieren Sie es online!

Mathematica, 58 Bytes

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

Löst einen Fehler aus (da base-1 keine gültige Basis ist), der aber ignoriert werden kann.

Natürlich ist es in Ordnung, die Länge des ersten repdigit ( FirstCase) zu nehmen, da Zahlen in niedrigeren Basen nicht kürzer sein können als in höheren Basen.

CJam (17 Bytes)

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

Online-Testsuite . Dies ist ein anonymer Block (Funktion), der eine Ganzzahl auf dem Stapel annimmt und eine Ganzzahl auf dem Stapel belässt.

Arbeitet mit brachialer Gewalt und dient 3als Ausweichbasis für Sonderfälle (Eingabe 1oder 2).

Perl 6 , 49 Bytes

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

Probieren Sie es online!

Erläuterung

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

Die Polymod- Methode ist eine Verallgemeinerung von Python divmod: Sie führt eine wiederholte Ganzzahldivision unter Verwendung einer gegebenen Liste von Divisoren durch und gibt die Zwischenreste zurück.
Es kann verwendet werden, um eine Menge in mehrere Einheiten zu zerlegen:

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

Stoppt, polymodwenn der Quotient Null erreicht , wenn eine träge Sequenz als Liste der Teiler übergeben wird . Indem Sie ihm eine unendliche Wiederholung der gleichen Zahl geben, zerlegen Sie die Eingabe in Ziffern dieser Basis:

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

Ich benutze dies hier, weil es im Gegensatz zur stringbasierten .baseMethode, die nur bis zur Basis 36 unterstützt, beliebig hohe Basen erlaubt .

TI-BASIC, 37 Bytes

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

Fordert zur Eingabe von N auf und gibt die Ausgabe in Ans zurück.

Erläuterung

Zur Übersicht berechnet es für jede mögliche Basis B nacheinander zuerst die Anzahl der Stellen von N, wenn diese in der Basis B dargestellt sind, und prüft dann, ob N durch den Wert teilbar ist, der durch die gleiche Anzahl von 1 Stellen in der Basis B dargestellt wird.

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

Probieren Sie es 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;}

Die Byteanzahl von 111 ist ebenfalls eine Wiederholungsziffer. ;)

Erläuterung:

Probieren Sie es hier aus.

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

Ein Lambda von Integerbis 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;}}

Ungolfed Lambda

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

Überprüft die Radices in aufsteigender Reihenfolge von 2 bis zur Ermittlung eines stelligen Radix. Beruht auf der Tatsache, dass der kleinste solcher Radix einer Darstellung mit den meisten Ziffern entspricht.

mist eine Kopie der Eingabe, bist die Basis und list die Anzahl der überprüften Ziffern (und letztendlich die Länge der Basisdarstellung b).

Burlesque, 24 Bytes

(siehe richtige Lösung unten)

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

In Aktion sehen .

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.

Zumindest, wenn meine Intuition stimmt, dass eine Repräsentation mit Wiederholungsziffern immer die längste ist? Sonst ähm ...

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

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