सबसे लंबा रेप डिजिट खोजें

17

आपका कार्य इनपुट के रूप में एक सकारात्मक संख्या लेना है, एन , और किसी भी आधार में एन के सबसे लंबे समय तक निरूपण प्रतिनिधित्व की लंबाई का उत्पादन करना है । उदाहरण के लिए 7 को निम्न में से किसी के रूप में दर्शाया जा सकता है

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

Rep-digits हैं 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

नमूना कार्यान्वयन

यहाँ हास्केल में एक कार्यान्वयन है जिसका उपयोग अधिक परीक्षण मामलों को उत्पन्न करने के लिए किया जा सकता है।

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]

इसे ऑनलाइन आज़माएं!

code-golf  base-conversion 
— पोस्ट रॉक गार्फ हंटर
स्रोत
1
मान लेना base > 1?
— H.PWiz
2
आप टेस्ट के मामले जोड़ सकते हैं 63-> 6 और 1023-> 10 अगर आपको पसंद है
— J42161217
1
@WheatWizard मुझे लगता है कि 26 यह उदाहरण के लिए करता है, यह 222बेस 3. में है
— xnor
1
क्या कुर्सियां ​​10 से ऊपर जा सकती हैं? यदि हां, तो आधारों के लिए> 10, क्या हमें अक्षर az शामिल करना चाहिए? अड्डों> 36 के बारे में क्या?
— रिक हिचकॉक
6
@RickHitchcock गैसें उच्च स्तर पर जा सकती हैं। चूंकि आपको 10 के अलावा किसी भी आधार में किसी भी संख्या को आउटपुट करने की आवश्यकता नहीं है, मुझे परवाह नहीं है कि आप अन्य ठिकानों का प्रतिनिधित्व कैसे करते हैं, लेकिन उन्हें 36 से बड़े ठिकानों के लिए काम करना चाहिए।
— पोस्ट रॉक गार्फ हंटर

जवाबों:

9

जेली , 9 बाइट्स

b‘Ḋ$EÐfZL

संख्याओं को स्वीकार करने और वापस करने का एक अद्वैतिक लिंक

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट देखें(एक से 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जेड।

— जोनाथन एलन
स्रोत
तो ... मुझे पता नहीं चला कि मैं अकेला हूँ ZL, इससे छोटा है L€Ṁ...
— 9
6

हास्केल , 86 81 79 बाइट्स

2 बाइट्स ने लिकोनी को धन्यवाद दिया

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

इसे ऑनलाइन आज़माएं!

चूंकि यह थोड़ा नीचे मर गया है, यहाँ मेरा दृष्टिकोण है। यह प्रश्न के लिए बनाए गए नमूना कोड का एक गोल्फ संस्करण है। मुझे लगता है कि यह निश्चित रूप से छोटा हो सकता है। मैंने अभी सोचा था कि मैं इसे वहाँ रख दूँगा।

— पोस्ट रॉक गार्फ हंटर
स्रोत
पॉइंटफ्री थोड़ा छोटा है length.head.filter(all=<<(==).head).(<$>[2..]).(!):।
— लकोनी
@ लायकोनी धन्यवाद! किसी कारण से मैं यह पता लगाने में सक्षम नहीं था कि इसे पॉइंट-फ्री नोटेशन में कैसे लाया जाए।
— पोस्ट रॉक गार्फ हंटर
मैं pointfree.io की सिफारिश कर सकता हूं जो लैम्बडाबॉट के पॉइंट फ्री कन्वर्टर पर आधारित है।
— लकोनी
@ लिकोनी मैं पॉइंटफ्री का उपयोग करता हूं। काफी थोड़ा। मैंने यहाँ कोशिश नहीं की होगी। मुझे आमतौर पर हालांकि बहुत अच्छे परिणाम मिलते हैं।
— पोस्ट रॉक गार्फ हंटर
5

भूसी , 13 11 बाइट्स

-2 बाइट्स ज़गरब की बदौलत

L←fȯ¬tuMBtN

इसे ऑनलाइन आज़माएं!

— H.PWiz
स्रोत
mmहो सकता है M, और ṠoΛ=←हो सकता है ȯ¬tu। अभी तक एक अंतर्निहित में जाँच के लिए नहीं है कि एक सूची के सभी तत्व समान हैं ...
— ज़र्गाब
M अभी तक विकी पर भी नहीं है :(
— H.PWiz
ΓoΛ=चार बाइट्स के रूप में भी काम करता है
— H.PWiz
1
ओह, Mडॉक्स में होना चाहिए, क्योंकि हमारे पास यह थोड़ी देर के लिए था। मुझे उसे ठीक करना चाहिए। लेकिन यह मूल रूप से दोहरी है Ṁ।
— जर्गब ऑग
3

05AB1E , 8 बाइट्स

L>вʒË}нg

इसे ऑनलाइन आज़माएं!

-1 कलसवरस को धन्यवाद ।

— आउटगोल्फ को एरिक करें
स्रोत
L>вʒË}нg8 बाइट्स के लिए
— कलसोवरस
@kalsowerus पता नहीं था कि आप इस तरह की सूची का उपयोग कर सकते हैं ... धन्यवाद!
— एरिक आउटलागफर
1

