দৈর্ঘ্যের ম্যাজিক সিকোয়েন্সেস n

Question

একটি ম্যাজিক সিকোয়েন্স হ'ল অ-নেতিবাচক পূর্ণসংখ্যার ক্রম x[0..n-1]যা এর ঠিক x[i]উদাহরণ রয়েছেi

উদাহরণস্বরূপ, 6,2,1,0,0,0,1,0,0,0 একটি যাদু অনুক্রম যেহেতু 6 0, 2, 1 ইত্যাদি রয়েছে।

একটি ফাংশন লিখুন যা এন দেওয়া হয়, দৈর্ঘ্যের সমস্ত যাদু ক্রমগুলি আউটপুট করে

---

প্রোগ্রাম যা 10 সেকেন্ড জয়ের মধ্যে এন এর সর্বোচ্চ মানের জন্য সঠিক আউটপুট তৈরি করতে পারে। (যদিও সমস্ত প্রোগ্রাম স্বাগত জানানো হয়)

উদাহরণস্বরূপ, অ্যালিসের প্রোগ্রামটি 10 ​​সেকেন্ডের মধ্যে এন = 15 পর্যন্ত ডিল করতে পারে যখন বব একই সময়ের মধ্যে এন = 20 পর্যন্ত ডিল করতে পারে। বব জিতল।

প্ল্যাটফর্ম: লিনাক্স 2.7GHz @ 4 সিপিইউ

Comments

পিপিসিজিতে আপনাকে স্বাগতম! এটি একটি দুর্দান্ত চ্যালেঞ্জ, তবে আপনার একটি বিজয়ী মানদণ্ড দরকার। উদাহরণস্বরূপ, আপনি বলতে পারেন যে বিজয়ী হ'ল সংক্ষিপ্ততম প্রোগ্রাম।

— Ypnypn

প্রাসঙ্গিক: স্ব-বর্ণনামূলক সংখ্যা

— Sp3000

উত্তর পোস্ট হওয়ার পরে দয়া করে বিজয়ী মানদণ্ডটি পরিবর্তন করবেন না। এছাড়াও, অন্তত আমার মতে, এটি দ্রুততম কোডের চেয়ে কোড গল্ফ হিসাবে অনেক ভাল ছিল।

— অ্যালেক্স এ।

@xnor আপনি এন এর পূর্ণসংখ্যা পার্টিশন তৈরি করে এবং সেগুলি স্ব-বর্ণনামূলক হতে পারে কিনা তা পরীক্ষা করে শুরু করতে পারেন।

— মার্টিন এন্ডার

n>5সমাধানটি ফর্মের নয়, সবচেয়ে ছোটটি কী [n-4, 2, 1, ..., 0, 0, 1, 0, 0, 0]? আমি সন্ধান করেছি n=20এবং একটিও পাইনি এবং ভাবছি যে আমি কোনও ত্রুটি করছি কিনা।

— xnor

Answer 1

পাইথন, n≈10 ⁸

def magic_sequences(n):
    if n==4:
        return (1, 2, 1, 0),(2, 0, 2, 0) 
    elif n==5:
        return (2, 1, 2, 0, 0),
    elif n>=7:
        return (n-4,2,1)+(0,)*(n-7)+(1,0,0,0),
    else:
        return ()

এটি সেই সত্যটি ব্যবহার করে, যা আমি প্রমাণ করব যে দৈর্ঘ্যের একমাত্র ম্যাজিক ক্রম n:

• [1, 2, 1, 0]এবং [2, 0, 2, 0]জন্যn=4
• [2, 1, 2, 0, 0] জন্য n=5
• [n-4, 2, 1, 0, 0, ..., 0, 0, 1, 0, 0, 0] জন্য n>=7

সুতরাং, কারণ n>=7, কেবলমাত্র একটি বিশাল টিউপল ফিরিয়ে দিতে হবে। আমি প্রায় n=10^8আমার ল্যাপটপে এটি করতে পারি , যা সম্ভবত মেমরির দ্বারা সীমাবদ্ধ; আরও কিছু এবং এটি হিমশীতল। (তালিকার চেয়ে টিপলস ব্যবহারের ধারণার জন্য ট্রাইকোপ্লেক্সকে ধন্যবাদ।) অথবা, যদি কেউ এর পরিবর্তে ননজারো এন্ট্রিগুলির একটি অভিধান মুদ্রণ করতে পারে, তবে জিনোর্মাসের জন্য {0:n-4, 1:2, 2:1, (n-4):1}কেউ এটি করতে পারে n।

