मैट्रिक्स की संपत्ति एक्स का फिर से आना (या एक्स की खुशी)

Question

यह चुनौती आंशिक रूप से एक एल्गोरिदम चुनौती है, आंशिक रूप से एक अनुकूलन चुनौती है और आंशिक रूप से बस एक सबसे तेज़ कोड चुनौती है।

AT मैट्रिक्स अपनी पहली पंक्ति rऔर पहले कॉलम द्वारा पूरी तरह से निर्दिष्ट है c। मैट्रिक्स के प्रत्येक शेष तत्व केवल उस तत्व की एक प्रति है जो तिरछे ऊपर और बाएं है। यही कारण है M[i,j] = M[i-1,j-1]। हम टी मैट्रीक की अनुमति देंगे जो वर्ग नहीं हैं। हालांकि हम हमेशा यह मानते हैं कि पंक्तियों की संख्या स्तंभों की संख्या से अधिक नहीं है। उदाहरण के लिए, 5 टी मैट्रिक्स द्वारा निम्नलिखित 3 पर विचार करें।

10111
11011
11101

हम कहते हैं कि मैट्रिक्स में गुणनफल X होता है यदि इसमें गैर-समान सूचकांकों वाले स्तंभों के दो गैर-खाली सेट होते हैं जिनमें समान (वेक्टर) योग होता है। एक या एक से अधिक स्तंभों का वेक्टर योग उनके कॉलमों का एक तत्व-वार योग है। यह दो या दो से अधिक स्तंभों का योग है जिसमें xप्रत्येक तत्व वाला एक अन्य स्तंभ xहै। किसी एक कॉलम का योग ही कॉलम है।

तुच्छ रूप से ऊपर वाले मैट्रिक्स में गुणनफल X है क्योंकि पहले और अंतिम कॉलम समान हैं। पहचान मैट्रिक्स में कभी संपत्ति X नहीं होती है।

यदि हम ऊपर दिए गए मैट्रिक्स के अंतिम कॉलम को हटाते हैं तो हमें एक उदाहरण मिलता है जिसमें संपत्ति X नहीं है और यह 4/3 का स्कोर देगा।

1011
1101
1110

काम

कार्य बाइनरी प्रविष्टियों के साथ उच्चतम स्कोरिंग टी मैट्रिक्स को खोजने के लिए कोड लिखना है और जिसके पास संपत्ति एक्स नहीं है। स्पष्टता के लिए, द्विआधारी प्रविष्टियों के साथ एक मैट्रिक्स में संपत्ति है कि इसकी प्रत्येक प्रविष्टि या तो 0 या 1 है।

स्कोर

आपका स्कोर आपके सर्वश्रेष्ठ स्कोरिंग मैट्रिक्स में पंक्तियों की संख्या से विभाजित संख्या कॉलम होगा।

टाई ब्रेकर

यदि दो उत्तरों में समान स्कोर है, तो पहले ने पहली जीत दर्ज की।

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

संकेत

संपत्ति X के बिना उच्चतम स्कोरिंग मैट्रिक्स को खोजने के सभी उत्तर यहां मान्य हैं लेकिन वे इष्टतम नहीं हैं। संपत्ति X के बिना T मैट्रिसेस हैं जो चक्रीय नहीं हैं।

उदाहरण के लिए, संपत्ति X के बिना 7 बाय 12 टी मैट्रिक्स है लेकिन ऐसा कोई चक्रीय मैट्रिक्स नहीं है।

21/11 इसमें से सभी मौजूदा उत्तरों और पिछली चुनौती को हरा देगा।

भाषाएं और पुस्तकालय

आप किसी भी भाषा का उपयोग कर सकते हैं जिसमें एक स्वतंत्र रूप से उपलब्ध संकलक / दुभाषिया / आदि है। लिनक्स और किसी भी पुस्तकालय के लिए जो लिनक्स के लिए भी स्वतंत्र रूप से उपलब्ध हैं।

बोनस 2 से अधिक अंक वाले पहले उत्तर को तत्काल 200 अंक का पुरस्कार मिलता है। टन हास्पेल ने अब यह हासिल कर लिया है!

---

वर्तमान नेता बोर्ड

• सी ++ । टन हास्पेल द्वारा स्कोर 31/15
• जावा । पीटर टेलर द्वारा स्कोर 36/19
• हास्केल । अलेक्जेंडर-ब्रेट द्वारा स्कोर 14/8

