হামিং দূরত্বের অনুক্রমের সংখ্যা গণনা করুন

Question

Hamming দূরত্ব সমান দৈর্ঘ্যের দুটি স্ট্রিং মধ্যে অবস্থানের যা সংশ্লিষ্ট চিহ্ন ভিন্ন সংখ্যা।

দিন Pদৈর্ঘ্যের একটি বাইনারি স্ট্রিং হতে nএবং Tদৈর্ঘ্যের একটি বাইনারি স্ট্রিং হতে 2n-1। আমরা বাম থেকে ডানে ক্রমান্বয়ে এবং প্রতিটি- দৈর্ঘ্যের স্তরগুলির nমধ্যে হামিংয়ের দূরত্বগুলি গণনা করতে Pএবং nএটিকে Tএকটি অ্যারে (বা তালিকা) এ রাখতে পারি।

উদাহরণ হ্যামিং দূরত্ব ক্রম

যাক P = 101এবং T = 01100। এই জুটি থেকে আপনি হ্যামিং দূরত্বের ক্রমটি হলেন 2,2,1।

কার্য

বৃদ্ধির nথেকে শুরু n=1, বাইনারি স্ট্রিং সব সম্ভব জোড়া বিবেচনা Pদৈর্ঘ্যের nএবং Tদৈর্ঘ্য 2n-1। আছে 2**(n+2n-1)এমন জোড়া তাই Hamming দূরত্ব অনেক সিকোয়েন্স। তবে এই সিকোয়েন্সগুলির অনেকগুলি অভিন্ন হবে। কাজটি প্রতিটিটির জন্য কতগুলি পৃথক তার সন্ধান করা n।

আপনার কোডটির মান অনুযায়ী এক নম্বর আউটপুট করা উচিত n।

স্কোর

আপনার স্কোরটি nআমার মেশিনে 5 মিনিটের মধ্যে সর্বোচ্চ কোড পৌঁছায়। সময়টি মোট চলমান সময়ের জন্য, কেবল সেই সময়ের জন্য নয় n।

কে জিতলো

সর্বোচ্চ স্কোর প্রাপ্ত ব্যক্তিটি জিতে যায়। যদি দুই বা ততোধিক লোক একই স্কোর নিয়ে আসে তবে এটিই প্রথম উত্তর যা জিতবে।

উদাহরণ উত্তর

জন্য nথেকে 1থেকে 8অনুকূল উত্তর 2, 9, 48, 297, 2040, 15425, 125232, 1070553।

ভাষা ও গ্রন্থাগার

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

আমার মেশিনের সময়গুলি আমার -৪-বিট মেশিনে চালিত হবে। এটি 8 জিবি র‌্যাম, এএমডি এফএক্স-8350 আট-কোর প্রসেসর এবং র‌্যাডিয়ন এইচডি 4250 সহ একটি স্ট্যান্ডার্ড উবুন্টু ইনস্টল This এর অর্থ এটিও আপনার কোডটি চালাতে সক্ষম হওয়া দরকার।

শীর্ষস্থানীয় উত্তর

• 11 সালে সি ++ feersum দ্বারা। 25 সেকেন্ড
• 11 সালে সি ++ অ্যান্ড্রু এপস্টাইন দ্বারা। 176 সেকেন্ড।
• 10 সালে জাভাস্ক্রিপ্ট নিল দ্বারা। 54 সেকেন্ড।
• 9 মধ্যে Haskell, nimi দ্বারা। 4 মিনিট এবং 59 সেকেন্ড।
• 8 জাভাস্ক্রিপ্ট মধ্যে fəˈnɛtɪk দ্বারা। 10 সেকেন্ড.

Comments

.. কোন উপলভ্য বিনামূল্যে * ভাষা?

— স্টিভি গ্রিফিন

দ্রুততম কোড ? না দ্রুততম-অ্যালগরিদম ? আপনি জানেন, লোকেরা ডার্ক ফাস্ট দোভাষী নিয়ে ভাষার সাথে যেতে পারে এবং সময়ের সাথে একটি উল্লেখযোগ্য পার্থক্য করতে পারে তবে সময়ের জটিলতা সবসময় একই থাকে, তাই এটি কিছুটা এটিকে ন্যায্য করে তোলে।

— ম্যাথু রোহ

সম্পর্কিত।

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