আমি স্বতন্ত্রতা প্রমাণ করি n>=7; অন্যগুলি নিষ্ঠুর বল বা কেস ওয়ার্ক দ্বারা পরীক্ষা করা যায়।

এন্ট্রিগুলির যোগফল lহল তালিকার সমস্ত সংখ্যার মোট গণনা, যা এর দৈর্ঘ্য n। তালিকায় l[0]শূন্য রয়েছে এবং তাই n-l[0]ননজারো এন্ট্রি রয়েছে। কিন্তু সংজ্ঞা দ্বারা l[0]অশূন্য হতে হবে অথবা আমরা একটি অসঙ্গতি পেতে, এবং অন্যান্য অশূন্য এন্ট্রি প্রতিটি অন্তত 1. ইতিমধ্যে একটি সমষ্টি জন্য অ্যাকাউন্ট হল l[0] + (n-l[0]-1)*1 = n-1সামগ্রিক যোগফল থেকে বের n। সুতরাং গণনা করা হচ্ছে না l[0], সর্বাধিক এক 2 এবং 2 এর চেয়ে বড় এন্ট্রি থাকতে পারে না।

তবে এর অর্থ হ'ল একমাত্র ননজারো এন্ট্রি l[0], l[1], l[2], and l[l[0]], যার মান সর্বাধিক l[0]এবং একটি অনুমানের পরিমাণ 1,1,2, যা সর্বাধিক যোগফল দেয় l[0]+4। যেহেতু এই যোগফলটি হ'ল nযা কমপক্ষে 7, l[0]>=3তাই আমাদের রয়েছে l[l[0]]=1। এখন, কমপক্ষে একটি আছে 1যার অর্থ l[1]>=1, তবে এটি যদি l[1]==1অন্যটি হয় 1, তবে l[1]>=2বোঝা l[1]যাচ্ছে যে একাকী 2। এটি দেয় l[2]=1, এবং বাকী সমস্ত এন্ট্রি হয় 0, সুতরাং l[0]=n-4, যা সমাধানটি সম্পূর্ণ করে।

Comments

আর ভাষা কি ...?

— edc65

@ edc65 এটি অজগর মত দেখাচ্ছে। কিন্তু আমি নিশ্চিত না.

— ইসমাইল মিগুয়েল

Answer 2

পাইথন 3, n≈40

def plausible_suffix(l,N):
    if sum(l)>N:
        return False

    pairs = [(N-1-i,l[i]) for i in range(len(l))]

    if sum(i*x for i,x in pairs)>N:
        return False

    num_remaining = N - len(l)

    for index, desired_count in pairs:
        count = l.count(index)
        more_needed = desired_count - count
        if more_needed<0: 
            return False
        num_remaining -= more_needed
        if num_remaining<0:
            return False
    return True

plausible_func = plausible_suffix

def generate_magic(N):
    l=[0]
    while l:
        extend = False
        if plausible_func(l,N):
            if len(l)==N:
                yield l[::-1]
            else:
                extend = True
        if extend:
            l.append(0)
        else:
            while l[-1]>=N-2:
                l.pop(-1)
                if not l:raise StopIteration
            l[-1]+=1

n=40 #test parameter

if n>0:
    for x in generate_magic(n):
        print(n,x)

সম্ভাব্য তালিকাগুলির প্রস্থ-প্রথম অনুসন্ধান কি ডান থেকে বামে এন্ট্রি পূরণ করছে, যদি এটি যুক্তিযোগ্য না হয় তবে প্রত্যয়টি অনুসন্ধান বন্ধ করে দেয়, যা ঘটতে পারে:

• প্রত্যয়টিতে প্রবেশের যোগফলকে ছাড়িয়ে গেছে n(পুরো তালিকার যোগফল অবশ্যই হবে n)
• i*l[i]প্রত্যয়টির ওজনযুক্ত যোগফল ছাড়িয়ে গেছে n(পুরো তালিকার যোগফল অবশ্যই হবে n)
• যে কোনও সংখ্যার প্রত্যয়টিতে আরও বেশি বার উপস্থিত হয় যা প্রত্যয়টি বলে যে এটি করা উচিত
• বাকি অসম্পূর্ণ দাগগুলির সংখ্যা যে সমস্ত সংখ্যার জন্য আরও বার প্রদর্শিত হবে তার জন্য অ্যাকাউন্ট খুব কম।

