Tugas Anda adalah mengambil angka positif sebagai input, n , dan menampilkan panjang representasi rep-digit terpanjang dari n pada basis apa pun. Misalnya 7 dapat direpresentasikan sebagai salah satu dari yang berikut ini

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

Digit rep adalah 111_2dan 11_6, 111_2lebih panjang sehingga jawaban kami adalah 3.

Ini adalah pertanyaan kode-golf sehingga jawaban akan dinilai dalam byte, dengan lebih sedikit byte yang lebih baik.

Uji Kasus

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

Implementasi sampel

Berikut ini adalah implementasi di Haskell yang dapat digunakan untuk menghasilkan lebih banyak kasus uji.

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]

Cobalah online!

Jelly , 9 byte

b‘Ḋ$EÐfZL

Tautan monadik yang menerima dan mengembalikan nomor

Cobalah online! atau lihat test suite (memasukkan satu hingga 32 inklusif).

Bagaimana?

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

... atau mungkin saya seharusnya melakukan:

bḊEÐfZLo1

Untuk 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 disimpan berkat Laikoni

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

Cobalah online!

Karena ini sedikit mereda, inilah pendekatan saya. Ini adalah versi kode kode yang dibuat untuk pertanyaan. Saya pikir pasti bisa lebih pendek. Saya hanya berpikir saya akan meletakkannya di sana.

Sekam , 13 11 byte

-2 byte terima kasih kepada zgarb

L←fȯ¬tuMBtN

Cobalah online!

Mathematica, 71 byte

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

Cobalah online!

05AB1E , 8 byte

L>вʒË}нg

Cobalah online!

-1 berkat kalsowerus .

Brachylog , 12 byte

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

Cobalah online!

Python 3 , 92 87 byte

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

Cobalah online!

Mathematica, 58 byte

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

Melempar kesalahan (karena basis-1 bukan basis yang valid), tetapi aman untuk diabaikan.

Tentu saja, tidak apa-apa untuk mengambil panjang dari repdigit pertama ( FirstCase), karena angka dalam basis yang lebih rendah tidak bisa lebih pendek dari pada basis yang lebih tinggi.

CJam (17 byte)

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

Test suite online . Ini adalah blok anonim (fungsi) yang mengambil integer di stack dan meninggalkan integer di stack.

Bekerja dengan brute force, digunakan 3sebagai basis cadangan untuk menangani kasus khusus (input 1atau 2).

Perl 6 , 49 byte

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

Cobalah online!

Penjelasan

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

Itu polymod metode adalah generalisasi dari Python divmod: Ia melakukan pembagian integer diulang menggunakan daftar yang diberikan pembagi, dan mengembalikan sisanya menengah.
Ini dapat digunakan untuk menguraikan kuantitas menjadi beberapa unit:

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

Ketika melewati urutan malas sebagai daftar pembagi, polymodberhenti ketika hasil bagi mencapai nol. Dengan demikian, memberikan pengulangan tak terbatas dari nomor yang sama, menguraikan input menjadi digit dari basis itu:

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

Saya menggunakan ini di sini karena memungkinkan basis tinggi sewenang-wenang, berbeda dengan .basemetode berbasis string yang hanya mendukung hingga basis 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

Prompt untuk N, mengembalikan output dalam Ans.

Penjelasan

Sebagai gambaran umum, untuk setiap basis B yang mungkin secara berurutan, pertama-tama ia menghitung jumlah digit N ketika direpresentasikan dalam basis B, kemudian memeriksa apakah N dapat dibagi dengan nilai yang diwakili oleh angka 1-digit yang sama dalam basis 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

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

Byte-count 111 juga merupakan digit ulang. ;)

Penjelasan:

Coba di sini.

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

Seekor lambda dari Integerke 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 yang tidak tersentuh

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

Memeriksa radio dalam urutan yang meningkat dari 2 hingga radix rep-digit ditemukan. Bergantung pada kenyataan bahwa radix terkecil tersebut akan sesuai dengan representasi dengan digit terbanyak.

madalah salinan input, badalah radix, dan ljumlah digit yang diperiksa (dan akhirnya panjang brepresentasi radix ).

Burlesque, 24 byte

(lihat solusi yang tepat di bawah)

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

Lihat beraksi .

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.

Setidaknya jika intuisi saya benar bahwa representasi rep-digit akan selalu terpanjang? Kalau tidak uhm ...

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

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