अनुक्रमों के प्रतिच्छेदन को प्रिंट करें


9

दृश्यों

आपको चार नंबर अनुक्रम दिए गए हैं, जिनके 1द्वारा क्रमांकित किया गया है 4

  1. OEIS का स्थान 0जब प्राकृतिक संख्याएं बाइनरी में सूचीबद्ध होती हैं। यहाँ एक उदाहरण है कि अनुक्रम की गणना कैसे करें:

     0,1,10,11,100,101,110,111
     ^    ^     ^^  ^    ^
     0    3     78  10   14
    

    अनुक्रम की शुरुआत इस तरह से होती है: 0, 3, 7, 8, 10, 14, 19, 20, 21, 23, 24, 27, 29, 31, 36, 37, 40, 45, 51, ...


  1. OEIS इस क्रम में पहली प्राकृतिक संख्या शामिल है, अगले दो को छोड़ता है, फिर अगले तीन को शामिल करता है, फिर अगले चार को छोड़ता है, और जारी रखता है।

     0, 3, 4, 5, 10, 11, 12, 13, 14, 21, 22, 23, 24, 25, 26, 27, 36, ...
    

  1. OEIS सकारात्मक पूर्णांक जहां दोनों की संख्या 0के और की संख्या 1'नंबर की बाइनरी प्रतिनिधित्व में है की शक्तियों हैं 2

    2, 4, 5, 6, 9, 10, 12, 16, 23, 27, 29, 30, 33, 34, 36, 39,
    

  1. OEIS द हॉफस्टैडर Q क्रम

    a (1) = a (2) = 1;
    a (n) = a (n (n-1)) + a (na (2)) n> 2 के लिए।

    1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6, 8, 8, 8, 10, 9, 10, 11, 11, 12, 12, 12, 12, 16, 14, ...
    

    इस अनुक्रम के बारे में बहुत कम साबित होता है, लेकिन कई अनुभवजन्य परिणाम मौजूद हैं। एक विशेष रूप से महत्वपूर्ण है, और आप मान सकते हैं कि यह पूरी श्रृंखला के लिए मान्य है:

    इस पत्र में पाया गया कि श्रृंखला के तत्वों को पीढ़ियों में बांटा जा सकता है। यदि हम उन्हें 1 पर शुरू करते हैं, तो k वें पीढ़ी में ठीक 2 k तत्व होते हैं। प्रासंगिक संपत्ति यह है कि पीढ़ी k में सभी संख्याएँ पी के -1 और / या k-2 से दो संख्याओं को जोड़कर प्राप्त की जाती हैं , लेकिन पहले की पीढ़ियों से कभी नहीं। आप अनुक्रम में शेष तत्वों पर निचली सीमा लगाने के लिए इसका (और केवल इस) अवलोकन का उपयोग कर सकते हैं।


चुनौती

आपकी चुनौती xदी गई इनपुट अनुक्रमों के प्रतिच्छेदन में पहले नंबरों को प्रिंट करना है ।

इनपुट: एक स्थान से दो नंबर अलग STDIN। पहले नंबर से एक पूर्णांक है 1करने के लिए 15समावेशी जहां एक दृश्य के लिए प्रत्येक बिट मेल खाती है। सबसे कम बिट अनुक्रम से मेल खाती है 1, और उच्चतम अनुक्रम से मेल खाती है 4। दूसरा नंबर है, xआउटपुट करने के लिए STDIN

आउटपुट: पहले xनंबर जो दिए गए इनपुट अनुक्रमों के साथ प्रतिच्छेद करते हैं। STDOUTकिसी भी स्पष्ट व्हाट्सएप या विराम चिह्न के साथ संख्याओं को एक सीमांकक के रूप में प्रिंट करें (रिक्त स्थान, टैब, newlines, कॉमा, कॉलन, अवधि, आदि)।


उदाहरण

1.3 हर क्रम में पहले नंबर को प्रिंट करें ।

इनपुट: 15 3

आउटपुट: 10,23,40


2.12 अनुक्रम संख्या में पहले नंबरों को प्रिंट करें 1और 4

इनपुट: 9 12

आउटपुट: 3,8,10,14,19,20,21,23,24,31,37,40


3. पहले 10नंबरों को क्रमानुसार प्रिंट करें 2

इनपुट: 2 10

आउटपुट: 0,3,4,5,10,11,12,13,14,21


4.6 अनुक्रमों में पहले नंबरों को प्रिंट करें 3और 4

इनपुट: 12 6

आउटपुट: 2,4,5,6,9,10


