Sharkovskii का अजीब क्रम

Question

परिचय

इस चुनौती में, हम सकारात्मक पूर्णांक के एक निश्चित क्रम के साथ काम करेंगे। आदेश इस प्रकार है:

   3,    5,    7,    9,    11, ...
 2*3,  2*5,  2*7,  2*9,  2*11, ...
 4*3,  4*5,  4*7,  4*9,  4*11, ...
 8*3,  8*5,  8*7,  8*9,  8*11, ...
16*3, 16*5, 16*7, 16*9, 16*11, ...
 ...
... 64, 32, 16, 8, 4, 2, 1

हम पहले आरोही क्रम में 1 से अधिक सभी विषम पूर्णांक सूचीबद्ध करते हैं। फिर हम 1 से अधिक दो बार अजीब पूर्णांक सूचीबद्ध करते हैं, फिर 4 बार, फिर 8 बार, और इसी तरह: सभी के लिए , हम 2 ^k गुना विषम पूर्णांक को आरोही क्रम में 1 से अधिक सूचीबद्ध करते हैं। अंत में, हम दो की शक्तियों को अवरोही क्रम में सूचीबद्ध करते हैं , 1. पर समाप्त होता है। प्रत्येक सकारात्मक पूर्णांक इस "सूची" में ठीक एक बार होता है।

अधिक स्पष्ट रूप से, दो अलग-अलग सकारात्मक पूर्णांक पर विचार करें A = n · 2 ^p और B = m · 2 ^q , जहाँ n, m and 1 विषम हैं, और p, q । 0 । उसके बाद A , B से पहले क्रम में आता है , यदि निम्न में से कोई एक शर्त रखता है:

• n> 1 , m> 1 और p <q
• 1 <n <m और p = q
• एन> एम = 1
• n = m = 1 और p> q

यह आदेश शारकोवस्की के प्रमेय के रूप में ज्ञात आश्चर्यजनक गणितीय परिणाम में प्रकट होता है , जो गतिशील प्रणालियों के आवधिक बिंदुओं की चिंता करता है। मैं यहां विवरण में नहीं जाऊंगा।

काम

इस चुनौती में आपका काम उपरोक्त आदेश की गणना करना है। आपके इनपुट दो सकारात्मक पूर्णांक A और B हैं , जो समान हो सकते हैं। आपका आउटपुट एक truthy मूल्य अगर है एक से पहले आता है बी आदेश में, और एक falsy मूल्य अन्यथा। यदि A = B , आपका आउटपुट सत्य होना चाहिए। जब तक आप सुसंगत हैं, तब तक आप ए और बी को किसी भी क्रम में ले सकते हैं ।

आपको पूर्णांक अतिप्रवाह के बारे में चिंता करने की ज़रूरत नहीं है, लेकिन आपके एल्गोरिथ्म को सैद्धांतिक रूप से बड़े इनपुट के लिए काम करना चाहिए।

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

सत्य दृष्टांत

3 11
9 6
48 112
49 112
158 158
36 24
14 28
144 32
32 32
32 8
3 1
1 1

झूठा उदाहरण

1 2
1 5
11 5
20 25
2 8
256 255
256 257
72 52
2176 1216
2176 2496

Answer 1

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

f=(a,b)=>b<2||a>1&&(a&b&1?a<=b:a&1|~b&f(a/2,b/2))

स्पष्टीकरण:

• यदि बी 1 है, तो एक पूर्व (या बराबर) बी
• अन्यथा, यदि कोई 1 है, तो पूर्ववर्ती बी नहीं है
• अन्यथा, यदि ए और बी दोनों विषम हैं, तो नियमित असमानता की जांच करें
• अन्यथा, यदि कोई विषम है, तो यह पूर्ववर्ती है
• अन्यथा, यदि बी विषम है, तो पूर्ववर्ती बी नहीं है
• अन्यथा, ए और बी दोनों को 2 से विभाजित करें और फिर से प्रयास करें।

संपादित करें: सहेजे गए 2 बाइट @Arnauld के लिए धन्यवाद।

Comments

अच्छा लगा। मैंने यहाँ पुनरावृत्ति का उपयोग करने के बारे में नहीं सोचा था। चाहेंगे a&1|~b&1&f(a/2,b/2)काम करते हैं?

— अरनौलद

@ अर्नूल मुझे यकीन नहीं है, मुझे चिंता थी कि यह अनिश्चित काल तक लूप करेगा।

— नील

