Göreviniz giriş, n olarak pozitif bir sayı almak ve herhangi bir tabandaki n'nin en uzun yeniden basamaklı gösteriminin uzunluğunu çıktılamaktır . Örneğin 7 aşağıdakilerden herhangi biri olarak temsil edilebilir

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

Rep-basamak vardır 111_2ve 11_6, 111_2cevabımız 3 yani uzundur.

Bu bir kod golf sorusudur, bu nedenle cevaplar bayt cinsinden puanlandırılacak, daha az bayt daha iyi olacaktır.

Test Durumları

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

Örnek uygulama

İşte Haskell'de daha fazla test örneği oluşturmak için kullanılabilecek bir uygulama.

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]

Çevrimiçi deneyin!

Jöle , 9 bayt

b‘Ḋ$EÐfZL

Sayıları kabul eden ve döndüren monadik bir bağlantı

Çevrimiçi deneyin! veya bir test takımına bakın(girişler bir ila 32 dahil).

Nasıl?

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

... ya da belki de yapmalıydım:

bḊEÐfZLo1

İçin Lo1z.

JavaScript (ES6), 62 bayt

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 bayt

Laikoni sayesinde 2 bayt kurtardı

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

Çevrimiçi deneyin!

Bu biraz öldüğünden, benim yaklaşımım. Soru için yaptığım örnek kodun golf edilmiş bir versiyonudur. Bence kesinlikle daha kısa olabilir. Sadece oraya koyacağımı düşündüm.

Kabuk , 13 11 bayt

Zgarb sayesinde -2 bayt

L←fȯ¬tuMBtN

Çevrimiçi deneyin!

Mathematica, 71 bayt

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

Çevrimiçi deneyin!

05AB1E, 8 bytes

L>вʒË}нg

Try it online!

-1 thanks to kalsowerus.

Brachylog, 12 bytes

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

Try it online!

Python 3, 92 87 bytes

5 bytes thanks to 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)

Try it online!

Mathematica, 58 bytes

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

Throws an error (because base-1 is not a valid base), but it is safe to ignore.

Of course, it is okay to take the length of the first repdigit (FirstCase), since numbers in lower bases cannot be shorter than in higher bases.

CJam (17 bytes)

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

Online test suite. This is an anonymous block (function) which takes an integer on the stack and leaves an integer on the stack.

Works with brute force, using 3 as a fallback base to handle the special cases (input 1 or 2).

Perl 6, 49 bytes

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

Try it online!

Explanation

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

The polymod method is a generalization of Python's divmod: It performs repeated integer division using a given list of divisors, and returns the intermediate remainders.
It can be used to decompose a quantity into multiple units:

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

When passing a lazy sequence as the list of divisors, polymod stops when the quotient reaches zero. Thus, giving it an infinite repetition of the same number, decomposes the input into digits of that base:

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

I use this here because it allows arbitrarily high bases, in contrast to the string-based .base method which only supports up to 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

Prompts for N, returns output in Ans.

Explanation

Genel bir bakış olarak, sırayla her olası B tabanı için, önce B tabanında temsil edildiğinde N'nin basamak sayısını hesaplar, sonra N'nin B tabanında aynı sayıda 1 basamakla temsil edilen değerle bölünüp bölünmediğini kontrol eder.

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 bayt

lhf!t{TjLQ}2h

Çevrimiçi deneyin!

Java 8, 111 bayt

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

111 bayt sayısı da bir rakamdır. ;)

Açıklama:

Burada deneyin.

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 bayt

A lambda Integeriçin 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;
    }
}

Radyanları, 2 basamaklı bir sayı tabanı bulunana kadar artan sırada kontrol eder. Böyle en küçük yarıçapın en fazla basamağa sahip bir temsile karşılık geleceğine güvenir.

m is a copy of the input, b is the radix, and l is the number of digits checked (and ultimately the length of the radix-b representation).

Burlesque, 24 bytes

(see correct solution below)

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

See in 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.

At least if my intuition is right that a rep-digit representation will always be longest? Otherwise uhm...

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

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