Comments

"गैर-समान सूचकांकों वाले स्तंभों के दो गैर-खाली सेटों" से आपका मतलब उन स्तंभों के दो सेटों से है जो असम्बद्ध हैं? या, इसे रीफ़्रेज़ करने के लिए, {1, 3}, {1, 5} एक वैध दो उप-कॉलम हैं?

— pawel.boczarski

@ pawel.boczarski कोई असहमति नहीं। बस गैर-समरूप। इसलिए {1, 3}, {1, 5} वैध है।

ठीक है। M [i, 1] के बारे में क्या है - क्या यह M [i-1] के अंतिम कॉलम से "उधार" है (शून्य एक वैध मैट्रिक्स कॉलम इंडेक्स नहीं है)? और वास्तव में यह "ऊपर और दाएं" के बजाय "ऊपर और बाएं" है।

— pawel.boczarski

@ pawel.boczarski "राइट" एक टाइपो था। धन्यवाद। पहली पंक्ति और कॉलम को आपकी पसंद के अनुसार सेट किया जा सकता है। वे मैट्रिक्स के बाकी हिस्सों को परिभाषित करते हैं। क्या वह आपके सवाल का जवाब है?

ठीक है मैंने समझ लिया। यह मेरी गलती थी कि मैंने ध्यान से नहीं पढ़ा कि पहला कॉलम भी परिभाषित है।

— pawel.boczarski

Answer 1

सी ++, स्कोर 23/12 25/13 27/14 28/14 31/15

अंत में परिणाम> 2:

rows=15,cols=31
1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 1 1 0 
1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 1 1 
1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 1 
1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 
1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 
0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 
0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 
1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 
0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 
0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 
0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 
1 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 
0 1 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 
0 0 1 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 
1 0 0 1 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 

मैंने पूरी तरह से 1 से 14 पंक्तियों का पता लगाया। 15 को पूरी तरह से तलाशने में बहुत लंबा समय लगेगा। परिणाम हैं:

1/1   = 1
2/2   = 1
4/3   = 1.333
5/4   = 1.25
7/5   = 1.4
9/6   = 1.5
12/7  = 1.714
14/8  = 1.75
16/9  = 1.778
18/10 = 1.8
20/11 = 1.818
23/12 = 1.917
25/13 = 1.923
28/14 = 2

नीचे दिया गया कोड प्रोग्राम का एक पुराना संस्करण है। नवीनतम संस्करण https://github.com/thospel/personal-propertyX पर है ।

/*
  Compile using something like:
    g++ -Wall -O3 -march=native -fstrict-aliasing -std=c++11 -g propertyX.cpp -lpthread -o propertyX
*/
#include <cstdint>
#include <climits>
#include <ctgmath>
#include <iostream>
#include <vector>
#include <array>
#include <chrono>
#include <mutex>
#include <atomic>
#include <thread>

using namespace std;

const int ELEMENTS = 2;

using uint    = unsigned int;
using Element = uint64_t;
using Column  = array<Element, ELEMENTS>;
using Set     = vector<Column>;
using Sum     = uint8_t;
using Index   = uint32_t;
using sec = chrono::seconds;

int const PERIOD = 5*60;
int const MAX_ROWS = 54;
int const COL_FACTOR = (MAX_ROWS+1) | 1;                // 55
int const ROW_ZERO   = COL_FACTOR/2;                    // 27
int const ROWS_PER_ELEMENT = CHAR_BIT * sizeof(Element) / log2(COL_FACTOR); //11
Element constexpr ELEMENT_FILL(Element v = ROW_ZERO, int n = ROWS_PER_ELEMENT) {
    return n ? ELEMENT_FILL(v, n-1) * COL_FACTOR + v : 0;
}
Element constexpr POWN(Element v, int n) {
    return n ? POWN(v, n-1)*v : 1;
}
Element const ELEMENT_TOP = POWN(COL_FACTOR, ROWS_PER_ELEMENT -1);
int const MAX_COLS = ROWS_PER_ELEMENT * ELEMENTS;       // 22

atomic<Index> col_next;
atomic<uint>  period;
chrono::steady_clock::time_point start;
mutex period_mutex;

