दो वेक्टर स्थानों के कार्टेशियन उत्पाद
Aug 16 2020
कुछ दिनों पहले मुझे एक दिलचस्प समस्या मिली, जो निम्नलिखित पढ़ती है:
दो सदिश स्थानों को देखते हुए इसके कार्टेशियन उत्पाद के परिणामस्वरूप सेट उत्पन्न होता है। \ start {इकट्ठा} \ text {Let:} \ mathcal {V}, \ mathcal {W} \ text {be वेक्टर रिक्त स्थान} \\ \ mathcal {V} \ गुना \ mathcal {w} = \ {{(v, w ) \ mid v \ in \ mathcal {V} \ land w \ in \ mathcal {W} \} \ अंत {इकट्ठा}
- संकेत 1: एक वेक्टर स्थान वैक्टर नामक तत्वों का एक समूह है जो कुछ गुणों को पूरा करता है
- संकेत 2: परिमित वेक्टर रिक्त स्थान के लिए समाधान डिज़ाइन करें
- टिप 1: संरचनाओं का उपयोग करने की अनुशंसा की जाती है
- बाधा: आपको किसी भी stl वर्ग का उपयोग करने से मना किया गया है
मैंने इस समस्या को अगले दृष्टिकोण से हल किया:
struct vector_pair
{
double *vector_a;
double *vector_b;
size_t a_dimension;
size_t b_dimension;
};
struct cartesian_product_set
{
vector_pair *pairs;
size_t pairs_number;
};
cartesian_product_set vector_spaces_cartesian_product(double **space_v, size_t v_vectors,
size_t v_dimension, double **space_w, size_t w_vectors, size_t w_dimension)
{
cartesian_product_set product_set{new vector_pair[v_vectors * w_vectors], v_vectors * w_vectors};
for (size_t i = 0, j, k = 0; i < v_vectors; i++)
for (j = 0; j < w_vectors; j++)
product_set.pairs[k++] = vector_pair{space_v[i], space_w[j], v_dimension, w_dimension};
return product_set;
}
यदि संभव हो तो मैं इस कोड को कैसे सुधार सकता हूं?
धन्यवाद।
जवाब
2 cauon Aug 18 2020 at 15:28
- कब्ज
- जहाँ संभव हो पॉइंटर्स के पक्ष में संदर्भों का उपयोग करें
- तथ्य यह है कि आप उस मेमोरी को मुक्त करने के लिए दायित्व छोड़ देते हैं जिसे आप कॉलर को आवंटित करते हैं, आमतौर पर एक अच्छा अभ्यास नहीं होता है
- आपके कोड में एक सामान्य पैटर्न यह है कि आपके पास सरणियों और उनकी लंबाई के लिए संकेत हैं - उन्हें बंडल करने के लिए एक संरचना क्यों नहीं बनाई गई है?
- जब आप वास्तव में सूचकांक (जो आप अपने उदाहरण में नहीं करते हैं) की आवश्यकता नहीं होने पर पुनरावृत्तियों और रेंज-आधारित-के लिए छोरों का उपयोग करने का प्रयास करें
- चूंकि हम वास्तव में वेक्टर अंतरिक्ष में तत्वों के प्रकार के बारे में परवाह नहीं करते हैं, इसलिए आप अपने एल्गोरिथ्म को सामान्य बनाने के लिए टेम्पलेट्स का उपयोग कर सकते हैं
और यह देखने के लिए कि क्या यह संभव होगा, मैंने एल्गोरिथ्म के संकलन-समय संस्करण के साथ आने की कोशिश की:
template<typename T>
struct pair
{
T first;
T second;
};
template<std::size_t N, typename T>
struct cvp
{
pair<T> pairs[N];
};
template <typename T, size_t NV, size_t NW>
auto get_cvp(const T (&vs)[NV], const T (&ws)[NW])
{
cvp<NV*NW, T> result;
auto it_pairs = std::begin(result.pairs);
for (const auto v : vs) {
for (const auto w : ws) {
*(it_pairs++) = {v, w};
}
}
return result;
}
आप यहाँ कोड की कोशिश कर सकते हैं: https://godbolt.org/z/e8GvEf