न्यूनतम शेष अनुक्रम उत्पन्न करें

21

हर संख्या को एक असीम रूप से लंबे शेष अनुक्रम का उपयोग करके दर्शाया जा सकता है। उदाहरण के लिए, यदि हम संख्या 7 लेते हैं, और प्रदर्शन करते हैं 7mod2, तो 7mod3, फिर 7mod4, और इसी तरह, हम प्राप्त करते हैं 1,1,3,2,1,0,7,7,7,7,....।

हालाँकि, हमें सबसे कम संभव शेष परिणाम की आवश्यकता है जिसे अभी भी सभी निम्न संख्याओं से अलग करने के लिए उपयोग किया जा सकता है। 7 का फिर से उपयोग करना, [1,1,3]सबसे छोटी प्रक्रिया है, क्योंकि पिछले सभी क्रम [1,1,3]निम्न से शुरू नहीं होते हैं :

0: 0,0,0,0...
1: 1,1,1,1...
2: 0,2,2,2...
3: 1,0,3,3...
4: 0,1,0,4...
5: 1,2,1,0...
6: 0,0,2,1...

ध्यान दें कि 7 का प्रतिनिधित्व करने के लिए काम [1,1] नहीं करता है , क्योंकि इसका उपयोग 1 का प्रतिनिधित्व करने के लिए भी किया जा सकता है। हालांकि, आपको [1]1 के इनपुट के साथ आउटपुट करना चाहिए ।

इनपुट आउटपुट

आपका इनपुट एक गैर-नकारात्मक पूर्णांक है। जैसा कि ऊपर बताया गया है, आपको एक क्रम या न्यूनतम लंबाई के क्रम की सूची को आउटपुट करना होगा।

परीक्षण के मामलों:

0: 0
1: 1
2: 0,2
3: 1,0
4: 0,1
5: 1,2
6: 0,0,2
7: 1,1,3
8: 0,2,0
9: 1,0,1
10: 0,1,2
11: 1,2,3
12: 0,0,0,2
30: 0,0,2,0
42: 0,0,2,2
59: 1,2,3,4
60: 0,0,0,0,0,4
257: 1,2,1,2,5,5
566: 0,2,2,1,2,6,6
1000: 0,1,0,0,4,6,0,1
9998: 0,2,2,3,2,2,6,8,8,10
9999: 1,0,3,4,3,3,7,0,9,0

यहां पहले 10,000 अनुक्रम हैं , यदि आप रुचि रखते हैं (पंक्ति संख्या 1 से बंद हैं)।

यह एक कोड-गोल्फ है , इसलिए इसे अपनी पसंदीदा भाषा में जितना हो सके उतना कम बनाएं। तेजी से कर रहे हैं कि किसी भी जवाब के लिए नकली बोनस अंक!

code-golf  number  sequence  arithmetic  number-theory 
— नाथन मेरिल
स्रोत
— पीटर टेलर
@nimi हमने उस बारे में बातचीत की, और मैंने तय किया कि दृश्यों को कम से कम 1 तत्व लंबा होना चाहिए।
— नाथन मेरिल
1
मुझे थोड़ा आश्चर्य है कि आपने इसे प्रमुख अवशेषों तक सीमित नहीं किया है।
— नील
यदि सूची में आउटपुट लौटाया जाता है तो क्या यह ठीक है?
— आर। कप
@neil, मैंने यह भी माना, लेकिन क्योंकि मिश्रित संख्या के साथ अवशेष अलग हैं, मैंने इसे रखने के लिए मतदान किया
— नाथन मेरिल

जवाबों:

5

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

#~Mod~FirstCase[2~Range~#&/@Range[#+2],x_/;LCM@@x>#]&

कुछ हद तक तेज (यह ~ 0.1 सेकंड में 10000 को संभालता है, लेकिन संभवतः 100000 के लिए मेमोरी से बाहर चला जाएगा)।

कोड एक त्रुटि फेंकता है लेकिन परिणाम को सही ढंग से गणना करता है।

व्याख्या