@ সিআইজিএসইজিভি fastest-codeকোড লেভেল অপটিমাইজেশন এবং একটি ভাল অ্যালগরিদম উভয়ের মাধ্যমেই অপ্টিমাইজেশনের জন্য আরও জায়গা ছেড়েছে । সুতরাং আমি মনে করি যে faster-codeএটি চেয়ে ভাল faster-algorithm।

— দাদা

Answer 1

সি ++ 11 (11 বা 12 এ পাওয়া উচিত)

এই মুহূর্তে এটি একক থ্রেডযুক্ত।

সংকলন করতে:

g++ -std=c++11 -O2 -march=native feersum.cpp

#include <iostream>
#include <unordered_set>
#include <vector>
#include <unordered_map>
#include <string.h>

using seq = uint64_t;
using bitvec = uint32_t;
using seqset = std::unordered_set<seq>;
using std::vector;

#define popcount __builtin_popcount
#define MAX_N_BITS 4

bitvec leading(bitvec v, int n) {
    return v & ((1U << n) - 1);
}
bitvec trailing(bitvec v, int n, int total) {
    return v >> (total - n);
}

bitvec maxP(int n) {
    return 1 << (n - 1);  // ~P, ~T symmetry
}

void prefixes(int n, int pre, int P, seqset& p) {
    p.clear();
    for (bitvec pref = 0; pref < (1U << pre); pref++) {
        seq s = 0;
        for (int i = 0; i < pre; i++) {
            seq ham = popcount(trailing(pref, pre - i, pre) ^ leading(P, pre - i));
            s |= ham << i * MAX_N_BITS;
        }
        p.insert(s);
    }
}



vector<seqset> suffixes(int n, int suf, int off) {
    vector<seqset> S(maxP(n));
    for (bitvec P = 0; P < maxP(n); P++) {
        for (bitvec suff = 0; suff < (1U << suf); suff++) {
            seq s = 0;
            for (int i = 0; i < suf; i++) {
                seq ham = popcount(leading(suff, i + 1) ^ trailing(P, i + 1, n));
                s |= ham << (off + i) * MAX_N_BITS;
            }
            S[P].insert(s);
        }
    }
    return S;
}



template<typename T> 
void mids(int n, int npre, int nsuf, int mid, bitvec P, T& S, const seqset& pre) {
    seq mask = (1ULL << (npre + 1) * MAX_N_BITS) - 1;
    for(bitvec m = 0; m < 1U << mid; m++) {
        int pc = popcount(P ^ m);
        if(pc * 2 > n) continue; // symmetry of T -> ~T : replaces x with n - x
        seq s = (seq)pc << npre * MAX_N_BITS;
        for(int i = 0; i < npre; i++)
            s |= (seq)popcount(trailing(P, n - npre + i, n) ^ leading(m, n - npre + i)) << i * MAX_N_BITS;
        for(int i = 0; i < nsuf; i++)
            s |= (seq)popcount(leading(P, mid - 1 - i) ^ trailing(m, mid - 1 - i, mid)) << (npre + 1 + i) * MAX_N_BITS;
        for(seq a: pre)
            S[(s + a) & mask].insert(P | (s + a) << n);
    }
}

uint64_t f(int n) {
    if (n >= 1 << MAX_N_BITS) {
        std::cerr << "n too big";
        exit(1);
    }
    int tlen = 2*n - 1;
    int mid = n;
    int npre = (tlen - mid) / 2;
    if(n>6) --npre;
    int nsuf = tlen - npre - mid;
    seqset preset;
    auto sufs = suffixes(n, nsuf, npre + 1);
    std::unordered_map<seq, std::unordered_set<uint64_t>> premid;
    for(bitvec P = 0; P < maxP(n); P++) {
        prefixes(n, npre, P, preset);
        mids(n, npre, nsuf, mid, P, premid, preset);
    }
    uint64_t ans = 0;
    using counter = uint8_t;
    vector<counter> found((size_t)1 << nsuf * MAX_N_BITS);
    counter iz = 0;
    for(auto& z: premid) {
        ++iz;
        if(!iz) {
            memset(&found[0], 0, found.size() * sizeof(counter));
            ++iz;
        }
        for(auto& pair: z.second) {
            seq s = pair >> n;
            uint64_t count = 0;
            bitvec P = pair & (maxP(n) - 1);
            for(seq t: sufs[P]) {
                seq suff = (s + t) >> (npre + 1) * MAX_N_BITS;
                if (found[suff] != iz) {
                    ++count;
                    found[suff] = iz;
                }
            }
            int middle = int(s >> npre * MAX_N_BITS) & ~(~0U << MAX_N_BITS);
            ans += count << (middle * 2 != n);
        }
    }

    return ans;
}

