एक पुनरावृत्ति एक प्राकृतिक संख्या है जिसे केवल उसी अंक को दोहराकर लिखा जा सकता है। उदाहरण के लिए, 777एक पुनरीक्षण है, क्योंकि यह पूरी तरह से 7तीन बार दोहराए गए अंकों से बना है ।

यह केवल दशमलव (आधार 10) संख्या तक सीमित नहीं है, हालांकि:

बाइनरी (बेस 2) में लिखे जाने पर हर मेर्सेन नंबर (फॉर्म एम _एन = 2 ^एन -1 का ) एक रिपिट होता है।
हर संख्या तुच्छ रूप से एक प्रतिगामी होती है जब एकात्मक (आधार 1) में लिखा जाता है।
हर संख्या nको 11आधार में रेपिडिट के रूप में भी लिखा जा सकता है n-1(उदाहरण के लिए, 17जब हेक्साडेसिमल (बेस 16) में लिखा जाता है 11, और 3जब बाइनरी में लिखा जाता है (बेस 2) भी 11)।

यहां चुनौती अन्य ठिकानों को खोजने की है जहां इनपुट संख्या एक पुनरीक्षण हो सकती है।

इनपुट

एक सकारात्मक पूर्णांक x > 3, किसी भी सुविधाजनक प्रारूप में।

उत्पादन

एक सकारात्मक पूर्णांक bके साथ (x-1) > b > 1जहां का प्रतिनिधित्व xआधार में bएक repdigit है।

यदि ऐसा नहीं bहै, तो आउटपुट 0या कुछ गलत मूल्य हैं।
यदि ऐसे कई bमौजूद हैं, तो आप किसी भी या सभी को आउटपुट कर सकते हैं।

नियम

(x-1) > b > 1प्रतिबंध एकल के लिए तुच्छ रूपांतरण या "घटाना एक" आधार को रोकने के लिए है। उत्पादन संख्या एकल या किसी सुविधाजनक आधार में लिखा जा सकता है, लेकिन आधार ही तुच्छ रूपांतरण में से एक नहीं होना चाहिए।
इनपुट / आउटपुट किसी भी उपयुक्त विधि से हो सकता है ।
मानक ढील प्रतिबंध लागू होते हैं।

उदाहरण

In --> Out
11 --> 0            (or other falsey value)
23 --> 0            (or other falsey value)
55 --> 10           (since 55 is 55 in base 10)
90 --> 14           (since 90 is 66 in base 14 ... 17, 29, 44 also allowed)
91 --> 9            (since 91 is 111 in base 9 ... 12 also allowed)

code-golf base-conversion

— AdmBorkBork
स्रोत

क्या हम मान सकते हैं b ≤ 36(कई भाषाओं में अंतर्निहित आधार रूपांतरण कार्य अधिक नहीं होते हैं)?

— दरवाज़े

2

@Doorknob b ≤ 36 गंभीर रूप से इस समस्या के दायरे को सीमित करता है, और सभी मौजूदा उत्तर सही ढंग से बड़े ठिकानों को संभालते हैं, इसलिए मैं यह कहने जा रहा हूं कि, आप bजो दिया गया है, उसके ऊपर एक ऊपरी बाध्यता नहीं मान सकते ।

— AdmBorkBork

अधिकांश संख्याएँ कुछ आधार में प्रतिगामी हैं। उदाहरण के लिए, 91 = 13 * 7 तो यह बेस 12 में 77 है

— नील

@ नील ... यह लगभग ऐसा है जैसे आप किसी चीज़ पर हैं, ...

— AdmBorkBork

11

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

bRI¬P€TḊṖ

आधारों की एक सूची लौटाता है, जो खाली (मिथ्या) है यदि कोई नहीं है। इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

bRI¬P€TḊṖ  Main link. Argument: x (number)

 R         Range; yield [1, ..., x].
b          Base; convert x to base n, for each n in the range.
  I        Compute the increment (differences of successive values) of each array
           of base-n digits. This yields only 0's for a repdigit.
   ¬       Apply logical NOT to each increment.
    P€     Compute the product of all lists of increments.
      T    Get the indices of all truthy products.
       Ḋ   Discard the first index (1).
        Ṗ  Discard the last index (x - 1).

