रमी अनुक्रम उत्पन्न करें

Question

आपका कार्य रम्मी सीक्वेंस के एक इनपुट nऔर आउटपुट तत्व को लेना है n, एक अनुक्रम जो मैंने बनाया (ओईआईएस को देखकर आपकी मदद नहीं करेगा)।

परिभाषा

रमी अनुक्रम का प्रत्येक तत्व सत्य या मिथ्या मूल्यों का एक समूह है। पूर्व .: [true, false]।

रमी सीक्वेंस के सदस्य बनाने के लिए कदम काफी सरल हैं:

1. पहले सूचकांक से शुरू करें, [](यह तत्व 0 है)।
2. सच करने के लिए सबसे बाईं ओर सेट करें। यदि बदलने के लिए कोई झूठा नहीं है, तो सूची की लंबाई 1 से बढ़ाएं और नई सूची के सभी सदस्यों को गलत तरीके से सेट करें।
3. तत्व तक पहुंचने तक चरण 2 को दोहराएं n।

उदाहरण

आइए हमारे फ़ंक्शन को इस रूप में परिभाषित करें rummy(int n)(सामान {}उत्तर के लिए उठाया गया कदम है):

>>> rummy(5)
{[]}
{[false]}
{[true]}
{[false, false]}
{[true, false]}
[true, true]

नियम

• मानक खामियां लागू होती हैं।
• अपनी भाषा के ऊपरी संख्यात्मक बाउंड के माध्यम से इनपुट 0 के लिए काम करना चाहिए।
• आप किसी भी तरह से फिट होने के लिए आउटपुट कर सकते हैं, बशर्ते कि यह स्पष्ट हो कि आउटपुट सच्चाई / झूठ का एक समूह है।

सामान्य ज्ञान

मैं इसे "रम्मी सीक्वेंस" कहता हूं क्योंकि, इंडेक्स 2 से शुरू होकर, यह उन सेटों को परिभाषित करता है, जिन्हें आपको प्रोग्रेसिव रमी के प्रत्येक राउंड में लेटाने की आवश्यकता होगी , जहां फाल्सी एक पुस्तक है और सत्य एक रन है।

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

>>> rummy(0)
[]

>>> rummy(1)
[false]

>>> rummy(6)
[false, false, false]

>>> rummy(20)
[true, true, true, true, true]

>>> rummy(1000)
[true, true, true, true, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]

Comments

इस में रिवर्स द्विआधारी गिनती की तरह थोड़े है

— ThreeFx

@ThreeFx को छोड़कर, जब जोड़ते 1हैं 11, तो आप 000इसके बजाय प्राप्त करते हैं 100। ; पी

— एडिसन क्रम्प

क्या हमारा जवाब एक-अनुक्रमित हो सकता है?

— डाउनगेट

मुझे लगता है कि आपको कुछ और परीक्षण मामलों को शामिल करना चाहिए, भले ही आउटपुट उदाहरण में स्पष्ट रूप से उल्लिखित हों। मेरा पहला संशोधन कोने के मामले 1 के साथ टूट गया ...

— डेनिस

@VTCAKAVSMoACE यह इसे द्विआधारी द्विआधारी बना देगा (जिसके लिए हमारे पास एक चुनौती भी है), लेकिन इसमें और भी अंतर हैं कि हर नंबर हमेशा फॉर्म का होता है 1*0*।

— मार्टिन एंडर

Answer 1

जावास्क्रिप्ट ईएस 6, 94 92 72 70 66 64 बाइट्स

बच गया 6 बाइट्स नील को धन्यवाद!

n=>[...Array(a=Math.sqrt(8*n+1)-1>>1)].map((_,l)=>l<n-a*(a+1)/2)

मुझे नहीं लगता कि यह अधिक गोल्फ हो सकता है। कम से कम समीकरणों के साथ।

व्याख्या

वे दो मुख्य समीकरण हैं ( nइनपुट है):

(Math.sqrt(8*n+1)-1)/2

यह कुल आकार देगा आउटपुट सरणी को होने की आवश्यकता होगी। मेरे कार्यक्रम में मैं इन के >>1बजाय प्रयोग किया जाता (...)/2है बाइनरी में पहली बिट के रूप में एक ही मूल्य है 2. इसे स्थानांतरित करने में परिणाम होगाfloor(.../2)

---

n-a*(a+1)/2

यह trueवहाँ की राशि है। aपिछली अभिव्यक्ति का परिणाम है।

---

यह सिंटैक्स करता है:

[...Array(n)]