विवरण

  • आप आउटपुट को प्रिंट कर सकते हैं जैसे ही आप जाते हैं या अंत में एक बार।

चैट में इसके साथ मदद करने वाले सभी लोगों का बहुत-बहुत धन्यवाद! इस सवाल का सैंडबॉक्स में होने से बहुत फायदा हुआ ।


@chilemagic: वास्तव में आप एक चौराहे में "पहले एक्स नंबर" को कैसे परिभाषित करते हैं? यदि आप 12 5उदाहरण में दोनों अनुक्रमों को एक ही अनुक्रमणिका तक ले जाते हैं, तो 10वास्तव 9में चौराहे से पहले आता है ... जैसे, आप अनुक्रमों से गुजरते समय, कैसे तय करेंगे कि 9# 3 को संभावित चौराहे के रूप में छोड़ें ? जैसे अगर # 3 में था 7, तो आपको इसे छोड़ना होगा, क्योंकि यह # 4 में दिखाई नहीं देता है
क्लाउडीयू

@Claudiu आपकी आउटपुट संख्या हमेशा बढ़नी चाहिए, और प्रत्येक संख्या आपके आउटपुट में केवल एक बार दिखाई देगी।
hmatt1

क्या इसकी अधिकतम सीमा है x?
य्प्निपन

@ypnypn हार्ड कोड की एक सीमा नहीं है, लेकिन अगर आपका एल्गोरिथ्म बहुत धीमा है या बहुत बड़े इनपुट के लिए समाप्त नहीं होगा जो ठीक है। यह कोड गोल्फ है इसलिए आप बाइट्स को बचाने के लिए अक्षम हो सकते हैं।
hmatt1

जवाबों:


2

हास्केल, 495 442 402