— डेनिस
स्रोत

9

Pyth, 1 1 10

fqjQT)r2tQ

qलगभग 10 दिनों पहले की सूची में सभी अद्वितीय मूल्यों वाले एक सूची के लिए स्पष्ट रूप से पायथ की एकात्मक जाँच। स्पष्ट रूप से पायथ कीड़े की जांच से गोल्फ स्कोर में सुधार होता है।

इस आधार [2..input-1)पर इनपुट के अंकों का अनूठा सेट लंबाई 1 है तो सूची को फ़िल्टर करता है।

परीक्षण सूट

स्पष्टीकरण:

r2tQ     ##  generate the python range from 2 to the input (Q) - 1
         ##  python range meaning inclusive lower and exclusive upper bounds
f        ##  filter that list with lambda T:
  jQT    ##  convert the input to base T
 q    )  ##  true if the resulting list digits has all equal elements

— FryAmTheEggman
स्रोत

5

रूबी, 87 69 63 बाइट्स

->x{(2..x-2).find{|b|y=x;a=y%b;a=0if a!=y%b while(y/=b)>0;a>0}}

मुझे हाथ से बेस कन्वर्शन लागू करना था, क्योंकि रूबी के बिल्डिंस केवल बेस 36 तक ही जाते थे ...

nilनहीं मिलने पर लौटा ।

->x{      # anonymous lambda that takes one argument
(2..x-2)  # range of the possible bases to search over
.find{    # return the first element that satisfies the block, or nil if none
|b|       # b represents the base currently being tested
y=x;      # a temporary value to avoid mutating the original value of x
a=y%b;    # the first (well, last) digit in base b, which will be compared to

                   y/=b      # divide the number by the base
   if a!=y%b                 # if this digit does not match (is different)...
a=0                          # set a to a value representing "failure"
             while(    )>0;  # keep doing this until we get zero (no digits left)

a>0       # return whether a has maintained its original value (no digit change)
}}        # find then returns the first element for which this is true (or nil)

— Doorknob
स्रोत

5

पायथन, 71 72 78 बाइट्स

lambda x:{b for b in range(2,x-1)for d in range(x)if x*~-b==x%b*~-b**d}

कोई पुनरावृत्ति नहीं, बस सभी ठिकानों की कोशिश करता है और उन लोगों के एक सेट को आउटपुट करता है जो काम करते हैं।

यह सांकेतिक शब्दों में बदलना bऔर dएक ही संख्या में है, लेकिन इसे निकालने के लिए बहुत अधिक कोष्ठक अभिव्यक्ति होती है। 77 बाइट्स:

lambda x:{k/x for k in range(2*x,x*x-x))if x*~-(k/x)==x%(k/x)*~-(k/x)**(k%x)}

72 बाइट्स:

f=lambda x,b=2:b*any(x*~-b==x%b*~-b**d for d in range(x))or f(x,b+1)%~-x

पहले bकाम करता है कि उत्पादन, या 0अगर कोई भी नहीं करता है।

आधार में अंकों की प्रतिनिधि इकाई xका मूल्य है । तुल्य, ।dcbx==c*(b**d-1)/(b-1)x*(b-1)==c*(b**d-1)

मान cहोना चाहिए x%b, अंतिम अंक। मुझे dअंकगणितीय रूप से निर्धारित करने का कोई तरीका नहीं दिखाई देता है , इसलिए कोड सभी संभावनाओं को देखने की कोशिश करता है कि उनमें से कोई काम करता है या नहीं।

जब उत्पादन मोडुलो ले कर पहुंचता है तो डेनिस की फाल्सी आउटपुट देने की ट्रिक को कॉपी करके 5 बाइट्स बचाता है । डेनिस से बचाए गए एक अन्य बाइट ने मुझे याद दिलाया कि गैर-जरूरी तरीके से घातांक की उच्च प्राथमिकता है ।bx-1x-1~

के inबजाय के साथ एक समान लंबाई समाधान any।