uint ratio_row;
uint ratio_col;
mutex ratio_mutex;

auto const nr_threads = thread::hardware_concurrency();
// auto const nr_threads = 1;

struct State {
    State(uint cols);
    void process(Index i);
    void extend(uint row);
    void print(uint rows);
    Index nr_columns() const { return static_cast<Index>(1) << cols_; }

    Column last_;
    Element top_;
    int top_offset_;
    uint ratio_row_ = 0;
    uint ratio_col_ = 1;
    uint cols_;
    array<Sum, MAX_ROWS + MAX_COLS -1> side;
    vector<Set> sets;
};

ostream& operator<<(ostream& os, Column const& column) {
    for (int i=0; i<ELEMENTS; ++i) {
        auto v = column[i];
        for (int j=0; j<ROWS_PER_ELEMENT; ++j) {
            auto bit = v / ELEMENT_TOP;
            cout << " " << bit;
            v -= bit * ELEMENT_TOP;
            v *= COL_FACTOR;
        }
    }
    return os;
}

State::State(uint cols) : cols_{cols} {
    sets.resize(MAX_ROWS+2);
    for (int i=0; i<2; ++i) {
        sets[i].resize(2);
        for (int j=0; j < ELEMENTS; ++j) {
            sets[i][0][j] =  ELEMENT_FILL();
            sets[i][1][j] =  static_cast<Element>(-1) - ELEMENT_FILL(1);
        }
    }
    top_ = POWN(COL_FACTOR, (cols_-1) % ROWS_PER_ELEMENT);
    top_offset_ = ELEMENTS - 1 - (cols_-1) / ROWS_PER_ELEMENT;
}

void State::print(uint rows) {
    for (auto c=0U; c<cols_;c++) {
        for (auto r=0U; r<rows;r++) {
            cout << static_cast<int>(side[cols_-c+r-1]) << " ";
        }
        cout << "\n";
    }
    cout << "----------" << endl;
}

void check(uint cols, uint t) {
    State state(cols);

    Index nr_columns = state.nr_columns();
    while (1) {
        Index col = col_next++;
        if (col >= nr_columns) break;
        state.process(col);

        auto now = chrono::steady_clock::now();
        auto elapsed = chrono::duration_cast<sec>(now-start).count();
        if (elapsed >= period) {
            lock_guard<mutex> lock{period_mutex};
            if (elapsed >= period) {
                cout << "col=" << col << "/" << nr_columns << " (" << 100.*col/nr_columns << "% " << elapsed << " s)" << endl;
                period = (elapsed/PERIOD+1)*PERIOD;
            }
        }
    }
}

void State::process(Index col) {
    last_.fill(0);
    for (uint i=0; i<cols_; ++i) {
        Element bit = col >> i & 1;
        side[i] = bit;
        Element carry = 0;
        for (int j=0; j<ELEMENTS; ++j) {
            auto c = last_[j] % COL_FACTOR;
            last_[j] = last_[j] / COL_FACTOR + carry * ELEMENT_TOP;
            if (j == top_offset_ && bit) last_[j] += top_;
            carry = c;
        }
    }
    // cout << "col=" << col << ", value=" << last_ << "\n";
    extend(0);
}

