নেস্টেড লুপগুলির আরও দ্রুত বিকল্প?

Question 1

আমার সংখ্যার সংমিশ্রনের একটি তালিকা তৈরি করা দরকার। সংখ্যার বেশ ছোট, তাই আমি ব্যবহার করতে পারেন byteবদলে int। তবে প্রতিটি সম্ভাব্য সংমিশ্রণ পেতে এর জন্য অনেক নেস্টেড লুপ প্রয়োজন। আমি ভাবছি যে আমার পরে যা করার আরও কার্যকর উপায় আছে কিনা। এখন পর্যন্ত কোডটি হ'ল:

var data = new List<byte[]>();
for (byte a = 0; a < 2; a++)
for (byte b = 0; b < 3; b++)
for (byte c = 0; c < 4; c++)
for (byte d = 0; d < 3; d++)
for (byte e = 0; e < 4; e++)
for (byte f = 0; f < 3; f++)
for (byte g = 0; g < 3; g++)
for (byte h = 0; h < 4; h++)
for (byte i = 0; i < 2; i++)
for (byte j = 0; j < 4; j++)
for (byte k = 0; k < 4; k++)
for (byte l = 0; l < 3; l++)
for (byte m = 0; m < 4; m++)
{
    data.Add(new [] {a, b, c, d, e, f, g, h, i, j, k, l, m});
}

আমি এর মতো কিছু ব্যবহার করার BitArrayকথা ভাবছিলাম তবে আমি কীভাবে এটি যুক্ত করতে পারি তা নিশ্চিত নই।

যে কোনও সুপারিশ প্রশংসিত হবে। বিকল্পভাবে, সম্ভবত এটি আমি যা চাই তা করার দ্রুততম উপায়?

দ্রুত পয়েন্টগুলির যুগল সম্পাদনা করুন (এবং ক্ষমাপ্রার্থী আমি এগুলি মূল পোস্টে রাখি না):

তাদের সংখ্যা এবং ক্রম (2, 3, 4, 3, 4, 3, 3 ইত্যাদি) খুব গুরুত্বপূর্ণ, সুতরাং লিনকিউ ব্যবহার করে পারমুটেশন জেনারেট করার মতো সমাধান ব্যবহার করা উপকারে আসবে না কারণ প্রতিটি 'কলামে' সর্বাধিক হয় বিভিন্ন
আমি গণিতবিদ নই, তাই আমি যদি 'ক্রমীকরণ' এবং 'সংমিশ্রণের' মতো প্রযুক্তিগত পদটি সঠিকভাবে ব্যবহার না করি তবে আমি ক্ষমা চাইছি :)
আমি না আমি শুধু একটা দখল করতে পারবে না বা অন্য একটি সূচক উপর ভিত্তি করে - একবারে এই সমাহারের সব পূরণ করতে প্রয়োজন
ব্যবহার byteকরা ব্যবহারের চেয়ে দ্রুততর int, আমি এটির গ্যারান্টি দিচ্ছি । ইনটগুলির চেয়ে 67 মিটার + অ্যারে বাইট থাকা মেমরির ব্যবহারে এটি আরও অনেক ভাল
আমার চূড়ান্ত লক্ষ্য এখানে নেস্টেড লুপগুলির জন্য একটি দ্রুত বিকল্পের সন্ধান করা।
আমি সমান্তরাল প্রোগ্রামিং ব্যবহার করে বিবেচনা করেছি, তবে আমি যা অর্জন করতে চাইছি তার পুনরাবৃত্ত প্রকৃতির কারণে, আমি এটি সফলভাবে করার জন্য কোনও উপায় খুঁজে পাইনি (এমনকি ConcurrentBag) - তবে আমি ভুল প্রমাণিত হতে পেরে আনন্দিত :)

উপসংহার

ক্যারামিরিল একটি ভাল মাইক্রো-অপ্টিমাইজেশন সরবরাহ করেছে যা লুপগুলি থেকে কিছুটা সময় শেভ করে, তাই আমি সেই উত্তরটিকে সঠিক হিসাবে চিহ্নিত করেছি। এরিক আরও উল্লেখ করেছেন যে তালিকাটি প্রাক-বরাদ্দ করা আরও দ্রুত। তবে, এই পর্যায়ে দেখে মনে হচ্ছে নেস্টেড লুপগুলি আসলে এটি করার দ্রুততম উপায় (হতাশাজনক, আমি জানি!)।

