งานของคุณคือการใช้จำนวนบวกเป็นอินพุท, nและเอาท์พุทความยาวของการเป็นตัวแทนหลักที่ยาวที่สุดของnในฐานใด ๆ ตัวอย่างเช่น 7 สามารถแสดงดังต่อไปนี้

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

ตัวแทนตัวเลข-มี111_2และ11_6, 111_2มีความยาวดังนั้นคำตอบของเราคือ 3

นี่เป็นคำถามเกี่ยวกับการเขียนโค้ดดังนั้นคำตอบจะได้คะแนนเป็นไบต์โดยมีจำนวนไบต์น้อยกว่าดีกว่า

กรณีทดสอบ

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

การใช้งานตัวอย่าง

นี่คือการดำเนินการใน Haskell ที่สามารถใช้เพื่อสร้างกรณีทดสอบเพิ่มเติม

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]

ลองออนไลน์!

เยลลี่ขนาด 9 ไบต์

b‘Ḋ$EÐfZL

ลิงค์ monadic ยอมรับและส่งคืนหมายเลข

ลองออนไลน์! หรือดูชุดทดสอบ (อินพุตหนึ่งถึง 32 รวม)

อย่างไร?

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

... หรือบางทีฉันควรจะทำ:

bḊEÐfZLo1

สำหรับLo1ซี

JavaScript (ES6), 62 ไบต์

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 ไบต์

บันทึก 2 ไบต์ขอบคุณ Laikoni

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

ลองออนไลน์!

เนื่องจากสิ่งนี้เสียชีวิตลงเล็กน้อยนี่คือแนวทางของฉัน มันเป็นโค้ดตัวอย่างที่ฉันทำขึ้นเพื่อตีกอล์ฟ ฉันคิดว่ามันจะสั้นลงอย่างแน่นอน ฉันแค่คิดว่าฉันใส่มันออกไปที่นั่น

Husk , 13 11 ไบต์

-2 ไบต์ขอบคุณ zgarb

L←fȯ¬tuMBtN

ลองออนไลน์!

Mathematica, 71 ไบต์

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

ลองออนไลน์!

05AB1E , 8 ไบต์

L>вʒË}нg

ลองออนไลน์!

-1 ขอบคุณที่kalsowerus

Brachylogขนาด 12 ไบต์

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

ลองออนไลน์!

Python 3 , 92 87 ไบต์

5 ไบต์ขอบคุณ 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)

ลองออนไลน์!

Mathematica, 58 ไบต์

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

โยนข้อผิดพลาด (เพราะ base-1 ไม่ใช่ฐานที่ถูกต้อง) แต่ก็ปลอดภัยที่จะเพิกเฉย

แน่นอนว่าการใช้ความยาวของ repdigit ( FirstCase) ครั้งแรกนั้นเป็นสิ่งที่ดีเนื่องจากตัวเลขในฐานที่ต่ำกว่าต้องไม่สั้นกว่าในฐานที่สูงกว่า

CJam (17 ไบต์)

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

ชุดทดสอบออนไลน์ชุดทดสอบออนไลน์นี่คือบล็อกที่ไม่ระบุชื่อ (ฟังก์ชัน) ซึ่งใช้จำนวนเต็มบนสแต็กและปล่อยให้เป็นจำนวนเต็มบนสแต็ก

ทำงานร่วมกับกำลังดุร้ายโดยใช้3เป็นฐานสำรองเพื่อจัดการเคสพิเศษ (อินพุต1หรือ2)

Perl 6 , 49 ไบต์

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

ลองออนไลน์!

คำอธิบาย

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

polymodวิธีเป็นลักษณะทั่วไปของ ธdivmod: มันดำเนินการซ้ำจำนวนเต็มส่วนใช้รายการที่กำหนดของตัวหารและส่งกลับเหลือกลาง
สามารถใช้ในการย่อยปริมาณออกเป็นหลาย ๆ หน่วย:

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

เมื่อผ่านลำดับที่ขี้เกียจเป็นรายการของตัวหารpolymodหยุดเมื่อความฉลาดทางถึงศูนย์ ดังนั้นให้มันซ้ำไม่มีที่สิ้นสุดของจำนวนเดียวกันสลายตัวอินพุตเป็นตัวเลขของฐานที่:

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

ฉันใช้สิ่งนี้ที่นี่เพราะมันช่วยให้ฐานสูงตามอำเภอใจตรงกันข้ามกับ.baseวิธีการอิงสตริงซึ่งรองรับได้สูงสุด 36 ฐานเท่านั้น

TI-BASIC, 37 ไบต์

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

แสดงพร้อมต์สำหรับ N ส่งคืนเอาต์พุตใน Ans

คำอธิบาย

สำหรับภาพรวมสำหรับแต่ละฐาน B ที่เป็นไปได้ลำดับแรกจะคำนวณจำนวนหลักของ N เมื่อแสดงในฐาน B จากนั้นตรวจสอบว่า N หารด้วยค่าที่แสดงด้วยตัวเลข 1 หลักเดียวกันในฐาน 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 ไบต์

lhf!t{TjLQ}2h

ลองออนไลน์!

Java 8, 111 ไบต์

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 ยังเป็นตัวเลขตัวแทน ;)

คำอธิบาย:

ลองที่นี่

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 ไบต์

แลมบ์ดาจากไปIntegerInteger

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

แลมบ์ดา

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

ตรวจสอบ radices ตามลำดับที่เพิ่มขึ้นจาก 2 จนกว่าจะพบ radix หลัก ขึ้นอยู่กับความจริงที่ว่า Radix ที่เล็กที่สุดนั้นจะสอดคล้องกับการแทนด้วยตัวเลขส่วนใหญ่

m เป็นสำเนาของอินพุต bคือ radix และlเป็นจำนวนหลักที่ตรวจสอบ (และท้ายที่สุดคือความยาวของการbแทนค่าradix- )

ล้อเลียน 24 ไบต์

(ดูวิธีแก้ไขที่ถูกต้องด้านล่าง)

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

ดูการทำงานการดำเนินการ

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.

อย่างน้อยถ้าสัญชาตญาณของฉันถูกต้องที่ตัวแทนตัวเลขจะยาวที่สุดเสมอ? ไม่งั้น ...

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

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