আমার বাম থেকে ডানে মূল পরীক্ষিত উপসর্গ ছিল, তবে এটি আরও ধীরে ধীরে চলেছে went

ফলাফলগুলি হ'ল n=30:

4 [1, 2, 1, 0]
4 [2, 0, 2, 0]
5 [2, 1, 2, 0, 0]
7 [3, 2, 1, 1, 0, 0, 0]
8 [4, 2, 1, 0, 1, 0, 0, 0]
9 [5, 2, 1, 0, 0, 1, 0, 0, 0]
10 [6, 2, 1, 0, 0, 0, 1, 0, 0, 0]
11 [7, 2, 1, 0, 0, 0, 0, 1, 0, 0, 0]
12 [8, 2, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0]
13 [9, 2, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
14 [10, 2, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
15 [11, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
16 [12, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
17 [13, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
18 [14, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
19 [15, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
20 [16, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
21 [17, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
22 [18, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
23 [19, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
24 [20, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
25 [21, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
26 [22, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
27 [23, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
28 [24, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
29 [25, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
30 [26, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]

প্রথম তিনটি তালিকা ব্যতীত [1, 2, 1, 0], [2, 0, 2, 0], [2, 1, 2, 0, 0]প্রতিটি দৈর্ঘ্যের ঠিক একটি তালিকা রয়েছে n>6এবং এটির ফর্ম রয়েছে [n-4, 2, 1, ..., 0, 0, 1, 0, 0, 0]। এই প্যাটার্নটি কমপক্ষে অবধি স্থায়ী n=50। আমি সন্দেহ করি এটি চিরকাল ধরে রেখেছে, এক্ষেত্রে এগুলির একটি বিশাল সংখ্যার আউটপুট দেওয়ার ক্ষেত্রে এটি ক্ষুদ্র। তা না হলেও, সম্ভাব্য সমাধানগুলি সম্পর্কে একটি গাণিতিক বোঝাপড়া একটি অনুসন্ধানকে তীব্রতর করবে।

Comments

@Ypnypn আমি বিশেষায়িত করেছি n=0। আমি মিস করেছি যে আমরা একটি একক জন্য ফলাফল ফিরে করছি n, গণনা না n। এটা আমার উঠে n=40।

— xnor

Answer 3

পাইথ - 15 বাইট

লেন nএবং তারপরে ফিল্টারগুলির সমস্ত সম্ভাব্য ক্রমগুলি দ্বারা ব্রুট ফোর্স ব্যবহার করা হয় ।

f.A.eq/TkYT^UQQ

শীঘ্রই সম্পূর্ণ ব্যাখ্যা আসছে।

এটি এখানে অনলাইনে চেষ্টা করে দেখুন ।

Comments

এফওয়াইআই, ওপি বিজয়ী মানদণ্ডকে দ্রুততম কোডে পরিবর্তন করেছে।

— অ্যালেক্স এ।

বিজয়ী মানদণ্ড নির্বিশেষে, এখানে একটি 3 বাইট গল্ফ রয়েছে: `fqm / TdQT ^ UQQ`

— Jakube

Answer 4

কে, 26 বাইট

{f@&{x~(+/x=)'!#x}'f:!x#x}

মাল্টেসেনের পদ্ধতির মতো, নিষ্ঠুর শক্তি। প্রোগ্রামের কেন্দ্রস্থল একটি ভবিষ্যদ্বাণী যা প্রদত্ত ভেক্টরটি "ম্যাজিক" কিনা তা পরীক্ষা করে:

{x~(+/x=)'!#x}

ইনপুট ভেক্টর ( !#x) হিসাবে যতক্ষণ না একটি আইওটা ভেক্টর তৈরি করুন , প্রতিটি অঙ্কের উপস্থিতি গণনা করুন ( (+/x=)') এবং ফলাফলটিকে ইনপুট ভেক্টর ( x~) এর সাথে তুলনা করুন । যদি কোনও মিল থাকে তবে আপনার ম্যাজিক ক্রম রয়েছে।

দুর্ভাগ্যক্রমে, এই প্রথম ছুরিকাঘাতটি বেশ ধীর বলে মনে হচ্ছে। আমার ল্যাপটপে কোনা ব্যবহার করে পরীক্ষা করাতে n = 7 পরিচালনা করতে 12 সেকেন্ড সময় লাগে। আমার এটিকে আরও একটু চিন্তাভাবনা করা দরকার।