यह b<2अंत में सच हो जाएगा क्योंकि नहीं कर सकते । अब, एक और समस्या यह है कि आप जरूरत से ज्यादा पुनरावृत्तियों की प्रक्रिया करेंगे और फ्लोटिंग पॉइंट वैल्यू प्राप्त करेंगे। लेकिन मुझे ऐसा कोई प्रतिसाद नहीं मिल रहा है जो उम्मीद के मुताबिक काम नहीं करेगा।

— अरनुलद

@Arnauld आह, ठीक है, मैं b<2मूल रूप से उपयोग नहीं कर रहा था , लेकिन मुझे लगता है कि यह अब काम करेगा।

— नील

@Arnauld अभी भी बेहतर है, के बाद से f(a/2,b/2)ही रिटर्न 0, 1, falseया true, मैं भी जरूरत नहीं है &1।

— नील

Answer 2

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

k=lambda n:[n&~-n<1,(n&-n)*cmp(n&~-n,1),n/(n&-n)]
lambda a,b:k(a)<=k(b)

यह शायद किसी भी आकार के पुरस्कार नहीं जीतेगा, लेकिन यह उत्तर पूर्णांक से 3 भावों का उपयोग करके 3-ट्यूपल का निर्माण करके काम करता है कि जब लेक्सोग्राफिक रूप से आदेश दिया जाता है तो सही क्रम में परिणाम होगा।

पठनीय शब्दों में, टपल ए = एन · 2 ^{पी के लिए है} :

[n == 0, p * (1 - 2*(n == 0)), n]

Answer 3

अजगर 2, 50 बाइट्स

lambda*l:cmp(*[([-n][n&n-1:],n&-n,n)for n in l])<1

प्रत्येक संख्या को एक ट्रिपल मैप किया जाता है जिसका क्रमबद्ध क्रम वांछित क्रम है।

• प्राथमिक मूल्य है [-n][n&n-1:], जो अंत में 2 की शक्तियों को संभालता है। बिटवाइज़ "और" एक शक्ति n&n-1होने पर बिल्कुल शून्य है । यदि हां, तो हम सूची प्राप्त करते हैं , और अन्यथा खाली सूची । यह आदेश के अंत में 2 की सभी शक्तियों को घटते क्रम में रखता है।n2[-n][]
• द्वितीयक मान n&-nपावर -2 के कारक को निकालता है n।
• अंतिम मान nअधिक संख्या के पक्ष में 2 की समान शक्तियों को टाईब्रेक करता है।

यह cmpदेखने के लिए कि क्या तुलना है, संबंधित टुपल्स पास किए जाते हैं <=0। पायथन 3 (n&n-1<1)/nट्रिपल में पहले मूल्य के लिए फ्लोट डिवीजन के साथ एक बाइट को बचाएगा , लेकिन अभाव cmp।

Comments

के cmp(...)<=0बराबर नहीं है cmp(...)<1?

— मैथमेटंदन

@ मतमंदन हां :)

— xnor

मुझे लगता है कि पूर्णांकों को उल्टे क्रम में लेना और ~इसके बदले उपयोग करने की अनुमति है<1

— मिच श्वार्ट्ज

Answer 4

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

शायद कुछ और गोल्फ हो सकता है, लेकिन पहले प्रयास के रूप में:

x=>y=>(a=x&-x,x/=a,b=y&-y,y/=b,y<2?x>1|b<=a:x>1&(b>a|b==a&y>=x))

करी सिंटैक्स के साथ इनपुट लेता है (x)(y)। रिटर्न 0/ 1।

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

let f =

x=>y=>(a=x&-x,x/=a,b=y&-y,y/=b,y<2?x>1|b<=a:x>1&(b>a|b==a&y>=x))

console.log('Testing truthy instances ...');
console.log(f(3)(11));
console.log(f(9)(6));
console.log(f(48)(112));
console.log(f(49)(112));
console.log(f(158)(158));
console.log(f(36)(24));
console.log(f(14)(28));
console.log(f(144)(32));
console.log(f(32)(32));
console.log(f(32)(8));
console.log(f(3)(1));
console.log(f(1)(1));

console.log('Testing falsy instances ...');
console.log(f(1)(2));
console.log(f(1)(5));
console.log(f(11)(5));
console.log(f(20)(25));
console.log(f(2)(8));
console.log(f(256)(255));
console.log(f(256)(257));
console.log(f(72)(52));
console.log(f(2176)(1216));
console.log(f(2176)(2496));