import Data.List
d=1:1:1%2
f=filter
p 0="0"
p 1="1"
p n=p(div n 2)++p(mod n 2)
l=length
u z[a,b]=sort.head.dropWhile((<b).l)$m(nub.foldl1 intersect.y(tail.p$31-a).(`m`[d,f(v.group.sort.p)[1..],z#1,y(z>>=p)z]).take)z
w=(=='0')
v[a]=1>2
v x=all(all w.tail.p.l)x
y x=m snd.f(w.fst).zip x
x#n=n`take`x++drop(n+n+1)x#(n+2)
n%m=d!!(m-d!!n)+d!!(m-d!!(n-1)):m%(m+1)
main=interact$show.u[0..].m read.words
m=map

यह यथोचित प्रदर्शन करता है। यहाँ ओपी के कुछ उदाहरण दिए गए हैं:

Flonk@home:~>echo 15 10 | codegolf
[10,23,40,57,58,139,147,149,212,228]
Flonk@home:~>echo 9 12 | codegolf
[3,8,10,14,19,20,21,23,24,31,37,40]
Flonk@home:~>echo 2 10 | codegolf
[0,3,4,5,10,11,12,13,14,21]
Flonk@home:~>echo 12 6 | codegolf
[2,4,5,6,9,10]

4

पायथन 3, 590 639 अक्षर

from itertools import count as C
D=lambda n,t='1':bin(n).count(t)
Y=range
def O():
 for n in C(0):yield from bin(n)[2:]
def B():
 s=i=0
 while 1:
  i+=s
  for j in Y(i,i+s+1):yield j
  s+=2;i+=s-1
def s(i):return D(i)==1
def F():
 a=[1]*3
 for n in C(3):a+=[a[n-a[n-1]]+a[n-a[n-2]]];yield a[-1]
L,R=input().split()
J=[x for x,U in zip([F(),(n for n in C(0)if s(D(n,'0')-1)and s(D(n))),B(),(i for i,c in enumerate(O())if'1'>c)],"{0:04b}".format(int(L)))if U>'0']
X=[set()for _ in J]
M=[]
Z=int(R);K=1
while len(M)<Z:
 for x,j in zip(X,J):x.add(next(j))
 for _ in Y(K):X[0].add(next(J[0]));K+=1
 M=X[0]
 for x in X:M=M&x
print(sorted(M)[:Z])

यह सीधे-आगे का समाधान है: प्रत्येक अनंत अनुक्रम को परिभाषित करने के लिए जनरेटर का उपयोग करें, और जब तक कि चौराहे काफी बड़ा न हो, प्रत्येक अनुक्रम में एक कदम जोड़ें।

गैर-मोनोटोनॉली-बढ़ते हॉफस्टैटर अनुक्रम के लिए खाता करने के लिए: प्रत्येक चरण पर मैं उस अनुक्रम के लिए दो बार उत्पन्न करता हूं, जैसे 1, फिर 2, 4, 8, 16, 32, आदि। मुझे लगता है कि प्रश्न में वर्णित सीमा को संतुष्ट करता है। , और यह अभी भी वहाँ प्रस्तुत सभी परीक्षण मामलों के लिए पर्याप्त तेज है।


2
गोल्‍फ: from itertools import count as C-> from itertools import* C=count, def s(i):return D(i)==1-> s=lambda i:D(i)==1(मुझे नहीं लगता कि यह फंक्शन इसे छोटा बनाता है ...), "{0:04b}".format(int(L)))if U>'0'->"{0:04b}".format(int(L)))if'0'<U
जस्टिन

3

सी #, 1923

यह शायद सबसे छोटा कार्यक्रम नहीं होगा, लेकिन मुझे चुनौती दिलचस्प लगी, इसलिए यहां मेरा समाधान है।

35 नंबर (15 35) के साथ सभी 4 दौड़ने में लगभग 5 सेकंड लगते हैं।

आप इसे यहाँ परीक्षण कर सकते हैं , लेकिन ध्यान दें कि यदि आप चाहते हैं कि OEIS4 अंकों की मात्रा जो आप चाहते हैं छोटा होना चाहिए या नेटफिल्ड स्मृति से बाहर चलाता है

golfed

using System;using System.Collections;using System.Collections.Generic;using System.Linq;class p{public static void Main(string[] args){int b=0;IEnumerable<int>a=null;foreach(char c in Convert.ToString(int.Parse(args[0]),2).Reverse()){++b;if(c=='0')continue;switch(b){case 1: a=d(a,e());break;case 2: a=d(a,f());break;case 3: a=d(a,g());break;case 4: a=d(a,h(),true);break;}}if(a==null)return;bool j=true;foreach(int i in a.Take(int.Parse(args[1]))){if(j)j=false;else Console.Write(",");Console.Write(i);}}static IEnumerable<int>d(IEnumerable<int>k,IEnumerable<int>l,bool m=false){if(k==null)foreach(int n in l)yield return n;int o=0;int p=1;foreach(int i in k){Dictionary<int,HashSet<int>>q=m ? new Dictionary<int,HashSet<int>>(): null;int s=0;foreach(int n in l){if(!m){if(i<n)break;}else{if(!q.ContainsKey(o))q.Add(o,new HashSet<int>());q[o].Add(n);if(q.Count==1){int r=q[o].OrderBy(gi =>gi).Take(2).Sum();if(i<r)break;}else{int r=q[o].Concat(q[o-1]).OrderBy(gi =>gi).Take(2).Sum();if(i<r)break;}if(++s==p){o++;p=(int)Math.Pow(2,o);}}if(i==n){yield return i;break;}}}}static IEnumerable<int>e(){int t=0;for(int i=0;i<int.MaxValue;i++)foreach(char c in Convert.ToString(i,2)){if(c=='0')yield return t;t++;}}static IEnumerable<int>f(){int t=1;int u=0;bool v=true;using(IEnumerator<int>w=Enumerable.Range(0,int.MaxValue).GetEnumerator()){while(w.MoveNext()){if(v){if(u==0)u=t+1;yield return w.Current;if(--t==0)v=false;}else{if(t==0)t=u+1;if(--u==0)v=true;}}}}static IEnumerable<int>g(){for(int i=0;i<int.MaxValue;i++){string s=Convert.ToString(i,2);if(x(s.Count(c =>c=='0'))&& x(s.Count(c =>c=='1')))yield return i;}}static bool x(int y){return(y != 0)&&((y &(y-1))==0);}static IEnumerable<int>h(){return Enumerable.Range(1,int.MaxValue).Select(z);}static Dictionary<int,int>_=new Dictionary<int,int>();static int z(int n){int a;if(!_.TryGetValue(n,out a)){if(n<3)a=1;else a=z(n-z(n-1))+z(n-z(n-2));_.Add(n,a);}return a;}}

पठनीय

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

class Programm
{
    public static void Main(string[] args)
    {
        int index = 0;

        IEnumerable<int> intersection = null;

        foreach (char c in Convert.ToString(int.Parse(args[0]), 2).Reverse())
        {
            ++index;
            if (c == '0')
                continue;

            switch (index)
            {
                case 1: intersection = _join(intersection, OEIS1()); break;
                case 2: intersection = _join(intersection, OEIS2()); break;
                case 3: intersection = _join(intersection, OEIS3()); break;
                case 4: intersection = _join(intersection, OEIS4(), true); break;

                default: throw new ArgumentException();
            }
        }
        if (intersection == null)
            return;

        bool first = true;
        foreach (int i in intersection.Take(int.Parse(args[1])))
        {
            if (first) first = false;
            else Console.Write(",");

            Console.Write(i);
        }

        Console.ReadKey();
    }

    private static IEnumerable<int> _join(IEnumerable<int> intersection, IEnumerable<int> newSequence, bool hof = false)
    {
        if (intersection == null)
            foreach (int n in newSequence) yield return n;



        int generation = 0;
        int generationMax = 1;
        foreach (int i in intersection)
        {
            Dictionary<int, HashSet<int>> generationCache = hof ? new Dictionary<int, HashSet<int>>() : null;
            int count = 0;
            foreach (int n in newSequence)
            {
                if (!hof)
                {
                    if (i < n)
                        break;
                }
                else
                {
                    if (!generationCache.ContainsKey(generation))
                        generationCache.Add(generation, new HashSet<int>());

                    generationCache[generation].Add(n);

                    if (generationCache.Count == 1)
                    {
                        int lowerBound = generationCache[generation].OrderBy(gi => gi).Take(2).Sum();
                        if (i < lowerBound)
                            break;
                    }
                    else
                    {
                        int lowerBound = generationCache[generation].Concat(generationCache[generation - 1]).OrderBy(gi => gi).Take(2).Sum();
                        if (i < lowerBound)
                            break;
                    }

                    if (++count == generationMax)
                    {
                        generation++;
                        generationMax = (int)Math.Pow(2, generation);
                    }
                }

                if (i == n)
                {
                    yield return i;
                    break;
                }
            }
        }
    }


    static IEnumerable<int> OEIS1()
    {
        int position = 0;
        for (int i = 0; i < int.MaxValue; i++)
            foreach (char c in Convert.ToString(i, 2))
            {
                if (c == '0')
                    yield return position;
                position++;
            }
    }

    static IEnumerable<int> OEIS2()
    {
        int take = 1;
        int skip = 0;
        bool doTake = true;
        using (IEnumerator<int> enumerator = Enumerable.Range(0, int.MaxValue).GetEnumerator())
        {
            while (enumerator.MoveNext())
            {
                if (doTake)
                {
                    if (skip == 0)
                        skip = take + 1;
                    yield return enumerator.Current;
                    if (--take == 0)
                        doTake = false;
                }
                else
                {
                    if (take == 0)
                        take = skip + 1;
                    if (--skip == 0)
                        doTake = true;
                }
            }
        }
    }

    static IEnumerable<int> OEIS3()
    {
        for (int i = 0; i < int.MaxValue; i++)
        {
            string s = Convert.ToString(i, 2);
            if (_isPowerOfTwo(s.Count(c => c == '0')) && _isPowerOfTwo(s.Count(c => c == '1')))
                yield return i;
        }
    }

    static bool _isPowerOfTwo(int number)
    {
        return (number != 0) && ((number & (number - 1)) == 0);
    }

    static IEnumerable<int> OEIS4()
    {
        return Enumerable.Range(1, int.MaxValue).Select(HofstadterQ);
    }

    static Dictionary<int, int> _hofstadterQCache = new Dictionary<int, int>();

    static int HofstadterQ(int n)
    {
        int result;
        if (!_hofstadterQCache.TryGetValue(n, out result))
        {
            if (n < 3)
                result = 1;
            else
                result = HofstadterQ(n - HofstadterQ(n - 1)) + HofstadterQ(n - HofstadterQ(n - 2));

            _hofstadterQCache.Add(n, result);
        }
        return result;
    }
}

व्याख्या

यह आलसी मूल्यांकन बिगटाइम का उपयोग करता है जो इसे तेजी से i bellieve बनाता है। इसके अलावा, मैं फ्रेमवर्क Convert.ToString (संख्या, 2) विधि का उपयोग करके किसी भी "बिटोग्लिक" कर रहा था। यह किसी भी संख्या को एक स्ट्रिंग के रूप में अपने बिन्रे प्रतिनिधित्व में बदल देता है।

मुझे seuqences को इंटरसेक्ट करने के लिए अपनी विधि लिखनी पड़ी क्योंकि Linq-Method अन्तर्विभाजक पूर्ण अनुक्रम के प्रतिच्छेदन की गणना करता है, और यह सचमुच असंभव था।

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