আমি ঠিক কী দিয়ে আমি বেঞ্চমার্ক করার চেষ্টা করছিলাম তা চেষ্টা করতে StopWatchচাইলে প্রতিটি লুপের 4 টি পর্যন্ত 13 টি লুপ গণনা করুন - যা তালিকায় প্রায় 67 মিটার + লাইন তৈরি করে। আমার মেশিনে (i5-3320M 2.6GHz) অপটিমাইজড সংস্করণটি করতে প্রায় 2.2 সেকেন্ড লাগে।

Question 2

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

আপনি একটি কাঠামোর বৈশিষ্ট্যগুলি ব্যবহার করতে পারেন এবং কাঠামোটি আগেই বরাদ্দ করতে পারেন। আমি নীচের নমুনায় কিছু স্তর কেটেছি, তবে আমি নিশ্চিত যে আপনি নির্দিষ্টকরণগুলি বের করতে সক্ষম হবেন। আসল (রিলিজ মোড) এর চেয়ে প্রায় 5-6 গুণ দ্রুত গতিতে চলে।

বাধা:

struct ByteBlock
{
    public byte A;
    public byte B;
    public byte C;
    public byte D;
    public byte E;
}

লুপ:

var data = new ByteBlock[2*3*4*3*4];
var counter = 0;

var bytes = new ByteBlock();

for (byte a = 0; a < 2; a++)
{
    bytes.A = a;
    for (byte b = 0; b < 3; b++)
    {
        bytes.B = b;
        for (byte c = 0; c < 4; c++)
        {
            bytes.C = c;
            for (byte d = 0; d < 3; d++)
            {
                bytes.D = d;
                for (byte e = 0; e < 4; e++)
                {
                    bytes.E = e;
                    data[counter++] = bytes;
                }
            }
        }
    }
}

এটি দ্রুততর কারণ এটি প্রতিবার তালিকায় যুক্ত করে কোনও নতুন তালিকা বরাদ্দ করে না। এছাড়াও যেহেতু এটি এই তালিকাটি তৈরি করছে, এর জন্য প্রতিটি অন্যান্য মান (a, b, c, d, e) এর একটি রেফারেন্স প্রয়োজন। আপনি ধরে নিতে পারেন প্রতিটি মান লুপের ভিতরে একবারই সংশোধিত হয়, তাই আমরা এটি (ডেটা লোকালটি) করতে এটি অনুকূল করতে পারি।

পার্শ্ব প্রতিক্রিয়া জন্য মন্তব্য পড়ুন।

এর T[]পরিবর্তে একটি ব্যবহারের জন্য উত্তরটি সম্পাদনা করে List<T>।

Question 3

আপনি যা করছেন তা গণনা করা হচ্ছে (ভেরিয়েবল রেডিক্স সহ, তবে এখনও গণনা করা হচ্ছে)।

যেহেতু আপনি সি # ব্যবহার করছেন, আমি ধরে নিয়েছি আপনি দরকারী মেমরি লেআউট এবং ডেটা স্ট্রাকচারের সাথে খেলতে চান না যা আপনাকে সত্যই আপনার কোডটি অনুকূলিত করতে দেয়।

সুতরাং এখানে আমি আলাদা কিছু পোস্ট করছি, এটি আপনার ক্ষেত্রে উপযুক্ত নাও হতে পারে তবে এটি লক্ষণীয় actually যদি আপনি প্রকৃতপক্ষে একটি বিরাট ফ্যাশনে তালিকাটি অ্যাক্সেস করেন তবে এখানে এমন একটি শ্রেণি রয়েছে যা আপনাকে রৈখিক সময়ের মধ্যে আই-তম উপাদানটি গণনা করতে দেয় (পরিবর্তে) অন্যান্য উত্তর হিসাবে ক্ষতিকারক চেয়ে)

class Counter
{
    public int[] Radices;

    public int[] this[int n]
    {
        get 
        { 
            int[] v = new int[Radices.Length];
            int i = Radices.Length - 1;

            while (n != 0 && i >= 0)
            {
                //Hope C# has an IL-opcode for div-and-reminder like x86 do
                v[i] = n % Radices[i];
                n /= Radices[i--];
            }
            return v;
        }
    }
}