f=lambda x,b=2:b*(x*~-b in[x%b*~-b**d for d in range(x)])or f(x,b+1)%~-x

— XNOR
स्रोत

4

रूबी, 50 बाइट्स

->n{(2..n-2).find{|b,i=n|i%b==(i/=b)%b ?redo:i<1}}

मैं वास्तव में उस कष्टप्रद स्थान को दूर करना चाहता हूं लेकिन रूबी को एक नवागंतुक के रूप में, मैं अभी भी अपने सिंटैक्टिक क्वॉक्स के साथ काफी अपरिचित हूं।

— xsot
स्रोत

इस मामले में अपमानजनक है कि b?एक वैध विधि का नाम होगा, ताकि आप अंतरिक्ष से छुटकारा न पा सकें।

— जॉर्डन

4

इमोजीकोड , 214 बाइट्स

(77 अक्षर):

🐇🐹🍇🐇🐖🏁➡🚂🍇🍦b🍺🔲🗞🔷🔡😯🔤🔤🚂🍮i 2🍮n 0🔁◀i➖b 1🍇🍦v🔷🔡🚂b i🍊▶🐔🔫v🔪v 0 1📏v🍇🍮n i🍉🍫i🍉😀🔷🔡🚂n 9🍎0🍉🍉

आधार 9 में प्रिंट होता है।

मैं कुछ हफ़्ते के लिए इमोजीकोड के साथ एक कोड गोल्फ करने के लिए अर्थ रखता हूं, लेकिन भाषा केवल हाल ही में स्थिर हो गई है वास्तव में a के साथ काम करने के लिए। एक बोनस के रूप में, यह प्रश्न कार्यक्षमता के एक टुकड़े का उपयोग करता है इमोजीकोड वास्तव में बहुत अच्छा है: अन्य आधारों में पूर्णांक का प्रतिनिधित्व करता है।

Ungolfed (ode इमोजीकोड में एक पंक्ति टिप्पणी है)

🐇🐹🍇         👴 define main class "🐹"
  🐇🐖🏁➡🚂🍇  👴 define main method

    👴 read an integer from stdin, store it in frozen variable "b"
    🍦 b 🍺 🔲 🗞 🔷🔡😯🔤🔤 🚂

    🍮 i 2  👴 i = 2
    🍮 n 0  👴 n = 0

    🔁◀i➖b 1🍇     👴 while i < b - 1
      🍦 v 🔷🔡🚂b i  👴 v = the string representation of b in base i

      👴 Split v on every instance of the first character of v.
      👴 If the length of that list is greater than the actual length of v,
      👴 n = i
      🍊▶🐔🔫v🔪v 0 1📏v🍇
        🍮 n i
      🍉

      🍫 i  👴 increment i
    🍉
    😀 🔷🔡🚂 n 9  👴 represent n in base 9 instead of 10, to save a byte 😜
    🍎 0          👴 return error code 0
  🍉
🍉

— orez
स्रोत

4

पायथन 2, 79 बाइट्स

f=lambda x,b=2:~-b*x in[i%b*~-b**(i/b)for i in range(b*x)]and b or f(x,-~b)%~-x

Ideone पर इसे आज़माएं ।

विचार

आधार b> 1 और अंक d <b का कोई भी प्रतिवर्ती x निम्नलिखित को संतुष्ट करता है।

शर्त

चूंकि d <b , मैप (b, d) + cb + d इंजेक्टिव है।

साथ ही, b, x> 1 के बाद से , हमारे पास c <x , इसलिए cb + d <cb + b = (c + 1) b) xb है ।

इसका मतलब है कि, के लिए उपयुक्त मूल्यों को खोजने के ग और घ किसी दिए गए आधार के लिए ख , हम सब के माध्यम से पुनरावृति कर सकते हैं मैं में [0, ..., bx) और जांच (ख - 1) एक्स == (i% ख) (ख ^{i / b} - 1) ।

कोड

लैम्ब्डा एफ टेस्ट नाम दिया गया है (b - 1) x सेट में है {(i% b) (b ^{i / b} - 1) | 0 0 i <bx} , मान b = 2 से शुरू होता है ।