Comments

आप चारों ओर और अंदर कोष्ठक को बाहर निकाल सकते हैं b>a||(b==a&&y>=x), निष्पादन पर कोई फर्क नहीं पड़ेगा।

— XavCo7

@ XavCo7 कोष्ठक को अंदर से हटाना ठीक है लेकिन आसपास नहीं। सभी मौजूदा परीक्षण मामले अभी भी पास होंगे, लेकिन एक इनपुट जैसे कि [1, 5]गलत तरीके से सत्य के रूप में पहचाना जाएगा।

— अरनौलड

@Arnauld मैं इसे भविष्य के लिए एक नए परीक्षण के मामले के रूप में जोड़ूंगा।

— जर्ग डेब

Answer 5

पर्ल 6 , 89 84 बाइट्स

->\a,\b{my \u=*>max a,b;a==first a|b,flat [1,2,4...u].&{(3*$_,5*$_...u for $_),.reverse}}

{my \u=*>@_.max;@_[0]==first @_.any,flat [1,2,4...u].&{.map(*X*(3,5...u)),.reverse}}

( इसे ऑनलाइन आज़माएं। )

बिल्कुल छोटा नहीं है, लेकिन मुझे लगा कि यह एक समाधान लिखना दिलचस्प होगा जो वास्तव में ऑर्डरिंग अनुक्रम (प्रत्येक उप-अनुक्रम के लिए एक सुरक्षित ऊपरी सीमा तक) उत्पन्न करता है, और फिर जांचता है कि कौन सा इनपुट पहले इसमें दिखाई देता है।

उदाहरण के लिए:

• इनपुट के लिए 2, 3यह उत्पन्न करता है:

  ३ ५
  6
  12
  ४ २ १

  ... और उसके बाद जो 3पहले दिखाई देता है 2।

• इनपुट के लिए 9, 6यह उत्पन्न करता है:

  ३ ५ 11 ९ ११
  ६ १०
  12
  24
  48
  १६ 16 ४ २ १

  ... और उसके बाद जो 9पहले दिखाई देता है 6।

यह होशियार हो सकता है और अनुक्रम के भी कम उत्पन्न कर सकता है, लेकिन यह कोड के अधिक बाइट्स ले जाएगा।

Answer 6

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

f=lambda a,b:b<2or[f(a/2,b/2),a>1,0,1<a<=b][a%2+b%2*2]

नील के समान एक पुनरावर्ती समाधान।

Comments

यह कुछ परीक्षण मामलों को गड़बड़ाने के लिए लगता है। यह कहता f(158,158)है कि गलत है और f(2,8)यह सच है।

— 23

@xnor उफ़, अब तय किया जाना चाहिए।

— orlp

यह कहते हैं f(1,5)कि गलत है।

— xnor

मेरा बुरा, मेरा मतलब था कि f(1,5)गलत होना चाहिए, लेकिन कोड सच देता है।

— xnor

@xnor आह, मैं बग को देखा, अब (अच्छा मुझे आशा है) के लिए तय किया। मैं नील के वर्णन के बारे में थोड़ा बहुत शिथिलता से गया।

— orlp

Answer 7

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