void State::extend(uint row) {
    // cout << "Extend row " << row << " " << static_cast<int>(side[cols_+row-1]) << "\n";
    if (row >= MAX_ROWS) throw(range_error("row out of range"));

    // Execute subset sum. The new column is added to set {from} giving {to}
    // {sum} is the other set.
    auto const& set_from = sets[row];
    auto const& set_sum  = sets[row + 1];
    auto      & set_to   = sets[row + 2];
    if (set_to.size() == 0) {
        auto size = 3 * set_from.size() - 2;
        set_to.resize(size);
        for (int j=0; j<ELEMENTS; ++j)
            set_to[size-1][j] = static_cast<Element>(-1) - ELEMENT_FILL(1);
    }

    // Merge sort {set_from - last_} , {set_from} and {set_from + last_}
    auto ptr_sum    = &set_sum[1][0];
    auto ptr_low    = &set_from[0][0];
    auto ptr_middle = &set_from[0][0];
    auto ptr_high   = &set_from[0][0];
    Column col_low, col_high;
    for (int j=0; j<ELEMENTS; ++j) {
        col_low   [j] = *ptr_low++  - last_[j];
        col_high  [j] = *ptr_high++ + last_[j];
    }

    auto ptr_end = &set_to[set_to.size()-1][0];
    auto ptr_to  = &set_to[0][0];
    while (ptr_to < ptr_end) {
        for (int j=0; j<ELEMENTS; ++j) {
            if (col_low[j] < ptr_middle[j]) goto LOW;
            if (col_low[j] > ptr_middle[j]) goto MIDDLE;
        }
        // low == middle
        // cout << "low == middle\n";
        return;

      LOW:
        // cout << "LOW\n";
        for (int j=0; j<ELEMENTS; ++j) {
            if (col_low[j] < col_high[j]) goto LOW0;
            if (col_low[j] > col_high[j]) goto HIGH0;
        }
        // low == high
        // cout << "low == high\n";
        return;

      MIDDLE:
        // cout << "MIDDLE\n";
        for (int j=0; j<ELEMENTS; ++j) {
            if (ptr_middle[j] < col_high[j]) goto MIDDLE0;
            if (ptr_middle[j] > col_high[j]) goto HIGH0;
        }
        // middle == high
        // cout << "middle == high\n";
        return;

      LOW0:
        // cout << "LOW0\n";
        for (int j=0; j<ELEMENTS; ++j) {
            *ptr_to++  = col_low[j];
            col_low[j] = *ptr_low++ - last_[j];
        }
        goto SUM;

      MIDDLE0:
        // cout << "MIDDLE0\n";
        for (int j=0; j<ELEMENTS; ++j)
            *ptr_to++ = *ptr_middle++;
        goto SUM;

      HIGH0:
        // cout << "HIGH0\n";
        for (int j=0; j<ELEMENTS; ++j) {
            *ptr_to++ = col_high[j];
            col_high[j] = *ptr_high++ + last_[j];
        }
        goto SUM;
      SUM:
        for (int j=-ELEMENTS; j<0; ++j) {
            if (ptr_to[j] > ptr_sum[j]) {
                ptr_sum += ELEMENTS;
                goto SUM;
            }
            if (ptr_to[j] < ptr_sum[j]) goto DONE;
        }
        // sum == to
        for (int j=-ELEMENTS; j<0; ++j)
            if (ptr_to[j] != ELEMENT_FILL()) {
                // sum == to and to != 0
                // cout << "sum == to\n";
                // cout << set_sum[(ptr_sum - &set_sum[0][0])/ELEMENTS-1] << "\n";
                return;
            }
      DONE:;
    }
    // cout << "Wee\n";
    auto row1 = row+1;
    if (0)
        for (uint i=0; i<row1+2; ++i) {
            cout << "Set " << i << "\n";
            auto& set = sets[i];
            for (auto& column: set)
                cout << column << "\n";
        }

    if (row1 * ratio_col_ > ratio_row_ * cols_) {
        ratio_row_ = row1;
        ratio_col_ = cols_;
        lock_guard<mutex> lock{ratio_mutex};

        if (ratio_row_ * ratio_col > ratio_row * ratio_col_) {

            auto now = chrono::steady_clock::now();
            auto elapsed = chrono::duration_cast<sec>(now-start).count();
            cout << "cols=" << cols_ << ",rows=" << row1 << " (" << elapsed << " s)\n";
            print(row1);
            ratio_row = ratio_row_;
            ratio_col = ratio_col_;
        }
    }

    auto last = last_;

    Element carry = 0;
    for (int j=0; j<ELEMENTS; ++j) {
        auto c = last_[j] % COL_FACTOR;
        last_[j] = last_[j] / COL_FACTOR + carry * ELEMENT_TOP;
        carry = c;
    }

    side[cols_+row] = 0;
    extend(row1);

    last_[top_offset_] += top_;
    side[cols_+row] = 1;
    extend(row1);

    last_ = last;
}

