इस लेख में, हम समझाएंगे कि C++ में एक समकोण त्रिभुज बनाने वाले कर्ण और क्षेत्रफल के संभावित युग्मों की संख्या को कैसे हल किया जाए।
हमें कर्ण के सभी संभावित युग्मों की संख्या और क्षेत्रफल ( H, A ) निर्धारित करने की आवश्यकता है ताकि H को कर्ण के रूप में और A को क्षेत्र के रूप में समकोण त्रिभुज बनाया जा सके।
इस उदाहरण में -
x =समकोण त्रिभुज का आधार
y =समकोण त्रिभुज की ऊँचाई
H =समकोण त्रिभुज का कर्ण
हम समकोण त्रिभुज का क्षेत्रफल जानते हैं,
ए =(एक्स * वाई) / 2
या
4 * ए 2 =(एक्स * वाई) 2 …… (1)
हम यह भी जानते हैं
x 2 + y 2 =एच 2 …… (2)
हल करना (1) और (2)
4 * ए 2 =x 2 (एच 2 - x 2 )
द्विघात समीकरण को x2 में हल करना और D (विभेदक)>=0 ( x के अस्तित्व के लिए)
रखनाहमें मिलता है, H2>=4 * A (समकोण त्रिभुज के अस्तित्व के लिए शर्त)
यहाँ उदाहरण है -
Input : array H[ ] = { 3, 6, 8 } : A[ ] = { 2, 31, 12 }
Output : 4
Explanation : possible pairs of Hypotenuse and Area ( H, A ) are ( 3, 2 ), ( 6, 2 ), ( 8, 2 ) and ( 8, 12 ).
Input : array H[ ] = { 2, 5, 9 } : A[ ] = { 3, 11, 7 }
Output : 4
Explanation : possible pairs of Hypotenuse and Area ( H, A ) are possible pairs of Hypotenuse and Area ( H, A ) are ( 5, 3 ), ( 9, 3 ), ( 9, 11 ) and ( 9, 7 ). समाधान खोजने के लिए दृष्टिकोण
अब हम दिए गए कार्य को करने के लिए दो अलग-अलग विधियों का उपयोग करेंगे -
क्रूर फ़ोर्स अप्रोच
इस सरल दृष्टिकोण में, हम कर्ण और क्षेत्रफल ( H, A ) के सभी संभावित जोड़े पाते हैं, जाँचते हैं कि क्या वे शर्त को पूरा करते हैं, h2>=4 * A या नहीं, और इस शर्त को पूरा करने वाले प्रत्येक जोड़े को गिनें।
उदाहरण
#include <iostream>
using namespace std;
int main(){
int H[ ] = { 2,5,9}; // array of hypotenuse
int s1 = sizeof(H)/sizeof(H[0]);
int A[ ] = { 3, 11, 7};// array of area
int s2 = sizeof(A)/sizeof(A[0]);
int count = 0;// initialising count to 0
// finding all possible pairs
for (int i = 0; i < s1; i++) {
for (int j = 0; j < s2; j++) {
// checking whether current pair satisfies the condition
if (H[i] * H[i] >= 4 * A[j]){
count++;
}
}
}
cout << "Number of possible pairs of ( H, A ): " << count ;
return 0;
} आउटपुट
Number of possible pairs of ( H, A ): 4
स्पष्टीकरण
इस कोड में, हम समीकरण को संतुष्ट करने वाले युग्मों की संख्या को बनाए रखने के लिए गणना चर का उपयोग करते हैं और (H, A) जोड़े बनाने के लिए नेस्टेड लूप का उपयोग करते हैं। इस कोड की समय जटिलता ओ (एन 2) है जो एक कुशल दृष्टिकोण नहीं है। आइए दूसरे दृष्टिकोण को समझते हैं।
कुशल तरीका
इस दृष्टिकोण में, हम पहले दोनों सरणियों को आरोही क्रम में क्रमबद्ध कर रहे हैं, फिर हम H 2 की जाँच करने पर अधिकतम क्षेत्र खोजने के लिए किसी भी कर्ण की लंबाई का पता लगा रहे हैं।> 4 * ए ।
उदाहरण
#include <bits/stdc++.h>
using namespace std;
int main (){
int H[] = { 2, 5, 9 };
int s1 = sizeof (H) / sizeof (H[0]);
int A[] = { 3, 11, 7 };
int s2 = sizeof (A) / sizeof (A[0]);
int count = 0;
// Sorting both the arrays
sort (H, H + s1);
sort (A, A + s2);
int temp = -1;
for (int i = 0; i < s1; i++){
// Applying binary search for
// every Hypotenuse Length
int flag1 = 0;
int flag2 = s2 - 1;
while (flag1 <= flag2){
int mid = flag1 + (flag2 - flag1) / 2;
if ((H[i] * H[i]) >= (4 * A[mid])){
temp = mid;
flag1 = mid + 1;
}
else{
flag2 = mid - 1;
}
}
if (temp != -1){// Check if we get any possible area
count += temp + 1;
}
}
cout << "Number of possible pairs of (H, A): " << count;
return 0;
} आउटपुट
Number of possible pairs of ( H, A ): 4
उपरोक्त कोड की व्याख्या
इस कोड में, हम पहले दोनों सरणियों को आरोही क्रम में क्रमबद्ध कर रहे हैं, और फिर हम अधिकतम क्षेत्र खोजने के लिए बाइनरी खोज का उपयोग करके हर संभव लंबाई की जाँच कर रहे हैं।
मान लें कि क्षेत्र A[ ] की सरणी में अनुक्रमणिका 3 पर अधिकतम क्षेत्रफल पाया जाता है, तो अनुक्रमणिका तीन से कम के सभी क्षेत्र भी समीकरण को संतुष्ट करेंगे ताकि हम 3 संभावित जोड़े बना सकें।
निष्कर्ष
इस लेख में, हमने एक समकोण त्रिभुज बनाने के लिए उपयोग किए जाने वाले कर्ण और क्षेत्रफल युग्मों की संख्या ज्ञात करने के लिए एक समस्या का समाधान किया। हमने ब्रूट फ़ोर्स दृष्टिकोण लागू किया, जिसकी समय जटिलता O(n 2 . थी) ), और कुशल दृष्टिकोण, जिसकी समय जटिलता O(s1 log(s2)) थी। आशा है कि आपको यह लेख मददगार लगा होगा।