यह कोड एक सरणी उत्पन्न करता है जिसमें [0, n)इस उत्तर में रेंज nपहले समीकरण है।

---

.map((_,l)=>l<n)यह उपरोक्त सीमा के माध्यम से लूप करेगा, lचर में वर्तमान आइटम वाला चर है। यदि आइटम ट्रू की मात्रा से कम है, तो वे (दूसरे समीकरण द्वारा निर्धारित) हैं, तो यह वापस आ जाएगा true, अन्यथा false।

Comments

के >>1बजाय का उपयोग करें /2|0। के (_,l)=>बजाय का उपयोग करें .keys()।

— नील

@ नील धन्यवाद! जिससे काफी बचत हुई। अपने अंतिम बिंदु तक, क्या आप का उपयोग करने का मतलब है Array.from()?, भरें, या कुछ और?

— डाउनगेट

नहीं, मैं सोच रहा था [...Array(a)].map((_,l)=>)जिसके बारे में मेरा मानना ​​है कि यह थोड़ा कम है, लेकिन ()एस में से कुछ को हटाने पर अच्छी पकड़ है >>1, मैं इसे देखा नहीं था!

— नील

ओह, वहाँ भी है a*-~a/2; मुझे नहीं पता कि मैंने इसके बारे में पहले क्यों नहीं सोचा।

— नील

Answer 2

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

f=lambda n,i=0:n>i and f(n+~i,i+1)or[1]*n+[0]*(i-n)

1 और 0 की सूची को आउटपुट करता है।

Answer 3

पायथ, 8 बाइट्स

_@{y/RQy

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

यह तेजी से धीमा है।

स्पष्टीकरण:

_@{y/RQyQQ    implicit Qs at the end, (Q = input)
       yQ     2*Q
    /RQ       divide each number in [0, 1, ..., 2*Q-1] by Q
              this results in a list of Q zeros and Q ones
   y          take all subsets
  {           remove duplicates
 @       Q    take the Qth element
_             print it reversed

Answer 4

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

Ḷṗ2SÞ⁸ị1,0x

चुनौती पोस्ट किए जाने से पहले कोड जेली के नवीनतम संस्करण में काम नहीं करता है, लेकिन इस संस्करण में काम किया , जो चुनौती से पहले है।

संकेत 1-आधारित हैं। इसे ऑनलाइन आज़माएं! (कुछ सेकंड लगते हैं) या एक बार में कई इनपुट सत्यापित करें ।

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

Ḷṗ2SÞ⁸ị1,0x  Main link. Argument: n (integer)

Ḷ            Unlength; yield [0, ..., n - 1].
 ṗ2          Take the second Cartesian power, i.e., generate the array of all
             pairs of elements of [0, ..., n - 1].
   SÞ        Sort the pairs by their sum. The sort is stable, so ties are broken
             by lexicographical order.
     ⁸ị      Retrieve the pair at index n.
       1,0x  Map [a, b] to a copies of 1 and b copies of 0.

Answer 5

05AB1E, 27 बाइट्स

8*>t<;ïÐ>*;¹s-ïD1s׊-0s×JSï

देखूंगा कि क्या मैं इसे कुछ और गोल्फ कर सकता हूं और सुबह एक स्पष्टीकरण जोड़ सकता हूं।

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

Answer 6

जावा, 117 110 बाइट्स

enum B{T,F};B[]r(int n){int i=0,c=0,j=0;while(n>=i)i+=++c;B[]a=new B[c-1];for(;j<n-i+c;)a[j++]=B.T;return a;}

अपना खुद का बूलियन प्रकार बनाया, जिसने मुझे 7bytes बचाने की अनुमति दी

Comments

फिटकरी का वह प्रयोग चतुर है। +1

— Addison Crump

Answer 7

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

a=b=0
exec'a,b=[a-1,b+1,0][a<1:][:2];'*input()
print[1]*b+[0]*a

Ideone पर इसका परीक्षण करें ।

Answer 8

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

j=(2*input()+.25)**.5-.5
print[i/j<j%1for i in range(int(j))]

N = j · (j + 1) / 2 के लिए हल । इनपुट स्टड से लिया गया है।

नमूना उपयोग

$ echo 20 | python rummy-seq.py
[True, True, True, True, True]

$ echo 50 | python rummy-seq.py
[True, True, True, True, True, False, False, False, False]

डेमो ।

Answer 9

एपीएल (डायलॉग एक्सटेंडेड) , 21 बाइट्स ^SBCS

{⍵⌷↑,/(↓0 1↓⍳≥\⍳)¨⍳⍵}

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