void my_main(int argc, char** argv) {
    if (!col_next.is_lock_free()) cout << "col_next is not lock free\n";
    if (!period.  is_lock_free()) cout << "period is not lock free\n";

    int min_col = 2;
    int max_col = MAX_COLS;
    if (argc > 1) {
        min_col = atoi(argv[1]);
        if (min_col < 2)
            throw(range_error("Column must be >= 2"));
        if (min_col > MAX_COLS)
            throw(range_error("Column must be <= " + to_string(MAX_COLS)));
    }
    if (argc > 2) {
        max_col = atoi(argv[2]);
        if (max_col < min_col)
            throw(range_error("Column must be >= " + to_string(min_col)));
        if (max_col > MAX_COLS)
            throw(range_error("Column must be <= " + to_string(MAX_COLS)));
    }

    for (int cols = min_col; cols <= max_col; ++cols) {
        cout << "Trying " << cols << " columns" << endl;
        ratio_row = 0;
        ratio_col = 1;
        col_next = 0;
        period = PERIOD;
        start = chrono::steady_clock::now();
        vector<thread> threads;
        for (auto t = 1U; t < nr_threads; t++)
            threads.emplace_back(check, cols, t);
        check(cols, 0);
        for (auto& thread: threads)
            thread.join();
    }
}

int main(int argc, char** argv) {
    try {
        my_main(argc, argv);
    } catch(exception& e) {
        cerr << "Error: " << e.what() << endl;
        exit(EXIT_FAILURE);
    }
    exit(EXIT_SUCCESS);
}

Comments

यह भी खूब रही। महान रहस्य है यदि आप कभी भी स्कोर प्राप्त कर सकते हैं 2.

एक्सट्रपलेशन के द्वारा, 28/14 मुझे अस्तित्व में होना चाहिए, जो मुझे लगता है कि वास्तव में रोमांचक होगा। लेकिन क्या यह सिर्फ पहुंच से बाहर है?

n = 14 को मेरे 8-कोर CPU पर मेरे वर्तमान कोड के साथ लगभग 200 दिन लगेंगे। संभवत: कोड को 30% तक बढ़ाया जा सकता है। उसके बाद मैं विचारों से बाहर चला गया। और अपने एक्सट्रपलेशन के बजाय आशावादी लगता है ...

— टन हास्पेल

मुझे लगता है कि पहली पंक्ति 010110111000101111010000011001111111111010100011010 के साथ 25 मैट्रिक्स से सर्कुलर 50 काम कर सकता है। यह अनुकूलन अनुकूलन द्वारा पाया गया जो उपयोगी हो सकता है।

N = 14 के संपूर्ण कवर के लिए 140 घंटे बहुत प्रभावशाली है।

Answer 2

हास्केल 14/8 = 1.75

1 1 0 0 0 1 0 1 1 0 1 1 0 0
1 1 1 0 0 0 1 0 1 1 0 1 1 0
0 1 1 1 0 0 0 1 0 1 1 0 1 1
1 0 1 1 1 0 0 0 1 0 1 1 0 1
0 1 0 1 1 1 0 0 0 1 0 1 1 0
0 0 1 0 1 1 1 0 0 0 1 0 1 1
0 0 0 1 0 1 1 1 0 0 0 1 0 1
0 0 0 0 1 0 1 1 1 0 0 0 1 0

पहले 9/6 = 1.5

1 0 1 0 1 1 0 0 1
1 1 0 1 0 1 1 0 0
1 1 1 0 1 0 1 1 0
1 1 1 1 0 1 0 1 1
1 1 1 1 1 0 1 0 1
1 1 1 1 1 1 0 1 0

मैंने यह लिखा, फिर दूसरे प्रश्न के उत्तर को देखा और ... हतोत्साहित किया गया।

import Data.List
import Data.Hashable
import Control.Monad
import Control.Parallel.Strategies
import Control.Parallel
import qualified Data.HashSet as S

matrix§indices = [ matrix!!i | i<-indices ]

powerset :: [a] -> [[a]]
powerset = filterM (const [True, False])

hashNub :: (Hashable a, Eq a) => [a] -> [a]
hashNub l = go S.empty l
    where
      go _ []     = []
      go s (x:xs) = if x `S.member` s
        then go s xs
        else x : go (S.insert x s) xs

getMatrix :: Int -> Int -> [Int] -> [[Int]]
getMatrix width height vector = [ vector § [x..x+width-1] | x<-[0..height-1] ]

hasDuplicate :: (Hashable a, Eq a) => [a] -> Bool
hasDuplicate m = go S.empty m
    where
        go _ [] = False
        go s (x:xs) = if x `S.member` s
            then True
            else go (S.insert x s) xs