int main() {
    for (int i = 1; ; i++)
        std::cout << i << ' ' << f(i) << std::endl;
}

Comments

30 সেকেন্ডেরও কম সময়ে 11 এ চলে যান!

যদি এটি আগ্রহী হয়:feersum.cpp:111:61: warning: shifting a negative signed value is undefined [-Wshift-negative-value] int middle = int(s >> npre * MAX_N_BITS) & ~(~0 << MAX_N_BITS);

Answer 2

হাস্কেল, স্কোর 9

import Data.Bits
import Data.List
import qualified Data.IntSet as S

main = mapM_ (print . S.size . S.fromList . hd) [1..9]

hd :: Int -> [Int]
hd n = [foldl' (\s e->s*m+e) 0 [popCount $ xor p (shiftR t i .&. m)|i<-[(0::Int)..n-1]] | let m=2^n-1,p<-[(0::Int)..2^n-1],t<-[(0::Int)..2^(2*n-1)-1]]

সংকলন -O3। এটি চালাতে আমার 6 বছরের পুরানো ল্যাপটপ হার্ডওয়্যারটিতে 6min35s সময় লাগে n=9, সুতরাং এটি সম্ভবত রেফারেন্স হার্ডওয়্যারের 5 মিনিটের নিচে।

> time ./113785
2
9
48
297
2040
15425
125232
1070553
9530752

real  6m35.763s
user  6m27.690s
sys   0m5.025s

Comments

6 বছরের ল্যাপটপ? ধিক্কার, এটি কিছু পুরানো প্রযুক্তি!

— ম্যাথু রোহ

@ সিআইজিএসইজিভি: সম্ভবত এটি পুরানো, তবে হামিং দূরত্বের অনুক্রমের সংখ্যা গণনা করার পাশাপাশি এটি তার কাজটি বেশ ভালভাবে সম্পাদন করে।

— নিমি

Answer 3

জাভাস্ক্রিপ্ট, স্কোর 10

findHamming = m => { 
    if (m < 2) return 2;
    let popcnt = x => x && (x & 1) + popcnt(x >> 1);
    let a = [...Array(1 << m)].map((_,i) => popcnt(i));
    let t = 0;
    let n = (1 << m) - 1;
    for (let c = 0; c <= m; c++) {
        for (let g = 0; g <= c; g++) {
            let s = new Set;
            for (let i = 1 << m; i--; ) {
                for (let j = 1 << (m - 1); j--; ) {
                    if (a[i ^ j + j] != c) continue;
                    for (let k = 1 << m - 1; k--; ) {
                        if (a[i ^ k] != g) continue;
                        let f = j << m | k;
                        let h = 0;
                        for (l = m - 1; --l; ) h = h * (m + 1) + a[i ^ f >> l & n];
                        s.add(h);
                    }
                }
            }
            t += s.size * (g < c ? 2 : 1);
        }
    }
    return t;
};
let d = Date.now(); for (let m = 1; m < 11; m++) console.log(m, findHamming(m), Date.now() - d);

ব্যাখ্যা: গণনা n=10করা শক্ত কারণ এখানে দুই বিলিয়ন জুড়ি এবং 26 বিলিয়ন এরও বেশি সম্ভাব্য সিকোয়েন্স রয়েছে। জিনিসগুলিকে গতি বাড়ানোর জন্য আমি গণনাটি 121 টি ভাগে বিভক্ত করেছি। কারণ ক্রমগুলি বিটওয়াইজ পরিপূরকগুলির অধীনে আক্রমণকারী, আমি সাধারণতার ক্ষতি ছাড়াই ধরে নিতে পারি যে মাঝের বিটটি Tশূন্য। এর মানে হল যে আমি ক্রমের প্রথম এবং শেষ উপাদানগুলি উপরের n-1এবং নীচের n-1বিটগুলি থেকে স্বাধীনভাবে নির্ধারণ করতে পারিT। প্রতিটি বিন প্রথম এবং শেষ উপাদানগুলির একটি পৃথক জুটির সাথে মিল রাখে; আমি তারপরে উপরের এবং নীচে বিটের সমস্ত সম্ভাব্য সেটগুলি লুপ করব যা প্রতিটি বিনের সাথে মিলে যায় এবং সিকোয়েন্সের অবশিষ্ট উপাদানগুলি গণনা করে অবশেষে প্রতিটি বিনের জন্য স্বতন্ত্র সিকোয়েন্সগুলি গণনা করে। এটি তখন সমস্ত 121 টি বিনের বাকী রয়েছে। মূলত 45 ঘন্টা সময় নিচ্ছে, এটি এখন আমার এএমডি এফএক্স-8120 এ সাড়ে তিন মিনিটের নিচে সামান্য সময়ে সম্পন্ন হয়েছে। সম্পাদনা: 50% স্পিডআপের জন্য @ ক্রিশ্চিয়ানসিভারকে ধন্যবাদ। সম্পূর্ণ আউটপুট:

1 2 0
2 9 1
3 48 1
4 297 2
5 2040 7
6 15425 45
7 125232 391
8 1070553 1844
9 9530752 15364
10 86526701 153699

Comments

আপনার কোডটি বর্তমানে কোনও আউটপুট দেয় না।

— ফেলিপা

@ ফিলিপা আপনার অর্থ কী তা নিশ্চিত নয়। এটি একটি বেনামি ফাংশন, সুতরাং আপনি এটিকে কল করুন (সম্ভবত এটি প্রথমে কোনও ভেরিয়েবলকে অর্পণ করে এবং তারপরে ভেরিয়েবলটিকে কল করে যেমন এটি কোনও ফাংশন) এবং এটি nএকটি প্যারামিটার হিসাবে পাস করে । (সেখানে প্যারামিটার নামের খারাপ পছন্দ করার জন্য দুঃখিত।)

— নীল

প্রশ্নটি এমন কোডের জন্য জিজ্ঞাসা করে যা 5 মিনিটের মধ্যে পেতে পারে এমন সর্বোচ্চ মানের এন এর জন্য উত্তর মুদ্রণ করে। "আপনার কোডে এন এর মান অনুসারে একটি সংখ্যা আউটপুট করা উচিত" "

— ফেলিপা

আপনার কোড যদি এন = 1 থেকে কাজ করে এবং প্রতিটি পর্যায়ে সময় নির্ধারণ করে তবে এটি দুর্দান্ত। প্রশ্নটি থেকে "সময়টি মোট চলমান সময়ের জন্য, সময়টি কেবলমাত্র সেই এন এর জন্য নয়" "

@ ললেবিক টাইমিং কোড যুক্ত করেছেন এবং বাগের জন্যও কাজ করেছিলেন n=1(কেন এটি স্তব্ধ হয়ে যায় তা জানেন না)।

— নীল

Answer 4

সি ++, স্কোর 10 11

এটি কিছু সরল সমান্তরালতার সাথে @ নীলের উত্তরটিকে সি ++ তে অনুবাদ করুন। আমার 2015 ম্যাকবুক প্রোতে n=90.4 সেকেন্ডে n=10এবং 4.5 সেকেন্ডের n=11মধ্যে এবং প্রায় 1 মিনিটে সম্পূর্ণ হয়। এছাড়াও, ক্রিশ্চিয়ন্সসিভারকে ধন্যবাদ। @ নীলের উত্তরে তার মন্তব্যের কারণে আমি কিছু অতিরিক্ত প্রতিসাম্য লক্ষ্য করেছি। আসল 121 বালতি (থেকে n=10) থেকে 66 টি বালতি যখন বিপরীতের জন্য হিসাব করে, আমি কেবল 21 বালতিতে নেমে এসেছি।

#include <iostream>
#include <cstdint>
#include <unordered_set>
#include <thread>
#include <future>
#include <vector>

using namespace std;

constexpr uint32_t popcnt( uint32_t v ) {
    uint32_t c = v - ( ( v >> 1 ) & 0x55555555 );
    c = ( ( c >> 2 ) & 0x33333333 ) + ( c & 0x33333333 );
    c = ( ( c >> 4 ) + c ) & 0x0F0F0F0F;
    c = ( ( c >> 8 ) + c ) & 0x00FF00FF;
    c = ( ( c >> 16 ) + c ) & 0x0000FFFF;
    return c;
}

template<uint32_t N>
struct A {
    constexpr A() : arr() {
        for( auto i = 0; i != N; ++i ) {
            arr[i] = popcnt( i );
        }
    }
    uint8_t arr[N];
};

uint32_t n = ( 1 << M ) - 1;
constexpr auto a = A < 1 << M > ();

uint32_t work( uint32_t c, uint32_t g, uint32_t mult ) {
    unordered_set<uint64_t> s;
    // Empirically derived "optimal" value
    s.reserve( static_cast<uint32_t>( pow( 5, M ) ) );

    for( int i = ( 1 << M ) - 1; i >= 0; i-- ) {
        for( uint32_t j = 1 << ( M - 1 ); j--; ) {
            if( a.arr[i ^ j + j] != c ) {
                continue;
            }

            for( uint32_t k = 1 << ( M - 1 ); k--; ) {
                if( a.arr[i ^ k] != g ) {
                    continue;
                }

                uint64_t f = j << M | k;
                uint64_t h = 0;

                for( uint32_t l = M - 1; --l; ) {
                    h = h * ( M + 1 ) + a.arr[i ^ ( f >> l & n )];
                }

                s.insert( h );
            }
        }
    }

    return s.size() * mult;

}

int main() {
    auto t1 = std::chrono::high_resolution_clock::now();

    if( M == 1 ) {
        auto t2 = std::chrono::high_resolution_clock::now();
        auto seconds = chrono::duration_cast<chrono::milliseconds>( t2 - t1 ).count() / 1000.0;
        cout << M << ": " << 2 << ", " << seconds << endl;
        return 0;
    }

    uint64_t t = 0;
    vector<future<uint32_t>> my_vector;

    if( ( M & 1 ) == 0 ) {
        for( uint32_t c = 0; c <= M / 2; ++c ) {
            for( uint32_t g = c; g <= M / 2; ++g ) {
                uint32_t mult = 8;

                if( c == M / 2 && g == M / 2 ) {
                    mult = 1;
                } else if( g == c || g == M / 2 ) {
                    mult = 4;
                }

                my_vector.push_back( async( work, c, g, mult ) );
            }

        }

        for( auto && f : my_vector ) {
            t += f.get();
        }

    } else {
        for( uint32_t c = 0; c <= ( M - 1 ) / 2; ++c ) {
            for( uint32_t g = c; g <= M - c; ++g ) {
                uint32_t mult = 4;

                if( g == c || g + c == M ) {
                    mult = 2;
                }

                my_vector.push_back( async( work, c, g, mult ) );
            }

        }

        for( auto && f : my_vector ) {
            t += f.get();
        }

    }

    auto t2 = std::chrono::high_resolution_clock::now();
    auto seconds = chrono::duration_cast<chrono::milliseconds>( t2 - t1 ).count() / 1000.0;
    cout << M << ": " << t << ", " << seconds << endl;
    return 0;
}

কোডটি কার্যকর করতে নিম্নলিখিত স্ক্রিপ্টটি ব্যবহার করুন:

#!/usr/bin/env bash

for i in {1..10}
do
    clang++ -std=c++14 -march=native -mtune=native -Ofast -fno-exceptions -DM=$i hamming3.cpp -o hamming
    ./hamming
done

ফলাফলটি নিম্নরূপ ছিল: (বিন্যাসটি হ'ল M: result, seconds)

1: 2, 0
2: 9, 0
3: 48, 0
4: 297, 0
5: 2040, 0
6: 15425, 0.001
7: 125232, 0.004
8: 1070553, 0.029
9: 9530752, 0.419
10: 86526701, 4.459
11: 800164636, 58.865

n=12 একক থ্রেডে গণনা করতে 42 মিনিট সময় নিয়েছে এবং 7368225813 এর ফলাফল দিয়েছে।

Comments

আপনি কীভাবে ঝাঁকুনি ব্যবহার করে উবুন্টুতে এটি সংকলন করবেন?

— ফেলিপা

@ ফিলিপা আমি মনে করি উত্তরটি আছে sudo apt-get install libiomp-dev।

আপনার কোড যদি এন = 1 থেকে কাজ করে এবং প্রতিটি পর্যায়ে সময় নির্ধারণ করে তবে এটি দুর্দান্ত। প্রশ্নটি থেকে "সময়টি মোট চলমান সময়ের জন্য, সময়টি কেবলমাত্র সেই এন এর জন্য নয়" "

এটি পুনরায় সংশোধন করার পরিবর্তে আপনি সম্ভবত ব্যবহার করতে পারেন __builtin_popcount।

— নীল

@ ল্যাম্বিক: আমি আজকের পরে এই পরিবর্তনগুলি করব। @ নীল: পপকন্টের ক্রিয়াকলাপটি কেবল সংকলনের সময়ে মূল্যায়ন করা হয় এবং আমি কীভাবে __builtin_popcountকনটেক্সট প্রসঙ্গে ব্যবহার করতে পারি তা জানি না । আমি নির্বাক বাস্তবায়নের সাথে যেতে পারি এবং এটি রান সময়কে প্রভাবিত করবে না।

— অ্যান্ড্রু এপস্টাইন

Answer 5

জাভাস্ক্রিপ্ট 2,9,48,297,2040,15425,125232,1070553,9530752

কনসোল চালান:

console.time("test");
h=(w,x,y,z)=>{retVal=0;while(x||y){if(x%2!=y%2)retVal++;x>>=1;y>>=1}return retVal*Math.pow(w+1,z)};
sum=(x,y)=>x+y;
for(input=1;input<10;input++){
  hammings=new Array(Math.pow(input+1,input));
  for(i=1<<(input-1);i<1<<input;i++){
    for(j=0;j<1<<(2*input);j++){
      hamming=0;
      for(k=0;k<input;k++){
        hamming+=(h(input,(j>>k)%(1<<input),i,k));
      }
      hammings[hamming]=1;
    }
  }
  console.log(hammings.reduce(sum));
}
console.timeEnd("test");

এটি অনলাইন চেষ্টা করুন!

বা স্ট্যাক স্নিপেট হিসাবে:

h=(w,x,y,z)=>{retVal=0;while(x||y){if(x%2!=y%2)retVal++;x>>=1;y>>=1}return retVal*Math.pow(w+1,z)};

function findHamming() {
  console.time("test");
  input = parseInt(document.getElementById("input").value);
  hammings=new Array(Math.pow(input+1,input));
  for(i=1<<(input-1);i<1<<input;i++){
    for(j=0;j<1<<(2*input);j++){
      hamming=0;
      for(k=0;k<input;k++){
        hamming+=(h(input,(j>>k)%(1<<input),i,k));
      }
      hammings[hamming]=1;
    }
  }
  document.getElementById("output").innerHTML = hammings.reduce((x,y)=>x+y);
  console.timeEnd("test");
}

<input type="text" id="input" value="6">
<button onclick="findHamming()"> Run </button>
<pre id="output">

কোডটি অ্যারেতে আরও দ্রুত 1s যোগ করার জন্য অ্যারেটিকে পূর্বনির্ধারিত করে

কোডটি সমস্ত হামিং দূরত্বের ক্রমগুলি খুঁজে বের করে এবং তাদেরকে সংখ্যা বেস (ইনপুট + 1) হিসাবে বিবেচনা করে, 1 এসিকে অ্যারেতে রাখার জন্য তাদের ব্যবহার করে। ফলস্বরূপ, এটি n 1s সহ একটি অ্যারে উত্পন্ন করে যেখানে এন অনন্য হামিং দূরত্বের ক্রমগুলির সংখ্যা। অবশেষে, অ্যারের সমস্ত মান যোগ করতে অ্যারে.রেডস () ব্যবহার করে 1s এর সংখ্যা গণনা করা হয়।

এই কোডটি 10 ​​এর ইনপুটটির জন্য চালাতে সক্ষম হবে না কারণ এটি মেমরির সীমাটিকে হিট করে

এই কোডটি ও (2 ^ 2n) সময়ে চলে কারণ এটি কতগুলি উপাদান উত্পন্ন করে।

Comments

আশ্চর্যজনকভাবে, 26 * 10 ^ 9 উপাদান অ্যারে তৈরি করার চেষ্টা করা কাজ করে না

— f 24nɛtɪk

n = 9node.js ব্যবহার করে আমার জন্য 5 মিনিট 30 সেকেন্ড সময় লাগে তাই খুব ধীর।

@ ল্যাম্বিক n = 8মূলত আমার পিসিতে 24 সেকেন্ড সময় নিয়েছিল তবে আমি কোডটি অপ্টিমাইজ করতে সক্ষম হয়েছি যাতে এটি n = 86 সেকেন্ড সময় নিয়েছিল। আমি তখন চেষ্টা করেছি n = 9এবং এটি 100 সেকেন্ড সময় নিয়েছে।

— নীল

@ নীল আপনার উত্তর জমা দেওয়া উচিত!

আপনার কোড যদি এন = 1 থেকে কাজ করে এবং প্রতিটি পর্যায়ে সময় নির্ধারণ করে তবে এটি দুর্দান্ত। প্রশ্নটি থেকে "সময়টি মোট চলমান সময়ের জন্য, সময়টি কেবলমাত্র সেই এন এর জন্য নয়" "