আপনি এই শ্রেণিটি এভাবে ব্যবহার করতে পারেন

Counter c = new Counter();
c.Radices = new int[] { 2,3,4,3,4,3,3,4,2,4,4,3,4};

এখন c[i]আপনার তালিকা হিসাবে একই, এটির নাম l, l[i]।

যেমন আপনি দেখতে পাচ্ছেন, আপনি সহজেই এই সমস্ত লুপগুলি এড়াতে পারবেন :) এমনকি আপনি যখন সমস্ত তালিকা নিখুঁতভাবে গণনা করেন তখনই আপনি কেবল একটি ক্যারি-রিপল কাউন্টার বাস্তবায়ন করতে পারেন।

কাউন্টারগুলি একটি খুব অধ্যয়নযোগ্য বিষয়, যদি আপনি মনে করেন তবে কিছু সাহিত্যের সন্ধানের জন্য দৃ strongly় পরামর্শ দিচ্ছি।

Question 4

পদ্ধতি 1

এটিকে দ্রুত করার একটি উপায় হ'ল আপনি যদি এর List<byte[]>মতো ব্যবহারের পরিকল্পনা করে থাকেন তবে সক্ষমতা উল্লেখ করা ।

var data = new List<byte[]>(2 * 3 * 4 * 3 * 4 * 3 * 3 * 4 * 2 * 4 * 4 * 3 * 4);

পদ্ধতি 2

তদ্ব্যতীত, আপনি System.Arrayদ্রুত অ্যাক্সেস পেতে সরাসরি ব্যবহার করতে পারেন । আমি এই পদ্ধতির প্রস্তাব দিচ্ছি যদি আপনার প্রশ্নটি জোর দেয় যে প্রতিটি উপাদান শারীরিকভাবে মেমরির মধ্যে রয়েছে, সামনে।

var data = new byte[2 * 3 * 4 * 3 * 4 * 3 * 3 * 4 * 2 * 4 * 4 * 3 * 4][];
int counter = 0;

for (byte a = 0; a < 2; a++)
    for (byte b = 0; b < 3; b++)
        for (byte c = 0; c < 4; c++)
            for (byte d = 0; d < 3; d++)
                for (byte e = 0; e < 4; e++)
                    for (byte f = 0; f < 3; f++)
                        for (byte g = 0; g < 3; g++)
                            for (byte h = 0; h < 4; h++)
                                for (byte i = 0; i < 2; i++)
                                    for (byte j = 0; j < 4; j++)
                                        for (byte k = 0; k < 4; k++)
                                            for (byte l = 0; l < 3; l++)
                                                for (byte m = 0; m < 4; m++)
                                                    data[counter++] = new[] { a, b, c, d, e, f, g, h, i, j, k, l, m };

এটি আমার কম্পিউটারে সম্পূর্ণ হতে 596 এমএস লাগবে , যা প্রশ্নযুক্ত কোডের চেয়ে প্রায় 10.4% দ্রুত (যা 658 মিমি লাগে)।

পদ্ধতি 3

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

এই বাস্তবায়নে প্রতিটি উপাদান অ্যাক্সেসের পরে অলসভাবে, ফ্লাইটে নির্ধারিত হয়। স্বাভাবিকভাবেই, এটি অতিরিক্ত সিপিইউয়ের দামে আসে যা অ্যাক্সেসের সময় ব্যয় করা হয়।

class HypotheticalBytes
{
    private readonly int _c1, _c2, _c3, _c4, _c5, _c6, _c7, _c8, _c9, _c10, _c11, _c12;
    private readonly int _t0, _t1, _t2, _t3, _t4, _t5, _t6, _t7, _t8, _t9, _t10, _t11;

    public int Count
    {
        get { return _t0; }
    }

    public HypotheticalBytes(
        int c0, int c1, int c2, int c3, int c4, int c5, int c6, int c7, int c8, int c9, int c10, int c11, int c12)
    {
        _c1 = c1;
        _c2 = c2;
        _c3 = c3;
        _c4 = c4;
        _c5 = c5;
        _c6 = c6;
        _c7 = c7;
        _c8 = c8;
        _c9 = c9;
        _c10 = c10;
        _c11 = c11;
        _c12 = c12;
        _t11 = _c12 * c11;
        _t10 = _t11 * c10;
        _t9 = _t10 * c9;
        _t8 = _t9 * c8;
        _t7 = _t8 * c7;
        _t6 = _t7 * c6;
        _t5 = _t6 * c5;
        _t4 = _t5 * c4;
        _t3 = _t4 * c3;
        _t2 = _t3 * c2;
        _t1 = _t2 * c1;
        _t0 = _t1 * c0;
    }

