Collatz तरह के दृश्यों का विश्लेषण

Question

हम 4 धनात्मक पूर्णांक के साथ Collatz तरह के अनुक्रम को परिभाषित sकरते हैं:

• n मूल्य शुरू
• d > 1 भाजक
• m > 1 गुणक
• i वेतन वृद्धि

(मूल Collatz अनुक्रम में d = 2 m = 3और i = 1।)

ये पूर्णांक sनिम्नलिखित तरीके से बनाए जाएंगे:

• s(0) = n
• अगर k > 0और s(k-1) mod d = 0फिरs(k) = s(k-1) / d
• अगर k > 0और s(k-1) mod d != 0फिरs(k) = s(k-1) * m + i

के साथ एक उदाहरण अनुक्रम d = 2, m = 3, i = 5और n = 80होगा s = 80, 40, 20, 10, 5, 20, 10, 5, 20, ...।

प्रत्येक अनुक्रम या तो किसी दिए गए बाउंड (यानी अनुक्रम डिवर्जेंट है) की तुलना में उच्च मूल्यों तक पहुंच जाएगा या यदि कुछ tऔर u( t!=u) के लिए अनंत लूप में मिल s(t) = s(u)जाएगा तो समानता सत्य होगी।

हमारी समस्या में अगर किसी अनुक्रम तत्व का मान 10^9उससे बड़ा है या 1000वें तत्व से पहले कोई तत्व दोहराव नहीं है तो अनुक्रम को विचलन माना जाता है।

काम

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो पॉजिटिव पूर्णांक लेता है d mऔर iइनपुट के रूप में और सभी विभिन्न प्रकार के अनुक्रमों (अनंत छोरों और विचलन) को आउटपुट करता है जो शुरुआती मान n = 1, 2, 3, ... 999, 1000उत्पन्न कर सकते हैं।

इनपुट विवरण

• इनपुट एक स्ट्रिंग या सूची (या अपनी भाषा में निकटतम समतुल्य) का प्रतिनिधित्व करने (सामान्य तरीके से) तीन धनात्मक पूर्णांक है d, mऔर iइसी क्रम में। dऔर mकम से कम हैं 2। न तो संख्या इससे बड़ी है 100।

आउटपुट विवरण

आउटपुट स्पेसिफिकेशन थोड़ा चिंताजनक है। पहले उदाहरणों को देखने के लायक हो सकते हैं।

• आपको मानक आउटपुट (या निकटतम विकल्प) के लिए आउटपुट करना चाहिए या एक स्ट्रिंग वापस करना चाहिए।
• यदि विचलन अनुक्रम संभव है तो पहली पंक्ति होनी चाहिए DIVERGENT।
• अनुक्रम के लूप का एक अनूठा प्रतिनिधित्व यह रोटेशन है जहां सबसे छोटी संख्या अंतिम स्थान द्वारा अलग की गई है। जैसे अगर s = 2 1 4 2 1 4 2 1लूप है 4 2 1।
• प्रत्येक निम्नलिखित पंक्ति में आपको शब्द द्वारा पूर्ववर्ती एक बार प्रत्येक अद्वितीय लूप का आउटपुट देना चाहिए LOOP। उदाहरण के लिएLOOP 4 2 1
• छोरों को उनके अंतिम तत्व के संबंध में आरोही क्रम में होना चाहिए।
• अनुगामी न्यूलाइन वैकल्पिक है।

उदाहरण:

पहली पंक्तियाँ इनपुट और निम्न हैं जब तक एक रिक्त रेखा आउटपुट नहीं होती है।

2 3 1
LOOP 4 2 1

2 2 6
LOOP 8 4 2 1
LOOP 12 6 3

3 7 8
DIVERGENT
LOOP 15 5 43 309 103 729 243 81 27 9 3 1
LOOP 22 162 54 18 6 2
LOOP 36 12 4

3 9 1
DIVERGENT

6 9 9
DIVERGENT
LOOP 18 3 36 6 1
LOOP 27 252 42 7 72 12 2
LOOP 45 414 69 630 105 954 159 1440 240 40 369 3330 555 5004 834 139 1260 210 35 324 54 9 90 15 144 24 4
LOOP 81 738 123 1116 186 31 288 48 8
LOOP 99 900 150 25 234 39 360 60 10
LOOP 126 21 198 33 306 51 468 78 13

10 10 10
LOOP 20 2 30 3 40 4 50 5 60 6 70 7 80 8 90 9 100 10 1

93 91 92
DIVERGENT
LOOP 2185 198927 2139 23
LOOP 4278 46

आइडोन पर पायथन 3 में संदर्भ कार्यान्वयन।

यह कोड-गोल्फ है इसलिए सबसे छोटी प्रविष्टि जीतती है।

Answer 1

पायथन 3, 269 254 252 246 बाइट्स

d,m,i=eval(input())
S=set()
for n in range(1,1001):
 T=X=()
 while len(T)**3<1e9>=n:
  T=(n,)+T;n=[n//d,n*m+i][n%d>0]
  if n in T:I=T.index;L=T[:I(n)+1];M=I(min(L));X=L[M:]+L[:M]
 S|={X}
for x in sorted(S):print(x and"LOOP"or"DIVERGENT",*x[::-1])

(अब कुछ बाइट्स को बचाने के लिए 10 गुना धीमा। विशिष्ट कोड गोल्फ।)

STDIN (जैसे [2, 3, 1]) के माध्यम से एक सूची इनपुट करें । मैं सोच रहा हूं कि साइकिल को मानकीकृत करने का एक बेहतर तरीका है ...

दृष्टिकोण काफी सीधा है - सभी 1000 नंबरों का परीक्षण करें और केवल अद्वितीय आउटपुट लें। हालाँकि, वहाँ दो छोटी चालें हैं:

• लूप्स का प्रतिनिधित्व गैर- रिक्त ट्यूपल्स द्वारा किया जाता है, लेकिन अधिक महत्वपूर्ण रूप से विचलन का प्रतिनिधित्व एक खाली ट्यूपल द्वारा किया जाता है । यह अच्छा है क्योंकि:

  • यह टूटता नहीं है sorted, और यहां तक कि सभी लूप ट्यूपल्स से पहले दिखाई देगा
  • यह हमें स्ट्रिंग का चयन करने की अनुमति देता है x and"LOOP"or"DIVERGENT"
  • *()[::-1] प्रभावित नहीं करता है print
• छोरों को "पिछले तत्व द्वारा बढ़ते हुए सॉर्ट" को "पहले तत्व द्वारा आरोही सॉर्ट" करने के लिए पीछे की ओर बनाया गया है, जो लैम्बडा को पास करने की आवश्यकता को हटा देता है sorted।

पिछला सबमिशन, 252 बाइट्स

d,m,i=eval(input())
def f(n,T=()):
 x=[n//d,n*m+i][n%d>0];I=T.index
 if x in T:L=T[:I(x)+1];M=I(min(L));return L[M:]+L[:M]
 return()if(T[1000:]or x>1e9)else f(x,(x,)+T)
for x in sorted(set(map(f,range(1,1001)))):print(x and"LOOP"or"DIVERGENT",*x[::-1])

यह एक बहुत तेज है।