हमने पहले चैट में पाया है कि आवश्यक विभाजक हमेशा सबसे छोटी सूची के रूप में निर्धारित किए जा सकते हैं, {1, 2, ..., n}जिसका कम से कम सामान्य एकाधिक इनपुट से अधिक है। ऐसा क्यों है के लिए एक छोटा तर्क: यदि एलसीएम इनपुट से कम है, तो एलसीएम को इनपुट से घटाकर सभी विभाजकों को अपरिवर्तित छोड़ दिया जाएगा, इसलिए प्रतिनिधित्व अद्वितीय नहीं है। हालाँकि, LCM से कम के सभी इनपुट के लिए, अवशेष अद्वितीय होंगे, अन्यथा समान संख्या वाले दो संख्याओं के बीच का अंतर सभी विभाजकों का एक छोटा गुणक होगा।

कोड के लिए के रूप में ... हमेशा की तरह गोल्फ की गणित पढ़ने का क्रम थोड़ा अजीब है।

Range[#+2]

यह हमें [1, 2, 3, ..., n+2]इनपुट के लिए एक सूची देता है n। +2यह सुनिश्चित करें कि इसके लिए ठीक से काम करता है 0और 1।

2~Range~#&/@...

इस सूची में नक्शा 2~Range~#(के लिए सिंटैक्टिक शुगर Range[2,#]), इसलिए हम प्राप्त करते हैं

{{}, {2}, {2,3}, ..., {2,3,...,n+2}}

ये उम्मीदवार विभाजक सूचियाँ हैं (निश्चित रूप से सामान्य तौर पर जो हमें आवश्यकता होगी उससे बहुत अधिक है)। अब हम उनमें से पहला खोजते हैं जिसका LCM इनपुट से अधिक है:

FirstCase[...,x_/;LCM@@x>#]

अधिक सिंटैक्स: x_एक पैटर्न है जो किसी भी सूची से मेल खाता है और इसे कॉल करता है x। /;उस पैटर्न को एक शर्त जुड़ जाता है। यह स्थिति है LCM@@x>#जहां @@ लागू होता है सूची, यानी करने के लिए समारोह LCM@@{1,2,3}का मतलब है LCM[1,2,3]।

अंत में हम केवल तथ्य यह है कि का इस्तेमाल कर रही सभी शेष मिलता है, Modहै Listable, यानी यह स्वचालित रूप से एक सूची से अधिक नक्शे यदि तर्कों में से एक सूची दी गई है (या अगर उन दोनों को एक ही लंबाई की सूची नहीं है):

#~Mod~...
— मार्टिन एंडर
स्रोत
5

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

‘Ræl\>iṠ2»2r⁸%

यह इस तथ्य का उपयोग करता है कि रैखिक congruences की एक प्रणाली का समाधान (यदि कोई हो) modulo का LCM का विशिष्ट मॉड्यूल है। इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

‘Ræl\>iṠ2»2r⁸%  Main link. Argument: n

‘               Increment; yield n+1.
 R              Range; yield [1, ..., n+1].
  æl\           Cumulatively reduce by LCM.
                This yields [LCM(1), ..., LCM(1, ..., n+1)].
     >          Compare all LCMs with n.
      iṠ        Find the first index of sign(n).
                This yields the first m such that LCM(2, ..., m) > n if n > 0, and
                0 if n == 0.
        2»      Take the maximum of the previous result and 2, mapping 0 to 2.
          2r    Yield the range from 2 up to and including the maximum.
            ⁸%  Compute n modulo each integer in that range.
— डेनिस
स्रोत
5

MATL , 24 बाइट्स

इस उत्तर के पिछले संस्करण में त्रुटि को इंगित करने के लिए @nimi के लिए धन्यवाद (अब सही किया गया)

Q:qtQ!\t0Z)tb=YpsSP2):Q)

यह दो सबसे बड़े परीक्षण मामलों के लिए ऑनलाइन कंपाइलर में मेमोरी से बाहर है (लेकिन यह 4 जीबी रैम वाले कंप्यूटर पर काम करता है)।

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

व्याख्या

यह परिभाषा को सीधे तरीके से लागू करता है। इनपुट के लिए nयह युक्त एक 2 डी सरणी की गणना mod(p,q)के साथ pसे 0करने के लिए nऔर qसे 1करने के लिए n+1। प्रत्येक pएक स्तंभ है, और प्रत्येक qएक पंक्ति है। उदाहरण के लिए, इनपुट के साथ n=7यह सरणी है

0 0 0 0 0 0 0 0
0 1 0 1 0 1 0 1
0 1 2 0 1 2 0 1
0 1 2 3 0 1 2 3
0 1 2 3 4 0 1 2
0 1 2 3 4 5 0 1
0 1 2 3 4 5 6 0
0 1 2 3 4 5 6 7