    public byte[] this[int index]
    {
        get
        {
            return new[]
            {
                (byte)(index / _t1),
                (byte)((index / _t2) % _c1),
                (byte)((index / _t3) % _c2),
                (byte)((index / _t4) % _c3),
                (byte)((index / _t5) % _c4),
                (byte)((index / _t6) % _c5),
                (byte)((index / _t7) % _c6),
                (byte)((index / _t8) % _c7),
                (byte)((index / _t9) % _c8),
                (byte)((index / _t10) % _c9),
                (byte)((index / _t11) % _c10),
                (byte)((index / _c12) % _c11),
                (byte)(index % _c12)
            };
        }
    }
}

এটি আমার কম্পিউটারে সম্পূর্ণ 897 এমএস লাগবে ( পদ্ধতি 2Array হিসাবে তৈরি করা ও যুক্ত করাও ), যা প্রশ্নের কোডের তুলনায় প্রায় 36.3% ধীর (যা 658 মিমি লাগে)।

Question 5

আমার মেশিনে, এটি 222 এমএস বনাম 760 এমএস (লুপগুলির জন্য 13) এর সংমিশ্রণগুলি তৈরি করে:

private static byte[,] GenerateCombinations(byte[] maxNumberPerLevel)
{
    var levels = maxNumberPerLevel.Length;

    var periodsPerLevel = new int[levels];
    var totalItems = 1;
    for (var i = 0; i < levels; i++)
    {
        periodsPerLevel[i] = totalItems;
        totalItems *= maxNumberPerLevel[i];
    }

    var results = new byte[totalItems, levels];

    Parallel.For(0, levels, level =>
    {
        var periodPerLevel = periodsPerLevel[level];
        var maxPerLevel = maxNumberPerLevel[level];
        for (var i = 0; i < totalItems; i++)
            results[i, level] = (byte)(i / periodPerLevel % maxPerLevel);
    });

    return results;
}

Question 6

var numbers = new[] { 2, 3, 4, 3, 4, 3, 3, 4, 2, 4, 4, 3, 4 };
var result = (numbers.Select(i => Enumerable.Range(0, i))).CartesianProduct();

Http://ericlippert.com/2010/06/28/computing-a-cartesian-product-with-linq/ এ এক্সটেনশন পদ্ধতিটি ব্যবহার করে

public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences)
{
    // base case: 
    IEnumerable<IEnumerable<T>> result =
        new[] { Enumerable.Empty<T>() };
    foreach (var sequence in sequences)
    {
        // don't close over the loop variable (fixed in C# 5 BTW)
        var s = sequence;
        // recursive case: use SelectMany to build 
        // the new product out of the old one 
        result =
            from seq in result
            from item in s
            select seq.Concat(new[] { item });
    }
    return result;
}

Question 7

তালিকার অভ্যন্তরীণভাবে একটি অ্যারে থাকে যেখানে এটি একটি নির্দিষ্ট দৈর্ঘ্যের সাথে মানগুলি সংরক্ষণ করে। আপনি যখন তালিকায় কল করবেন enough পর্যাপ্ত জায়গা আছে কিনা তা পরীক্ষা করে দেখুন। এটি যখন নতুন উপাদান যুক্ত করতে না পারে এটি বৃহত্তর আকারের একটি নতুন অ্যারে তৈরি করবে, পূর্ববর্তী সমস্ত উপাদানগুলি অনুলিপি করুন, তারপরে নতুনটি যুক্ত করুন। এটি বেশ কয়েকটি চক্র নেয়।

যেহেতু আপনি ইতিমধ্যে উপাদানগুলির সংখ্যা জানেন তাই আপনি সঠিক আকারের তালিকা তৈরি করতে পারেন, এটি ইতিমধ্যে অনেক দ্রুত হওয়া উচিত।

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

Question 8

এখানে একটি পৃথক পদ্ধতিতে কেবল 2 টি লুপের প্রয়োজন। ধারণাটি হ'ল প্রথম উপাদানটি বাড়ানো এবং যদি সেই সংখ্যাটি পরেরটি বাড়ানোর চেয়ে বেশি হয়।