hasProperty :: [[Int]] -> Bool
hasProperty matrix =
    let
        base = replicate (length (matrix !! 0)) 0::[Int]
    in
        if elem base matrix then
            False
        else
            if hasDuplicate matrix then
                False
            else
                if hasDuplicate (map (foldl (zipWith (+)) base) (powerset matrix)) then
                    False
                else
                    True


pmap = parMap rseq

matricesWithProperty :: Int -> Int -> [[[Int]]]
matricesWithProperty n m =
    let
        base = replicate n 0::[Int]
    in
    filter (hasProperty) $
    map (getMatrix n m) $
    sequence [ [0,1] | x<-[0..n+m-1] ]

firstMatrixWithProperty :: Int -> Int -> [[Int]]
firstMatrixWithProperty n m = head $ matricesWithProperty n m

main = mapM (putStrLn. show) $ map (firstMatrixWithProperty 8) [1..]

Comments

धन्यवाद! एक हास्केल जवाब हमेशा बहुत स्वागत है। मुझे लगता है कि पहला दिलचस्प मामला 12/7 है। क्या आपको वह मिल सकता है?

मैं इसे एक दोहरे कोर 2009 लैपटॉप पर चला रहा था, इसलिए नहीं :) मैं फिर से एक तेज़ मशीन पर कोशिश करूँगा

— अलेक्जेंडर-ब्रेट

बहुत अच्छा। मैंने अभी एक टिप्पणी जोड़ी है कि 21/11 पिछले सभी उत्तरों को हरा देगा।

क्या आप बता सकते हैं कि आपका कोड क्या करता है?

में main, संख्या (इस मामले में 8) मैट्रिक्स की ऊंचाई है, और कार्यक्रम चौड़ाई के माध्यम से पुनरावृत्त करता है [1..]। प्रत्येक ऊँचाई / चौड़ाई के संयोजन के लिए, यह एक वैध मैट्रिक्स के स्तंभों की एक श्रृंखला को प्रिंट करता है।

— अलेक्जेंडर-ब्रेट

Answer 3

सी

यहाँ एक जवाब है जो काम करता है और हास्केल की तुलना में अधिक मेमोरी-कुशल है। दुर्भाग्य से, मेरा कंप्यूटर अभी भी किसी भी उचित लंबाई में 14/8 से बेहतर हासिल करने के लिए बहुत धीमा है।

के gcc -std=c99 -O2 -fopenmp -o matrices.exe matrices.cसाथ matrices.exe width heightया समान के साथ संकलन और चलाने का प्रयास करें । आउटपुट एक पूर्णांक है, जिसके बिट्स प्रश्न में मैट्रिक्स के लिए आधार बनाते हैं, उदाहरण के लिए:

$ matrices.exe 8 14
...
valid i: 1650223

तब से 1650223 = 0b110010010111000101111, प्रश्न में मैट्रिक्स है:

0 0 1 1 1 0 1 0 0 1 0 0 1 1
0 ...
1 ...
0
1
1
1
1

अगर किसी के हाथ में 8 कोर और समय के साथ कुछ समय के लिए इसे चलाना चाहते हैं, तो मुझे लगता है कि कुछ अच्छी चीजें हो सकती हैं :)

---

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

/*
 * BEGIN WIKIPEDIA CODE
 */
const long long m1  = 0x5555555555555555; //binary: 0101...
const long long m2  = 0x3333333333333333; //binary: 00110011..
const long long m4  = 0x0f0f0f0f0f0f0f0f; //binary:  4 zeros,  4 ones ...
const long long m8  = 0x00ff00ff00ff00ff; //binary:  8 zeros,  8 ones ...
const long long m16 = 0x0000ffff0000ffff; //binary: 16 zeros, 16 ones ...
const long long m32 = 0x00000000ffffffff; //binary: 32 zeros, 32 ones
const long long hff = 0xffffffffffffffff; //binary: all ones
const long long h01 = 0x0101010101010101; //the sum of 256 to the power of 0,1,2,3...
//This uses fewer arithmetic operations than any other known
//implementation on machines with fast multiplication.
//It uses 12 arithmetic operations, one of which is a multiply.
long long hamming(long long x) {
    x -= (x >> 1) & m1;             //put count of each 2 bits into those 2 bits
    x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits
    x = (x + (x >> 4)) & m4;        //put count of each 8 bits into those 8 bits
    return (x * h01)>>56;  //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ...
}
/*
 * END WIKIPEDIA CODE
 */