अब अंतिम कॉलम, जिसमें के अवशेष शामिल हैं n, इस सरणी के प्रत्येक कॉलम की तुलना में तत्व-वार है। यह प्रदान करता है

1 1 1 1 1 1 1 1
0 1 0 1 0 1 0 1
0 1 0 0 1 0 0 1
0 0 0 1 0 0 0 1
0 0 1 0 0 0 0 1
0 1 0 0 0 0 0 1
1 0 0 0 0 0 0 1
0 0 0 0 0 0 0 1

जहां 1समानता का संकेत देता है। अंतिम स्तंभ स्पष्ट रूप से स्वयं के बराबर है और इस प्रकार सभी शामिल हैं। हमें उस कॉलम को ढूंढना होगा जिसमें शुरुआती कॉलम की सबसे बड़ी संख्या है , पिछले कॉलम के अलावा, और शुरुआती लोगों की संख्या पर ध्यान दें m। (इस मामले में यह दूसरा कॉलम है, जिसमें m=3शुरुआती वाले शामिल हैं)। इसके लिए, हम प्रत्येक कॉलम के संचयी उत्पाद की गणना करते हैं:

1 1 1 1 1 1 1 1
0 1 0 1 0 1 0 1
0 1 0 0 0 0 0 1
0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 1

फिर प्रत्येक कॉलम का योग

1 3 1 2 1 2 1 8

और फिर गैर-बढ़ते क्रमबद्ध करें और दूसरा मान लें, जो है 3। यह वांछित है m, जो इंगित करता है कि हमें कितने अवशेष लेने की आवश्यकता है।

Q:q    % take input n implicitly. Generare row array [0 1 ... n]
tQ!    % duplicate. Transform into column array [1; 2; ...; n-1]
\      % modulo, element-wise with broadcast. Gives the 2D array
t0Z)   % duplicate. Take last column
tb     % duplicate, bubble up
=      % test for equality, element-wise with broadcast
Yp     % cumumative product of each column
s      % sum of each column. This gives the number of initial coincidences
SP2)   % sort in decreasing order and take second value: m
:Q     % generate range [2 3 ... m+1]
)      % apply as index into array of remainders of n. Implicitly display
— लुइस मेंडो
स्रोत
4

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

r¬µ%€R‘$ḟ/Ṫ

यह कोई वेग ब्राउनी अंक नहीं जीतेगा ... इसे ऑनलाइन आज़माएं! या छोटे परीक्षण मामलों की पुष्टि करें ।

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

r¬µ%€R‘$ḟ/Ṫ  Main link. Argument: n

r¬           Range from n to (not n).
             This yields [n, ..., 0] if n > 0 and [0, 1] otherwise.

  µ          Begin a new, monadic chain. Argument: A (range)

       $     Combine the previous two links into a monadic chain:
     R         Range; turn each k in A into [1, ..., k] or [] if k == 0.
      ‘        Increment to map k to [2, ..., k+1].
   %€        Take each k in A modulo all the integers in the 2D list to the right.
        ḟ/   Reduce by filter-not; sequentially remove all remainder sequences of
             n-1, ..., (not n) from the remainder sequences of n.
          Ṫ  Tail; take the last remainder sequence.
             This gives the shortest sequence for descending A and the longest one
             (i.e., [0]) for ascending A.
— डेनिस
स्रोत
आपने दो उत्तर क्यों शामिल किए हैं ???
— एर्ग आउटफोलर
क्योंकि वे दो पूरी तरह से अलग दृष्टिकोण हैं। जबकि यह 3 बाइट्स छोटा है, अन्य सभी परीक्षण मामलों की गणना करने के लिए वास्तव में काफी तेज है।
— डेनिस
अगर मैं आप होते, तो मैं ऐसा नहीं करता ... सिवाय इसके कि अगर यह एक अप / डाउन वोट की बात होती।
— को एग्लोफ़र ​​ऑर्क
— डेनिस
3

पायथन 3.5, 117 95 78 बाइट्स

import sympy
r=lambda n,m=2,M=1,*l:M>n and l or r(n,m+1,sympy.lcm(m,M),*l,n%m)