ডেটা প্রদর্শন করার পরিবর্তে, আপনি বর্তমানভ্যালুগুলি ব্যবহার করতে পারেন lক্লোন এবং ক্লোন করা সংস্করণটি আপনার তালিকায় যুক্ত করতে পারেন। আমার জন্য এটি আপনার সংস্করণের চেয়ে দ্রুত দৌড়েছিল।

byte[] maxValues = {2, 3, 4};
byte[] currentValues = {0, 0, 0};

do {
    Console.WriteLine("{0}, {1}, {2}", currentValues[0], currentValues[1], currentValues[2]);

    currentValues[0] += 1;

    for (int i = 0; i <= maxValues.Count - 2; i++) {
        if (currentValues[i] < maxValues[i]) {
            break;
        }

        currentValues[i] = 0;
        currentValues[i + 1] += 1;
    }

// Stop the whole thing if the last number is over
// } while (currentValues[currentValues.Length-1] < maxValues[maxValues.Length-1]);
} while (currentValues.Last() < maxValues.Last());

আশা করি এই কোডটি কার্যকর হয়, আমি এটি ভিবি থেকে রূপান্তর করেছি

Question 9

আপনার সমস্ত নম্বর সংকলন সময় ধ্রুবক।

একটি তালিকাতে সমস্ত লুপগুলি তালিকাভুক্ত করার বিষয়ে কী (কোড লেখার জন্য আপনার প্রোগ্রামটি ব্যবহার করে):