यदि परीक्षण सफल रहा, तो हम बी लौट आए ।
और, हम फिर से f को कॉल करते हैं, उसी x और b को 1 से बढ़ाते हैं ।

चूंकि ख अंततः तक पहुंच सकता है एक्स - 1 , हम अंतिम परिणाम सापेक्ष ले एक्स - 1 वापस जाने के लिए 0 इस मामले में। ध्यान दें कि ऐसा नहीं होगा यदि b = 2 स्थिति को संतुष्ट करता है, क्योंकि यह पुनरावृत्ति के बिना वापस आ जाता है। हालांकि, सवाल इस बात की गारंटी देता है कि इस मामले में b = 2 <x - 1 है।

— डेनिस
स्रोत

3

पर्ल 6, 45 43 42 बाइट्स

{grep 2..$^x-2: {[==] $x.polymod($_ xx*)}}

समझाया (प्रकार)

संदर्भ के लिए, एक चर $^xमें { ... }कर के रूप में ही है-> $x { ... }

{grep 2..$^x-2: {[==] $x.polymod($_ xx*)}}
{                                          # Anonymous function taking $x
 grep                                      # Return the all values in
      2..$^x-2: {                          # Range from 2 to $x - 2 satisfying:
                 [==]                      #     Reduce with ==:
                      $x.polymod(          #         (See below for polymod)
                                 $_ xx*    #         An infinite list containing
                                           #         the current value
                                       )}}

Polymod (टीएल, डीआर): $n.polymod($b xx *)आप के लिए / 'अंक' अंकों के एक उलट सूची प्रदान करती है $nआधार में$b

पॉलीमॉड (वास्तविक के लिए): पॉलीमॉड विधि लगभग अजगर के divmodकार्य के अधिक शक्तिशाली संस्करण की तरह है । $n.polymod(*@args)* @ आर्ग में प्रत्येक मान से $ n को विभाजित करता है, शेष ( $n mod $x) को उस सूची में जोड़ता है और अगले भाग के लिए भागफल का उपयोग करता है। मुझे लगता है कि मैंने इसे खराब तरीके से समझाया, इसलिए यहां कुछ उदाहरण दिए गए हैं (पर्ल 6 में लिखे गए हैं, लेकिन बहुत साफ है कि मुझे सबसे अधिक आशा है कि यह समझा जाए):

12.polymod(7)    # returns (5, 1)
# Roughly equivalent to:
(12 mod 7, 12 div 7)

86400.polymod(60,60,24) # returns (0, 0, 0, 1)
# Roughly equivalent to (this will give you an array rather than a list):
my $n = 86400;
my @remainders; # Here lies the end result
for (60, 60, 24) -> $divisor {
    @remainders.push( $n mod $divisor );
    $n div= $divisor;
}
@remainders.push($n)

# This is essentially the base conversion algorithm everyone
# knows and loves rolled into a method.
# Given an infinite list of divisors, polymod keeps going until
# the remainder given is 0.     
0xDEADBEEF.polymod(16 xx *) # returns (15 14 14 11 13 10 14 13)
# Roughly equivalent to (but gives an array rather than a list):
my $n = 0xDEADBEEF;
my @remainders; # Here lies the end result
while $n > 0 {
    @remainders.push( $n mod 16 );
    $n div= 16;
}

— हॉटकी
स्रोत

1

वास्तव में चूंकि आपको मान्य मानों के " किसी भी या सभी " आउटपुट की अनुमति है , आप grepविधि के बजाय विधि का उपयोग कर सकते हैं first।

— ब्रैड गिल्बर्ट

ओह अच्छा पकड़, मुझे याद आया कि

— Hotkeys

3

दिल्लोग एपीएल , 28 बाइट्स

 {b/⍨⍵{1=≢∪⍵⊥⍣¯1⊢⍺}¨b←1+⍳⍵-3}