पाइथन 3.5 और सिम्पी ( python3 -m pip install --user sympy) की आवश्यकता है। क्रेडिट @ @ डेनिस ने मुझे सूचित किया कि पायथन 3.5 *lडिफ़ॉल्ट तर्कों के साथ चाल की अनुमति देता है।

— orlp
स्रोत
SymPy 0.7.5 के साथ, आप छोटा कर सकते हैं M>n and lकरने के लिए l*(M>n)।
— डेनिस
3

पायथन 2, 73 70 69 65 बाइट्स

i=l=1
n=input()
while l<=n|1:
 i+=1;a=l;print n%i
 while l%i:l+=a

एक पूरा कार्यक्रम। @ डेनिस ने शून्य को संभालने के तरीके में सुधार करके 4 बाइट्स बचाए।

— xsot
स्रोत
3

हास्केल, 66 60 51 50 बाइट्स

f i=mod i<$>[2..2+sum[1|l<-scanl1 lcm[2..i],l<=i]]

प्रयोग उदाहरण: f 42-> [0,0,2,2]। यह @Martin Büttner के उत्तर में वर्णित एल्गोरिदम है ।

मैं पिछले संस्करण को संदर्भ के लिए रखूंगा, क्योंकि यह बहुत तेज़ है:

हास्केल, 51 बाइट्स

f i=mod i<$>[[2..x]|x<-[2..],foldl1 lcm[2..x]>i]!!0

यह f (10^100)मेरे पांच साल पुराने लैपटॉप पर 0.03s लेता है ।

संपादित करें: @xnor को बचाने के लिए एक बाइट मिला। धन्यवाद!

— nimi
स्रोत
जब तक h i=mod i<$>[2..2+sum[1|l<-scanl1 lcm[2..i],l<=i]]
— Lcm
2

पायथ, 51 बाइट्स 66 बाइट्स

