नेस्टेड छोरों के लिए तेज़ विकल्प?

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लेकिन मुझे यकीन नहीं है कि मैं इसे कैसे शामिल कर सकता हूं।

प्रत्येक अनुशंसा के लिए हम आपके अत्यंत आभारी होंगे। वैकल्पिक रूप से, शायद यह सबसे तेज़ तरीका है जो मुझे चाहिए?

त्वरित बिंदुओं की EDIT जोड़ी (और माफी जो मैंने उन्हें मूल पोस्ट में नहीं डाली थी):

संख्या और उनके क्रम (2, 3, 4, 3, 4, 3, 3 आदि) बहुत महत्वपूर्ण हैं, इसलिए एक समाधान का उपयोग करना जैसे कि LINQ का उपयोग करके जनरेटिंग क्रमांकन में मदद नहीं मिलेगी क्योंकि प्रत्येक 'कॉलम' में मैक्सिमम हैं विभिन्न
मैं गणितज्ञ नहीं हूं, इसलिए मैं माफी मांगता हूं अगर मैं 'क्रमपरिवर्तन' और 'संयोजन' जैसे तकनीकी शब्दों का उपयोग नहीं कर रहा हूं
मैं है मैं सिर्फ एक आकर्षित नहीं कर सकते हैं या किसी अन्य एक सूचकांक के आधार पर - एक बार में इन संयोजनों के सभी से पॉप्युलेट करने
उपयोग करने byteकी तुलना में उपयोग करना तेज है int, मैं इसकी गारंटी देता हूं । यह भी स्मृति उपयोग पर एक बहुत बेहतर है बट्स के बजाय बाइट्स के 67m + सरणियों है
मेरा अंतिम लक्ष्य नेस्टेड छोरों के लिए एक तेज विकल्प की तलाश करना है।
मैंने समानांतर प्रोग्रामिंग का उपयोग करने पर विचार किया, लेकिन जो मैं हासिल करने की कोशिश कर रहा हूं, उसके पुनरावृत्ति स्वभाव के कारण, मैं इसे सफलतापूर्वक (यहां तक कि ConcurrentBag) करने का एक तरीका नहीं खोज सका - हालांकि मैं गलत साबित होने के लिए खुश हूं :)

निष्कर्ष

Caramiriel ने एक अच्छा माइक्रो-ऑप्टिमाइज़ेशन प्रदान किया है जो लूप्स से कुछ समय दूर होता है, इसलिए मैंने उस उत्तर को सही के रूप में चिह्नित किया है। एरिक ने यह भी उल्लेख किया कि सूची को पूर्व-आवंटित करना तेज है। लेकिन, इस स्तर पर ऐसा लगता है कि नेस्टेड लूप वास्तव में ऐसा करने का सबसे तेज़ संभव तरीका है (निराशाजनक, मुझे पता है!)।

यदि आप वास्तव में कोशिश करना चाहते हैं कि मैं किसके साथ बेंचमार्क करने की कोशिश कर रहा था StopWatch, तो प्रत्येक लूप में 4 तक गिनती के साथ 13 छोरों पर जाएं - जो सूची में लगभग 67m + लाइनें बनाता है। मेरी मशीन (i5-3320M 2.6GHz) पर अनुकूलित संस्करण को करने में लगभग 2.2s का समय लगता है।

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

हर बार जब आप सूची में जोड़ते हैं तो यह एक नई सूची आवंटित नहीं करता है क्योंकि यह तेज़ है। चूंकि यह इस सूची को बना रहा है, इसलिए इसे हर दूसरे मूल्य (ए, बी, सी, डी, ई) के संदर्भ की आवश्यकता है। आप मान सकते हैं कि प्रत्येक मान केवल लूप के अंदर एक बार संशोधित किया जाता है, इसलिए हम ऐसा करने के लिए इसे अनुकूलित कर सकते हैं (डेटा स्थानीयता)।

साइड-इफेक्ट्स के लिए टिप्पणियाँ भी पढ़ें।

के T[]बजाय उपयोग करने के लिए उत्तर का संपादन किया List<T>।

Question 3

आप जो कर रहे हैं वह गिनती है (चर मूलांक के साथ, लेकिन फिर भी गिनती)।

जब से आप C # का उपयोग कर रहे हैं, मुझे लगता है कि आप उपयोगी मेमोरी लेआउट और डेटा संरचनाओं के साथ नहीं खेलना चाहते हैं जो आपको वास्तव में अपने कोड को अनुकूलित करने की अनुमति देते हैं ।