{... ⍵... }अनाम कार्य करने के लिए लागू किया जाना है x(द्वारा प्रतिनिधित्व ⍵)
b←1+⍳⍵-32 से पूर्णांकों - ⍵ -2 संग्रहीत के रूप में b
⍵{... }¨ख (में प्रत्येक तत्व के लिए ⍵), समारोह लागू {... }के रूप में छोड़ दिया तर्क एक्स के साथ ⍺
⍵⊥⍣¯1⊢⍺कि आधार के लिए परिवर्तित एक्स
1=≢∪1 संख्या के बराबर है अद्वितीय अंक का?
b/⍨b के तत्व जहां सत्य हैं (कि केवल एक अद्वितीय अंक है)।

उदाहरण के मामले

यदि कोई आधार मौजूद नहीं है, तो आउटपुट खाली है (जो कि गलत है), जैसा कि इस कार्यक्रम द्वारा दिखाया जा सकता है:

 WhatIsEmpty
 →''/TRUE ⍝ goto (→) TRUE: if (/) emptystring ('')
 'False'
 →END       
TRUE:       
 'True'     
END:

यह प्रिंट 'गलत'

— एडम
स्रोत

2

पायथ, 26 19 बाइट्स

hMfql{eT1m,djQdr2tQ

यहाँ कोशिश करो!

~~इसके बाद मैं इस बात को समझाउंगा।~~ देखो इस जवाब एक छोटी कार्यान्वयन और स्पष्टीकरण के लिए।

— Denker
स्रोत

1

मुझे याद दिलाता है कि मैं के लिए अतिरिक्त ठिकानों भूल के लिए धन्यवाद 90और 91मेरी उदाहरण में!

— AdmBorkBork

2

MATL , 15 14 बाइट्स

3-:Q"G@:YAd~?@

यह भाषा / संकलक के वर्तमान संस्करण (14.0.0) के साथ काम करता है ।

यदि कोई आधार मौजूद नहीं है, तो आउटपुट खाली है (जो कि गलत है)।

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

3-:Q    % take input x implicitly. Generate range of possible bases: [2,3,...,x-2]
"       % for each base b
  G     %   push input again
  @:    %   generate vector of (1-based) digits in base b: [1,2,...,b]
  YA    %   convert to that base
  d~    %   differences between consecutive digits; negate
  ?     %   if all values are true (that is, if all digits were equal)
    @   %     push that base
        %   end if implicitly
        % end for each implicitly
        % display implicitly

— लुइस मेंडो
स्रोत

2

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

Cases[4~Range~#-2,a_/;Equal@@#~IntegerDigits~a]/.{}->0&

अनाम फ़ंक्शन, बहुत जटिल नहीं है। बस repdigit-ness पर आधारित ठिकानों को छानता है।

— LegionMammal978
स्रोत

2

पायथन 2, 75 बाइट्स

n=input()
b=1
while b<n-2:
 i=n;b+=1
 while i%b==i/b%b:i/=b
 if i<b:print b

मेरे माणिक जवाब का एक बंदरगाह। सभी मान्य आधारों को प्रिंट करता है यदि कोई मौजूद है।

— xsot
स्रोत

2

जूलिया, 45 बाइट्स

n->filter(b->endof(∪(digits(n,b)))<2,2:n-2)

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और पूर्णांक सरणी देता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें। यह सभी लागू आधारों या खाली सरणी को लौटाएगा। बड़े ठिकानों के साथ कोई समस्या नहीं है।

पहले हम समावेशी रेंज [2, n - 2] उत्पन्न करते हैं , जहां n इनपुट है। हम तो filterकेवल पूर्णांकों के लिए सूची ख जिसके लिए n आधार में ख से कम 2 अद्वितीय अंक हैं। ऐसा करने के लिए, सीमा में प्रत्येक पूर्णांक b के लिए, हमें आधार b में n का अंक एक सरणी के रूप में मिलता है, उपयोग करने वाले अद्वितीय आइटम प्राप्त करते हैं , और अंतिम तत्व (यानी लंबाई) का सूचकांक प्राप्त करते हैं ।digits∪endof

— एलेक्स ए।
स्रोत

1

ब्रेकीलॉग , 12 बाइट्स

>>.ℕ₂≜&ḃ↙.=∧

इसे ऑनलाइन आज़माएं! (एक जनरेटर के रूप में!)

इनपुट चर के माध्यम से इनपुट लेता है और इस मामले में आउटपुट चर के माध्यम से एक आधार को आउटपुट करता है कि यह संभव है, अन्यथा विफल। इसी समय, यह एक जनरेटर के रूप में भी काम करता है जो सभी आधारों की एक सूची को आउटपुट करता है, जहां वह सूची खाली हो सकती है।

आदर्श रूप में यह कुछ ऐसा दिख सकता है ḃ↙.=&>>, संभवतः जनरेटर की कार्यक्षमता को उस रूप में या इसी तरह के एक के बाद से (क्योंकि यह अंततः एकतरफा मारा जाएगा), लेकिन अब तक 12 बाइट कम से कम मुझे पता है कि इसे कैसे प्राप्त करना है।

     ≜          Assign an integer value to
  .             the output variable
   ℕ₂           which is greater than or equal to 2
 >              and less than a number
>               which is less than the input.
      &         The input
       ḃ↙.      in base-(the output)
          =     is a repdigit.
           ∧    (which is not necessarily the output)

— असंबंधित स्ट्रिंग
स्रोत

1

रूबी , 46 43 बाइट्स

रूबी 2.4 में पेश किए गए इंटेगर # डिजिट फ़ंक्शन का उपयोग मैन्युअल रूप से विभाजित करने की आवश्यकता से बचने के लिए करता है।

-3 बाइट्स @ जोर्डन को धन्यवाद।

->n{(2..n-2).find{|i|!n.digits(i).uniq[1]}}

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

— मूल्य स्याही
स्रोत

@ जोर्डन आह हां मैं उस ट्रिक को भूल रहा हूं

— मान इंक

0

05AB1E , 7 बाइट्स

ÍL¦ʒвÙg

सभी संभव मानों को आउटपुट करता है, या फ़ाल्सी वैल्यू के रूप में एक खाली सूची (हालांकि तकनीकी रूप से मान्य आउटपुट फ़ॉसी के रूप में अच्छी तरह से हैं, क्योंकि केवल 105AB1E में सत्य है, और बाकी सब फ़ॉसी है)।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Í        # Decrease the (implicit) input-integer by 2
 L       # Create a list in the range [1, input-2]
  ¦      # Remove the first value to make the range [2, input-2]
   ʒ     # Filter this list by:
    в    #  Convert the (implicit) input to the base of the number we're filtering
     Ù   #  Uniquify it, leaving only distinct digits
      g  #  Get the length of this, which is truthy (1) if all digits were the same
         # (and then output the filtered list implicitly as result)

— केविन क्रूज़सेन
स्रोत

0

पर्ल 5 `-Minteger -na` , 63 बाइट्स

map{$r=$,=($c="@F")%$_;$r*=$c%$_==$,while$c/=$_;$r&&say}2..$_-2

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

कोई समाधान मौजूद नहीं है, तो सभी संभव जवाब या कुछ भी नहीं।

— Xcali
स्रोत

Repdigit बेस ढूँढना

इनपुट

उत्पादन

नियम

उदाहरण

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

यह काम किस प्रकार करता है

Pyth, 1 1 10

स्पष्टीकरण:

रूबी, 87 69 63 बाइट्स

पायथन, 71 72 78 बाइट्स

रूबी, 50 बाइट्स

इमोजीकोड , 214 बाइट्स

पायथन 2, 79 बाइट्स

विचार

कोड

पर्ल 6, 45 43 42 बाइट्स

दिल्लोग एपीएल , 28 बाइट्स

पायथ, 26 19 बाइट्स

MATL , 15 14 बाइट्स

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

पायथन 2, 75 बाइट्स

जूलिया, 45 बाइट्स

ब्रेकीलॉग , 12 बाइट्स

रूबी , 46 43 बाइट्स

05AB1E , 7 बाइट्स

पर्ल 5 -Minteger -na , 63 बाइट्स

पर्ल 5 `-Minteger -na` , 63 बाइट्स