OrderedQ[{1,#}&/@#//.{a_,b_/;EvenQ@b}->{2a,b/2}/.{a_,1}->{∞,-a}]&

सकारात्मक पूर्णांक की एक सूची लेने का कार्य करें और Trueयदि सूची शारकोव्स्की के क्रम में आरोही क्रम बनाती है तो वापस लौटती है False। (विशेष रूप से, इनपुट सूची में केवल दो तत्व नहीं हैं - हमें मुफ्त में अतिरिक्त कार्यक्षमता मिलनी चाहिए।)

एल्गोरिथ्म के दिल समारोह है {1,#}&/@#//.{a_,b_/;EvenQ@b}->{2a,b/2}, जो बार-बार 2 के आसपास के कारकों ले जाता है प्रपत्र के एक पूर्णांक कन्वर्ट करने के लिए m*2^k, के साथ m, अजीब आदेश दिया जोड़ी के लिए {2^k,m}(और इनपुट सूची के प्रत्येक तत्व के लिए ऐसा नहीं करता है)। OrderedQफिर यह तय करता है कि आदेशित जोड़े की परिणामी सूची पहले से ही क्रमबद्ध है; डिफ़ॉल्ट रूप से, इसका मतलब है कि पहले तत्व द्वारा ऑर्डर बढ़ाना, फिर दूसरे तत्व द्वारा ऑर्डर बढ़ाना।

ठीक यही हम चाहते हैं, संख्याओं को छोड़कर जो 2 की शक्तियां हैं वे विभिन्न नियमों का पालन करती हैं। इसलिए में जाँच करने से पहले OrderingQ, हम एक अंतिम नियम लागू करते हैं /.{a_,1}->{∞,-a}, जो (उदाहरण के लिए) रूपांतरित {64,1}होता है {∞,-64}; यह क्रम में 2 की शक्तियों को सही स्थान पर रखता है।

Answer 8

हास्केल, 143 138 बाइट्स

मूल रूप से मानदंडों का एक अपेक्षाकृत सीधा कार्यान्वयन:

e n=head[k-1|k<-[0..],n`mod`(2^k)>0]   -- exponent of 2
f n=n`div`2^e n                        -- odd part
a#b|n<-f a,p<-e a,m<-f b,q<-e b=n>1&&(m>1&&p<q||n<m&&p==q||m<2)||n<2&&m<2&&p>q||a==b  

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

Answer 9

पायथन, 159 158 153 144 142 141 बाइट्स

सहेजा एक 2 Kritixi lithos करने के लिए धन्यवाद बाइट्स!

यह मुख्य रूप से सिर्फ मेरे पायथन की गोल्फ प्रैक्टिस करने के लिए है!
सभी चतुर उत्तरों के तरीकों के बजाय ओपी द्वारा दिए गए सूत्र का उपयोग करें

f=lambda a,p=0:(a&1)*(a,p)or f(a>>1,p+1)
t=lambda(n,p),(m,q):(n==1)*(m==1)&(p>=q)or (m>1)&(p<=q)|(n<=m)&(p==q)or m==1
lambda a,b:t(f(a),f(b))

Comments

आप अनावश्यक स्थानों को हटाकर इसे गोल्फ कर सकते हैं: उदाहरण के (a, b)लिए दूसरी पंक्ति पर जहां आप कॉमा और के बीच के स्थान को हटा सकते हैं b।

— कृति लिथोस

Answer 10

एपीएल (डायलाग एक्सटेंडेड) , 27 बाइट्स

1⊃∘⍋⍮⍥{p⍵⍮⍨-⍵⍴⍨⍵=2*p←⊥⍨~⊤⍵}

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

एक टैसिट डियाडिक फ़ंक्शन जिसका बाएं तर्क है aऔर दाईं ओर है b।

दृष्टिकोण xnor के पायथन 2 समाधान के लगभग समान है , जिसमें हम प्रत्येक संख्या को एक नेस्टेड सरणी में परिवर्तित करते हैं और उनके बीच की तुलनात्मकता करते हैं।

भाग 1: संख्या को नेस्टेड सरणी में बदलें

{p⍵⍮⍨-⍵⍴⍨⍵=2*p←⊥⍨~⊤⍵}  ⍝ Input: positive integer N
                  ⊤⍵   ⍝ Convert N to binary digits
                 ~     ⍝ Flip all the bits (1 to 0, 0 to 1)
             p←⊥⍨      ⍝ Count trailing ones and assign it to p
                       ⍝ (maximum power of 2 that divides N)
         ⍵=2*          ⍝ Test if N itself is equal to 2^p
     -⍵⍴⍨              ⍝ If true, create 1-element array containing -N;
                       ⍝ otherwise, an empty array
 p⍵⍮⍨                  ⍝ Form a 2-element nested array;
                       ⍝ 1st element is the above, 2nd is [p, N]

भाग 2: दो नेस्टेड सरणियों की तुलना करें

1⊃∘⍋⍮⍥f  ⍝ Input: A (left) and B (right)
     ⍥f  ⍝ Evaluate f A and f B
    ⍮    ⍝ Create a 2-element nested array [f A, f B]
   ⍋     ⍝ Grade up; indexes of array elements to make it sorted
         ⍝ Here, the result is [0 1] if A ≤ B, [1 0] otherwise
1⊃∘      ⍝ Take the element at index 1 (0-based)

Dfn वाक्य-विन्यास सशर्त वक्तव्यों जैसे {a:x ⋄ b:y ⋄ z}अर्थ का समर्थन करता है if a then x else if b then y else z, लेकिन यह इस मामले में उपयोग करने के लिए बहुत अधिक क्रिया है ।

Answer 11

05AB1E , 14 बाइट्स

ΣxÓs1ǝzDg≠i(]Q

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