int main ( int argc, char *argv[] ) {
    int height;
    int width;

    sscanf(argv[1], "%d", &height);
    sscanf(argv[2], "%d", &width);

    #pragma omp parallel for
    for (
        /*
         * We know that there are 2^(h+w-1) T-matrices, defined by the entries
         * in the first row and first column. We'll let the long long i
         * represent these entries, with 1s represented by set bits.
         *
         * The first (0) and last (1) matrix we will ignore.
         */
        long long i = 1;
        i < (1 << (height+width-1))-1;
        i++
    ) {
        // Flag for keeping track as we go along.
        int isvalid = 1;

        /*
         * Start by representing the matrix as an array of columns, with each
         * non-zero matrix entry as a bit. This allows us to construct them and
         * check equality very quickly.
         */
        long *cols = malloc(sizeof(long)*width);
        long colmask = (1 << height)-1;
        for (int j = 0; j < width; j++) {
            cols[j] = (i >> j) & colmask;
            if (cols[j] == 0) {
                //check no zero rows
                isvalid = 0;
            } else {
                //check no duplicate rows
                for (int k = 0; k < j; k++) {
                    if (cols[j] == cols[k]) {
                        isvalid = 0;
                    }
                }
            }
        }

        if (isvalid == 1) {
            /*
             * We'll also represent the matrix as an array of rows, in a
             * similar manner.
             */
            long *rows = malloc(sizeof(long)*height);
            long rowmask = (1 << width)-1;
            for (int j = 0; j < height; j++) {
                rows[j] = (i >> j) & rowmask;
            }

            int *sums[(1 << width)];
            for (long j = 0; j < 1<<width; j++) {
                sums[j] = (int*)malloc(sizeof(int)*height);
            }

            for (
                /*
                 * The powerset of columns has size 2^width. Again with the
                 * long; this time each bit represents whether the
                 * corresponding row is a member of the subset. The nice thing
                 * about this is we can xor the permutation with each row,
                 * then take the hamming number of the resulting number to get
                 * the sum.
                 */
                long permutation = 1;
                (isvalid == 1) && (permutation < (1 << width)-1);
                permutation ++
            ) {
                for (int j = 0; j < height; j++) {
                    sums[permutation][j] = hamming( rows[j] & permutation);
                }
                for (int j = permutation-1; (isvalid == 1) && (j > -1); j--) {
                    if (memcmp(sums[j], sums[permutation], sizeof(int)*height) == 0) {
                        isvalid = 0;
                    }
                }
            }

            for (long j = 0; j < 1<<width; j++) {
                free(sums[j]);
            }

            free(rows);

        }

        if (isvalid == 1) {
            printf ("valid i: %ld\n", i);
        }

        free(cols);
    }

    return 0;
}

Comments

मुझे अलेक्जेंडर- brett.c: फंक्शन 'मेन': अलेक्जेंडर- brett.c: 107: 21: चेतावनी: फंक्शन 'मेम्कंप' की अंतर्निहित घोषणा sums [क्रमपरिवर्तन], आकार (इंट) * ऊंचाई) == 0) {^ अलेक्जेंडर- brett.c: 122: 13: चेतावनी: प्रारूप '% ld' प्रकार के तर्क को 'लंबे समय तक' की अपेक्षा रखता है, लेकिन तर्क 2 का प्रकार है लंबे लंबे int '[-रूपत =] प्रिंटफ ("मान्य i:% ld \ n", i);

कब तक ./alexander-brett 8 14 आप के लिए ले?

हाय लेम्बिक, 8 14 को क्वाड कोर मशीन पर मेरे लिए एक घंटे में 5 उत्तर मिले। मैं उन हेडर के साथ खिड़कियों पर संकलित करने में कामयाब रहा, अगर मेमकैंप गायब हो गया, तो यह अजीब होगा ...

— एलेक्जेंडर-ब्रेट

stackoverflow.com/questions/7132039/…

मैंने 7 12 के साथ आपके कोड की कोशिश की और इसका एक जवाब है कि यह आउटपुट है valid i: 7481। अजगर बिन (7481) में 0b1110100111001 है जो लंबे समय से पर्याप्त नहीं है। कोई अंदाज़ा है कि क्या चल रहा है?