गणितज्ञ, 58 बाइट्स

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

एक त्रुटि फेंकता है (क्योंकि आधार -1 एक वैध आधार नहीं है), लेकिन इसे अनदेखा करना सुरक्षित है।

बेशक, पहले रेपिडिट ( FirstCase) की लंबाई लेना ठीक है , क्योंकि निचले आधारों में संख्या उच्च आधारों की तुलना में कम नहीं हो सकती है।

— जंगहवान मिन
स्रोत
1

CJam (17 बाइट्स)

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

ऑनलाइन टेस्ट सूट । यह एक अनाम ब्लॉक (फ़ंक्शन) है जो स्टैक पर पूर्णांक लेता है और स्टैक पर पूर्णांक छोड़ता है।

ब्रूट बल के साथ काम करता है, 3विशेष मामलों (इनपुट 1या 2) को संभालने के लिए फ़ॉलबैक बेस के रूप में उपयोग करता है ।

— पीटर टेलर
स्रोत
1

पर्ल 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: यह दोहराया पूर्णांक विभाजन करता है divisors की दी गई सूची का उपयोग कर, और मध्यवर्ती शेष देता है।
इसका उपयोग कई इकाइयों में एक मात्रा को विघटित करने के लिए किया जा सकता है:

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

विभाजक की सूची के रूप में एक आलसी क्रम से गुजरते polymodसमय , जब भागफल शून्य तक पहुंच जाता है , तो रुक जाता है। इस प्रकार, इसे उसी संख्या का अनंत दोहराव देते हुए, उस आधार के अंकों में इनपुट को विघटित करता है:

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

मैं यहां इसका उपयोग करता हूं क्योंकि यह मनमाने ढंग से उच्च आधारों की अनुमति देता है, स्ट्रिंग-आधारित .baseपद्धति के विपरीत जो केवल आधार 36 तक का समर्थन करता है।

— SMLS
स्रोत
आप निकाल सकते हैं []चारों ओर polymodबदलकर $_करने के लिए@_
— जो राजा
1

टीआई-बेसिक, 37 बाइट्स

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

एन के लिए संकेत, Ans में आउटपुट देता है।

व्याख्या

अवलोकन के रूप में, क्रम में प्रत्येक संभावित आधार B के लिए यह पहली बार N के अंकों की संख्या की गणना करता है जब आधार B में प्रतिनिधित्व किया जाता है, तो यह जांचता है कि क्या आधार B में समान संख्या में 1-अंकों के प्रतिनिधित्व वाले मान से विभाज्य है या नहीं।

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.
— calc84maniac
स्रोत
0

जावा 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;}

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
— केविन क्रूज़सेन
स्रोत
लैम्ब्डा को जावा 8.
— जैकब
1
@ जकोब वूप्स .. मुझे यकीन नहीं है कि मैंने 7 टाइप क्यों किया .. या तो इसलिए कि मैंने हाल ही में एक जावा 7 के जवाब में मेरी ओर देखा, या बस एक टाइपो .. सुधार के लिए धन्यवाद या तो, निश्चित रूप से 8 होना चाहिए ...> ।>
— केविन क्रूज़सेन
0

जावा 8, 79 बाइट्स

से एक लैम्ब्डा 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;}}

अघोषित लंबोदर

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

2 से बढते क्रम में मूलांक की जाँच करता है जब तक कि एक पुनः अंक मूलांक नहीं मिलता है। इस तथ्य पर निर्भर करता है कि इस तरह के सबसे छोटे मूलांक सबसे अंकों के साथ एक प्रतिनिधित्व के अनुरूप होंगे।

mइनपुट की एक प्रति bहै, मूलांक है, और lजांचे गए अंकों की संख्या है (और अंततः मूलांक- bप्रतिनिधित्व की लंबाई )।

— जेकब
स्रोत
0

बर्लेस्क, 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"
— mroman
स्रोत
1
बेस -2 प्रतिनिधित्व हमेशा सबसे लंबा होगा, उदाहरण के लिए इनपुट 26 के साथ प्रयास करें और आप देखेंगे कि आपका पहला समाधान गलत है
— लियो
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.