इसलिए यहां मैं कुछ अलग पोस्ट कर रहा हूं, जो आपके मामले के अनुरूप नहीं हो सकता है, लेकिन यह ध्यान देने योग्य है: यदि आप वास्तव में एक विरल फैशन में सूची तक पहुंचते हैं, तो यहां एक वर्ग है जो आपको रैखिक समय में आई-वें तत्व की गणना करने देता है (बल्कि घातांक की तुलना में अन्य उत्तर)

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]।

जैसा कि आप देख सकते हैं, आप आसानी से उन सभी छोरों से बच सकते हैं :) यहां तक कि जब आप पूरी सूची को पूरी तरह से पूर्व कर देते हैं तब से आप केवल कैरी-रिपल काउंटर को लागू कर सकते हैं।

काउंटर्स एक बहुत ही अध्ययन का विषय है, अगर आपको लगता है कि मैं कुछ साहित्य की खोज करने की दृढ़ता से सलाह देता हूं।

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% तेज है (जो 658ms लेता है)।

विधि 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)
            };
        }
    }
}

यह मेरे कंप्यूटर पर ( विधि 2 में एक के रूप में भी बनाने और जोड़ने ) को पूरा करने के लिए 897 एमएस लेता है , जो कि प्रश्न में कोड की तुलना में 36.3% धीमा है (जो 658ms लेता है)।Array

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

सूची में आंतरिक रूप से एक सरणी होती है जहां यह एक निश्चित लंबाई के साथ इसे मूल्यों को संग्रहीत करता है। जब आप List कहते हैं। पर्याप्त स्थान होने पर यह जांचें। जब यह नया तत्व नहीं जोड़ता है तो यह बड़े आकार का एक नया सरणी बनाएगा, पिछले सभी तत्वों को कॉपी करेगा, फिर नए को जोड़ेगा। इसमें काफी चक्र लगते हैं।

चूंकि आप पहले से ही तत्वों की संख्या जानते हैं, इसलिए आप सही आकार की सूची बना सकते हैं, जो पहले से ही बहुत तेज होना चाहिए।

इसके अलावा, यह सुनिश्चित नहीं करें कि आप मूल्यों का उपयोग कैसे करते हैं, लेकिन आप इस चीज़ को बना सकते हैं और छवि को कोड में सहेज सकते हैं (इसे डिस्क से लोड करना संभवत: आपके द्वारा किए गए कार्य की तुलना में धीमा होगा। अब आप कितनी बार इसे पढ़ते / लिखते हैं। चीज़?

Question 8

यहां एक अलग तरीका है जिसे केवल 2 लूप की आवश्यकता है। विचार पहले तत्व को बढ़ाने के लिए है और यदि वह संख्या अगले एक को बढ़ाने से अधिक है।

डेटा प्रदर्शित करने के बजाय, आप currentValues.Clone का उपयोग कर सकते हैं और उस क्लोन संस्करण को अपनी सूची में जोड़ सकते हैं। मेरे लिए यह आपके संस्करण से अधिक तेज़ी से चला।

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());

आशा है कि यह कोड काम करता है, मैंने इसे vb से बदल दिया है

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.

कम से कम छोरों के ओवरहेड को दूर करना चाहिए (यदि कोई है)।

मैं C # से बहुत अधिक परिचित नहीं हूं, लेकिन वस्तुओं को क्रमबद्ध करने के कुछ साधन प्रतीत होते हैं। क्या होगा यदि आप अभी उस सूची को उत्पन्न करते हैं और इसे किसी रूप में क्रमबद्ध करते हैं? मुझे यकीन नहीं है कि यदि डिसेरिएलाइज़ेशन जल्दी हो जाता है तो सूची बनाएं और तत्वों को जोड़ दें, हालांकि।

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()इसे चलाने के लिए उपयोग करने के बारे में क्या ? ( संरचना अनुकूलन यश @Caramiriel के लिए )। मैंने मूल्यों को थोड़ा संशोधित किया है (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 गुना तेज (1.718 सेकंड बनाम 0.266 सेकंड) चलाता है।

Question 12

आपकी संख्याओं में से कुछ पूरी तरह से बिट्स के पूर्णांक नुम्बर पर फिट होते हैं, इसलिए आप उन्हें ऊपरी स्तर की संख्या के साथ "पैक" कर सकते हैं:

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

बेशक, यह कोड को कम पठनीय बनाता है, लेकिन आपने एक लूप बचाया। यह हर बार किया जा सकता है जब संख्याओं में से एक दो की शक्ति होती है, जो आपके मामले में सात बार होती है।

Question 13

यहाँ एक और उपाय है। वीएस के बाहर यह 437.5 एमएस के रूप में तेजी से चलता है जो मूल कोड (मेरे कंप्यूटर पर 593.7) से 26% तेज है:

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