data.Add(new [] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
data.Add(new [] {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
etc.

এটি অন্তত লুপগুলির ওভারহেডটি সরিয়ে ফেলতে হবে (যদি থাকে তবে)।

আমি সি # এর সাথে খুব বেশি পরিচিত নই, তবে বস্তুগুলিকে সিরিয়াল করার কিছু উপায় আছে বলে মনে হচ্ছে। আপনি যদি কেবলমাত্র সেই তালিকাটি তৈরি করেছেন এবং কোনও আকারে এটি ক্রমিক করেছেন? আমি নিশ্চিত না যে ডিসরিয়ালাইজেশন দ্রুত হয় কিনা তবে তালিকা তৈরি এবং উপাদানগুলি যুক্ত করা হোক।

Question 10

অ্যারেগুলির অ্যারে হওয়ার জন্য আপনার কি ফলাফল দরকার? বর্তমান সেটআপের সাথে সাথে অভ্যন্তরীণ অ্যারেগুলির দৈর্ঘ্য স্থির হয় এবং স্ট্রাক্টের সাথে প্রতিস্থাপন করা যেতে পারে। এটি পুরো জিনিসটিকে মেমরির একটানা ব্লক হিসাবে সংরক্ষণ করার অনুমতি দেয় এবং উপাদানগুলিতে সহজে অ্যাক্সেস সরবরাহ করে (আপনি কীভাবে এই জিনিসটি পরে ব্যবহার করবেন তা নিশ্চিত নয়)।

নীচের পদ্ধতিরটি আরও দ্রুত (আমার বাক্সে আসলটির জন্য 41ms বনাম 1071ms):

struct element {
    public byte a;
    public byte b;
    public byte c;
    public byte d;
    public byte e;
    public byte f;
    public byte g;
    public byte h;
    public byte i;
    public byte j;
    public byte k;
    public byte l;
    public byte m;
}

element[] WithStruct() {
    var t = new element[3981312];
    int z = 0;
    for (byte a = 0; a < 2; a++)
    for (byte b = 0; b < 3; b++)
    for (byte c = 0; c < 4; c++)
    for (byte d = 0; d < 3; d++)
    for (byte e = 0; e < 4; e++)
    for (byte f = 0; f < 3; f++)
    for (byte g = 0; g < 3; g++)
    for (byte h = 0; h < 4; h++)
    for (byte i = 0; i < 2; i++)
    for (byte j = 0; j < 4; j++)
    for (byte k = 0; k < 4; k++)
    for (byte l = 0; l < 3; l++)
    for (byte m = 0; m < 4; m++)
    {
        t[z].a = a;
        t[z].b = b;
        t[z].c = c;
        t[z].d = d;
        t[z].e = e;
        t[z].f = f;
        t[z].g = g;
        t[z].h = h;
        t[z].i = i;
        t[z].j = j;
        t[z].k = k;
        t[z].l = l;
        t[z].m = m;
        z++;
    }
    return t;
}

Question 11

Parallel.For()এটি চালানোর জন্য ব্যবহার সম্পর্কে কী ? ( @ ক্যারামিরিলে অপ্টিমাইজেশন কুডোস গঠন করুন ) আমি মানগুলিতে কিছুটা পরিবর্তন করেছি (2 এর পরিবর্তে 5 হ'ল) সুতরাং ফলাফলগুলিতে আমি আরও আত্মবিশ্বাসী।

    var data = new ConcurrentStack<List<Bytes>>();
    var sw = new Stopwatch();

    sw.Start();

    Parallel.For(0, 5, () => new List<Bytes>(3*4*3*4*3*3*4*2*4*4*3*4),
      (a, loop, localList) => {
        var bytes = new Bytes();
        bytes.A = (byte) a;
        for (byte b = 0; b < 3; b++) {
          bytes.B = b;
          for (byte c = 0; c < 4; c++) {
            bytes.C = c; 
            for (byte d = 0; d < 3; d++) {
              bytes.D = d; 
              for (byte e = 0; e < 4; e++) {
                bytes.E = e; 
                for (byte f = 0; f < 3; f++) {
                  bytes.F = f; 
                  for (byte g = 0; g < 3; g++) {
                    bytes.G = g; 
                    for (byte h = 0; h < 4; h++) {
                      bytes.H = h; 
                      for (byte i = 0; i < 2; i++) {
                        bytes.I = i; 
                        for (byte j = 0; j < 4; j++) {
                          bytes.J = j; 
                          for (byte k = 0; k < 4; k++) {
                            bytes.K = k; 
                            for (byte l = 0; l < 3; l++) {
                              bytes.L = l;
                              for (byte m = 0; m < 4; m++) {
                                bytes.M = m;
                                localList.Add(bytes);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }


        return localList;
      }, x => {
        data.Push(x);
    });

    var joinedData = _join(data);

_join() এটি একটি ব্যক্তিগত পদ্ধতি, এটি হিসাবে সংজ্ঞায়িত:

private static IList<Bytes> _join(IEnumerable<IList<Bytes>> data) {
  var value = new List<Bytes>();
  foreach (var d in data) {
    value.AddRange(d);
  }
  return value;
}

আমার সিস্টেমে, এই সংস্করণটি প্রায় 6 গুণ দ্রুত (0.27 সেকেন্ডের তুলনায় 1.718 সেকেন্ড) দ্রুত চলে।

Question 12

আপনার কয়েকটি নম্বর বিটসের পূর্ণসংখ্যার সংখ্যায় পুরোপুরি ফিট করে, তাই আপনি তাদের উপরের স্তরের নম্বর দিয়ে "প্যাক" করতে পারেন:

for (byte lm = 0; lm < 12; lm++)
{
    ...
    t[z].l = (lm&12)>>2;
    t[z].m = lm&3;
    ...
}

অবশ্যই, এটি কোডটি কম পঠনযোগ্য করে তোলে তবে আপনি একটি লুপ সংরক্ষণ করেছেন। এটি প্রতিবার সংখ্যার একটিতে দু'জনের শক্তি হ'ল এটি করা যেতে পারে যা আপনার ক্ষেত্রে সাতবার।

Question 13

এখানে আরও একটি সমাধান দেওয়া হল। ভিএস এর বাইরে এটি 437.5 এমএস হিসাবে দ্রুত চলে যা মূল কোডের চেয়ে 26% দ্রুত (আমার কম্পিউটারে 593.7):

static List<byte[]> Combinations(byte[] maxs)
{
  int length = maxs.Length;
  int count = 1; // 3981312;
  Array.ForEach(maxs, m => count *= m);
  byte[][] data = new byte[count][];
  byte[] counters = new byte[length];

  for (int r = 0; r < count; r++)
  {
    byte[] row = new byte[length];
    for (int c = 0; c < length; c++)
      row[c] = counters[c];
    data[r] = row;

    for (int i = length - 1; i >= 0; i--)
    {
      counters[i]++;
      if (counters[i] == maxs[i])
        counters[i] = 0;
      else
        break;
    }
  }

  return data.ToList();
}