IqQZ[Z).q)IqQ1[1))IqQ2,0 1))FdhhQJu/*GHiGHtUd1I>JQVQ aY%QhN)<tYd.q

कोशिश करके देखो!

बहुत अधिक गति 39 बाइट संस्करण (0-2 के लिए काम नहीं करता है):

FdhhQJu/*GHiGHtUd1I>JQVtd aY%QhN)<tYd.q

यह 10 10 3 जैसी बेतुकी बड़ी संख्या के लिए काम करता है

नोट: यह उत्तर 0, 1, और 2 के लिए काम नहीं करता है। फिक्स्ड!

— poi830
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 81 77 बाइट्स

f=(n,r=[n%2],l=i=2,g=(j,k)=>j?g(k%j,j):k)=>l>n?r:f(n,[...r,n%++i],i/g(i,l)*l)

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

संपादित करें: @ user81655 के लिए 4 बाइट्स सहेजे गए।

— नील
स्रोत
@ user81655 यह अभी रेखांकित है ...
— नील
2

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

->n{m=t=1;a=[];(a<<n%m)until n<t=t.lcm(m+=1);a<<n%m}

यह समाधान हर संभव जाँच करता है m 2 से शुरू होने वाले है जो शेष है जो अनुक्रम को अद्वितीय बनाता है। जो अंतिम mअद्वितीय बनाता है वह स्वयं शेष नहीं होता है, लेकिन यह mसबसे छोटी श्रेणी का अंतिम सदस्य होता है, (2..m)जहां उस श्रेणी का न्यूनतम सामान्य एकाधिक (LCM) इससे अधिक होता है n। यह चीनी अवशेष प्रमेय के कारण है, जहां विशिष्ट रूप से यह निर्धारित करने के लिए कि संख्या कितनी संख्या में nहै, उन अवशेषों का एलसीएम इससे अधिक होना चाहिए n(यदि चयन करने nसे (1..n); यदि चयन करते nहैं a..b, तो एलसीएम की आवश्यकता केवल इससे अधिक होनी चाहिए b-a)

नोट: मैंने a<<n%mकोड के अंत में रखा है क्योंकि until n<t=t.lcm(m+=1)शॉर्ट-सर्किट से पहले aइसे अद्वितीय बनाने के लिए अंतिम तत्व प्राप्त हुआ है।

अगर किसी के पास कोई गोल्फ सुझाव है, तो कृपया मुझे टिप्पणियों में या पीपीसीजी चैट में बताएं ।

Ungolfing:

def remainder_sequence(num)
  # starting with 1, as the statements in the until loop immediately increments divisor
  divisor = 1
  # starts with 1 instead of 2, as the statements in the until loop
  # immediately change product to a new lcm
  product = 1
  remainders = []

  # this increments divisor first then checks the lcm of product and divisor
  # before checking if num is less than this lcm
  until num < (product = product.lcm(divisor = divisor + 1))
    remainders << num % divisor
  end

  # until always short circuits before the last element is entered
  # so this enters the last element and returns
  return remainders << num % divisor
end
— Sherlock9
स्रोत
1

पायथन 3.5, 194 181 169 152 149 146 बाइट्स:

( 2 बाइट्स के लिए @ शर्लक 9 का धन्यवाद! )

def r(o,c=0):
 y=[[j%i for i in range(2,100)]for j in range(o+1)]
 while 1:
  c+=1;z=y[-1][:c]
  if z not in[f[:c]for f in y[:-1]]:break
 print(z)

पूरी तरह से काम करता है, और बहुत जल्दी है। 100000आउटपुट के न्यूनतम शेष अनुक्रम के लिए गणना [0, 1, 0, 0, 4, 5, 0, 1, 0, 10, 4, 4]और केवल 3 सेकंड के लिए। यह इनपुट 1000000(1 मिलियन), आउटपुट के लिए अनुक्रम की गणना करने में भी सक्षम था[0, 1, 0, 0, 4, 1, 0, 1, 0, 1, 4, 1, 8, 10, 0, 9] , और लगभग 60 सेकंड लगे।

व्याख्या

मूल रूप से इस समारोह सबसे पहले एक सूची बना रहा है क्या करता है, y, सभी के साथ j mod iजहां jरेंज में हर पूर्णांक है 0=>7(7 सहित) और iरेंज में हर पूर्णांक है 0=>100। तब प्रोग्राम एक अनंत whileलूप में जाता है और सूची के अंतिम सबलिस्ट ( ) में आइटम की समान संख्या के साथ y( y[:-1:]) के दूसरे-से-अंतिम सब्लिस्ट के माध्यम से पहले के भीतर प्रत्येक सबलिस्ट की सामग्री की समान संख्या की तुलना करता है । जब sublist है अलग किसी अन्य sublist से, लूप से बाहर टूट गया है, और सही कम से कम शेष अनुक्रम दिया जाता है।y[-1]yy[-1]

उदाहरण के लिए, यदि इनपुट 3 है, तो yयह होगा:

[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [1, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]]

फिर, जब यह लूप में प्रवेश करता है, तो यह सूची में प्रत्येक सबलिस्ट y[:-1:]को समान सूची में समान आइटमों के साथ तुलना करता है y[-1]। उदाहरण के लिए, यह पहले तुलना करेगा [[0],[1],[0]]और [1]। चूंकि अंतिम सबलिस्ट बाकी में है y, यह जारी रहेगा और फिर तुलना [[0,0],[0,1],[0,2]]और [1,0]। चूंकि [1,0]अब y उस विशिष्ट क्रम के बाकी हिस्सों में नहीं है , इसलिए यह न्यूनतम अनुस्मारक अनुक्रम है, और इसलिए, [1,0]सही ढंग से वापस आ जाएगा।

— आर। कप
स्रोत
बाइट्स को बचाने के लिए, y[:c:]जैसा हैy[:c]
— शर्लक
0

C89, 105 बाइट्स

g(a,b){return b?g(b,a%b):a;}main(n,m,M){scanf("%d",&n);for(m=M=1;(M=++m*M/g(m,M))<=n;)printf("%d ",n%m);}

संकलन (चेतावनियों के साथ) का उपयोग करना gcc -std=c89। स्टड पर एक ही नंबर लेता है, और स्टडआउट पर रिक्त स्थान द्वारा अलग किए गए अवशेष के अनुक्रम को आउटपुट करता है।

— orlp
स्रोत
1
यह कुछ भी प्रिंट नहीं करता है जब n = 0
— xsot
0

सी, 89 बाइट्स

a,i=2;main(l,n){for(n=atoi(gets(n))?:!puts(n);n/l;printf("%d ",n%i++))for(a=l;l%i;l+=a);}

जीसीसी के साथ संकलन। इसे ऑनलाइन आज़माएँ: n = 59 , n = 0 ।

— xsot
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.