অনুক্রমের ছেদটি মুদ্রণ করুন


9

সিকোয়েন্স

আপনাকে চার নম্বর সিকোয়েন্স দেওয়া হবে, এর 1মাধ্যমে নম্বরযুক্ত 4

  1. OEIS0 প্রাকৃতিক সংখ্যা বাইনারি তালিকাভুক্ত করা হয় যখন এর অবস্থান । ক্রমটি কীভাবে গণনা করা যায় তার একটি উদাহরণ এখানে:

     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. ওআইআইএস এই ক্রমটিতে প্রথম প্রাকৃতিক সংখ্যা অন্তর্ভুক্ত রয়েছে, পরের দুটিটিকে বাদ দেওয়া হবে, তারপরে পরবর্তী তিনটি অন্তর্ভুক্ত করুন, তারপরে পরবর্তী চারটি এড়িয়ে যান এবং অবিরত থাকবে।

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

  1. OEIS ধনাত্মক পূর্ণসংখ্যা যেখানে উভয় সংখ্যা 0's এবং সংখ্যা 1' সংখ্যা বাইনারি প্রতিনিধিত্ব s এর ক্ষমতা আছে 2

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

  1. ওইআইএস দ্য হফস্ট্যাটার কিউ সিকোয়েন্স

    a (1) = a (2) = 1;
    a (n) = a (না (এন -1)) + এ (না (এন -2)) এন> 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 কে উপাদান রয়েছে। প্রাসঙ্গিক সম্পত্তি হ'ল প্রজন্মের কে-তে সমস্ত সংখ্যার প্রজন্মের কে -1 এবং / অথবা কে -2 থেকে দুটি সংখ্যার যোগফল অর্জন করা হয় , তবে আগের প্রজন্ম থেকে কখনও হয় না। অনুক্রমের বাকী উপাদানগুলিতে নিম্ন সীমাবদ্ধ রাখতে আপনি এটি (এবং এটি কেবলমাত্র) পর্যবেক্ষণটি ব্যবহার করতে পারেন।


চ্যালেঞ্জ

আপনার চ্যালেঞ্জটি হ'ল xপ্রদত্ত ইনপুট সিকোয়েন্সগুলি ছেদ করে প্রথম সংখ্যাগুলি মুদ্রণ করা ।

ইনপুট: দুটি সংখ্যা পৃথক পৃথক স্থান দ্বারা পৃথক করা STDIN। প্রথম সংখ্যা থেকে একটি পূর্ণসংখ্যা 1থেকে 15সমেত যেখানে একটা ক্রম প্রতিটি বিট অনুরূপ। নিম্নতম বিটটি সিকোয়েন্সের সাথে মিলে যায় 1এবং সর্বাধিক সিকোয়েন্সের সাথে মিল রয়েছে 4। দ্বিতীয়টি হ'ল সংখ্যার পরিমাণ x, আউটপুট চালু করতে STDIN

আউটপুট:x প্রদত্ত ইনপুট অনুক্রমের সাথে ছেদ করা প্রথম সংখ্যা। STDOUTকোনও স্পষ্ট শ্বেতক্ষেত্র বা বিরামচিহ্নের সাথে একটি ডিলিমিটার (স্পেস, ট্যাব, নিউলাইনস, কমা, কলোন, পিরিয়ড ইত্যাদি) হিসাবে মুদ্রণ করুন ।


উদাহরণ

1.3 প্রতিটি অনুক্রমের মধ্যে প্রথম সংখ্যা মুদ্রণ করুন ।

ইনপুট: 15 3

আউটপুট: 10,23,40


২.12 সিক্যুয়েন্স সংখ্যা 1এবং প্রথম সংখ্যা মুদ্রণ করুন 4

ইনপুট: 9 12

আউটপুট: 3,8,10,14,19,20,21,23,24,31,37,40


৩.10 ধারাবাহিকতায় প্রথম সংখ্যা মুদ্রণ করুন 2

ইনপুট: 2 10

আউটপুট: 0,3,4,5,10,11,12,13,14,21


৪. প্রথম 6সংখ্যাটি সিকোয়েন্সে মুদ্রণ করুন 3এবং 4

ইনপুট: 12 6

আউটপুট: 2,4,5,6,9,10


বিস্তারিত

  • আপনি যেতে যেতে আউটপুট মুদ্রণ করতে পারেন বা সব শেষে একবারে।

চ্যাটে এর সাথে যারা সাহায্য করেছেন তাদের প্রত্যেককে প্রচুর ধন্যবাদ! এই প্রশ্নটি স্যান্ডবক্সে থাকা থেকে অনেক উপকৃত হয়েছিল ।


@ চিলেমাজিক: আসলে আপনি কোন ছেদে "প্রথম এক্স সংখ্যা" সংজ্ঞা দেবেন কীভাবে? আপনি যদি 12 5একই সূচী পর্যন্ত উদাহরণে উভয় ধারাবাহিকতা গ্রহণ 10করেন , তবে সত্যিকার অর্থে 9ছেদ আসার আগেই আসবে ... যেমন, আপনি কীভাবে সিকোয়েন্সগুলি অতিক্রম করার সময় সিদ্ধান্ত নেবেন যে 9সম্ভাব্য ছেদ হিসাবে # 3 এ এড়িয়ে যাবেন কিনা ? # 3 এর 7মধ্যে যদি এটি থাকে তবে আপনি এটি এড়িয়ে যেতে হবে যেহেতু এটি # 4-এ প্রদর্শিত হয় না
ক্লাডিউ

@ ক্লাডিউ আপনার আউটপুটযুক্ত সংখ্যা সর্বদা বৃদ্ধি পাবে এবং প্রতিটি সংখ্যা কেবল একবার আপনার আউটপুটে প্রদর্শিত হবে।
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, ইত্যাদি I আমি মনে করি যে প্রশ্নটিতে বর্ণিত সীমাটি সন্তুষ্ট করে , এবং এটি সেখানে উপস্থাপিত সমস্ত পরীক্ষার ক্ষেত্রে এখনও যথেষ্ট দ্রুত।


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 সেকেন্ড সময় লাগে।

আপনি এটি এখানে পরীক্ষা করতে পারেন তবে নোট করুন যে আপনি যদি ওইআইএস 4 চান তবে আপনার যে পরিমাণে অঙ্ক চান তা ছোট বা নেটফিডাল মেমরির বাইরে চলে যায়।

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;
    }
}

ব্যাখ্যা

এটি অলস মূল্যায়নের বিগটাইম ব্যবহার করে যা এটি দ্রুত বেলিং করে তোলে। এছাড়াও আমি ফ্রেমওয়ার্ক কনভার্ট.টোস্ট্রিং (সংখ্যা, 2) পদ্ধতি ব্যবহার করে কোনও "বিটলজিক" করতে অলস ছিলাম। এটি যে কোনও সংখ্যাকে স্ট্রিং হিসাবে তার বাইনরে উপস্থাপনায় পরিণত করে।

লিনক-পদ্ধতি ছেদটি সম্পূর্ণ অনুক্রমের ছেদকে গণনা করায় আমাকে নিজের পাঠ্যসূচিগুলি ছেদ করার জন্য নিজস্ব পদ্ধতি লিখতে হয়েছিল এবং এটি আক্ষরিকভাবে অসম্ভব ছিল।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.