Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> C++

उन जोड़ों की संख्या की गणना करें जिनके कॉलम योग C++ में पंक्ति योग से अधिक हैं


हमें NXN आकार का मैट्रिक्स दिया गया है। लक्ष्य इंडेक्स (i,j) के सभी मान्य युग्मों की गिनती इस प्रकार ज्ञात करना है कि कॉलम j का योग तत्व पंक्ति i के तत्वों के योग से अधिक हो।

हम मैट्रिक्स को पार करके ऐसा करेंगे और प्रत्येक पंक्ति और स्तंभ के तत्वों के योग की गणना करेंगे।

पंक्तियों में प्रत्येक के तत्वों का योग [N] और प्रत्येक स्तंभ के तत्वों का योग colsum[N] में संग्रहीत करें।

अब रोसम [i] और कोलसम [j] के जोड़े बनाएं और जांचें कि क्या colsum[j]>rowsum[i]. अगर सही वेतन वृद्धि ऐसे जोड़े के लिए गिना जाता है।

आइए उदाहरणों से समझते हैं।

Input-: matrix= {
   { 1,2,0,1},
   { 3,3,0,2},
   { 1,3,0,2},
   { 3,0,0,2} 
};

आउटपुट - मान्य युग्मों की संख्या - 9

स्पष्टीकरण -

Rowsum[0]= 1+2+0+1=5 Colsum[0]= 1+3+1+3=8
Rowsum[1]=3+3+0+2=8 Colsum[1]= 2+3+3+0=8
Rowsum[2]= 1+3+0+2=6 Colsum[2]= 0+0+0+0=0
Rowsum[3]=3+0+0+2=5 Colsum[3]= 1+2+2+2=7
Pairs of (i,j) such that rowsum[i] < colsum[j].
(0,0), (0,1), (0,3), (2,0), (2,1), (2,3), (3,0) (3,1), (3,3)

इनपुट -

Arr[]= { {1,1,1}, {1,1,1}, {1,1,1} } N=3

आउटपुट - मान्य युग्मों की संख्या - 0

स्पष्टीकरण -

Rowsum[0]= 1+1+1=3 Colsum[0]= 1+1+1=3
Rowsum[1]= 1+1+1=3 Colsum[1]= 1+1+1=3
Rowsum[2]= 1+1+1=3 Colsum[2]= 1+1+1=3
No pairs possible where rowsum[i]<colsum[j]

नीचे दिए गए प्रोग्राम में इस्तेमाल किया गया तरीका इस प्रकार है

  • हम एक पूर्णांक सरणी लेते हैं Arr[] यादृच्छिक संख्याओं के साथ आरंभ किया गया।

  • एक वैरिएबल n लें जो Arr[] की लंबाई को स्टोर करता है।

  • फंक्शन काउंटपेयर्स (int arr[], int n) एक ऐरे लेता है, इसकी लंबाई इनपुट के रूप में और उन युग्मों को लौटाता है जो मान्य हैं और वांछित शर्तों को पूरा करते हैं।

  • हम दो सरणियाँ लेते हैं rowsum[n] और colsum[n].

  • ट्रैवर्स मैट्रिक्स और पंक्ति i और कॉलम j के योग की गणना करने के लिए arr[i][j] को rowsum[i] और colsum[j] में जोड़ें।

  • अब दो फॉर लूप्स का उपयोग करके ट्रैवर्स एरेज़ कोलसम [] और रोसम []।

  • यदि कोई colsum[j]>rowsum[i]. वेतन वृद्धि की संख्या।

  • परिणाम के रूप में गिनती लौटाएं।

उदाहरण

#include <bits/stdc++.h>
using namespace std;
int countPairs(int arr[][3], int n){
   // Count of pairs
   int count = 0;
   int rowsum[n]={0};
   int colsum[n]={0};
   int i,j;
   for (i = 0; i < n; i++){
      for (j = 0; j < n; j++){
         rowsum[i]+=arr[i][j];
         colsum[j]+=arr[i][j];
      }
   }
   for(i=0;i<n;i++){
      for(j=0;j<n;j++)
         if(colsum[j]>rowsum[i])
            { count++; }
   }
   return count;
}
int main(){
   int Arr[][3] = { {1,3,5},{2,4,6},{3,5,7} };
   int side=3;
   cout <<endl<<"Count of number of pairs : "<< countPairs(Arr, side);
   return 0;
}

आउटपुट

यदि हम उपरोक्त कोड चलाते हैं तो यह निम्न आउटपुट उत्पन्न करेगा -

Count of number of pairs : 4

  1. C++ का उपयोग करके K से कम योग वाले उप-सरणियों की संख्या ज्ञात कीजिए

    इस लेख में, हम C++ का उपयोग करके K से कम योग वाले उप-सरणियों की संख्या का पता लगाएंगे। इस समस्या में, हमारे पास एक सरणी arr[] और एक पूर्णांक K है। तो अब हमें ऐसे उप-सरणियाँ ढूँढ़नी होंगी जिनका योग K से कम है। यहाँ उदाहरण है - Input : arr[] = {1, 11, 2, 3, 15} K = 10 Output : 4 {1}, {2}, {3} and {2,

  1. C++ में N के अंकों के योग से अधिक अंकों के योग के साथ N से कम की सबसे बड़ी संख्या

    इस ट्यूटोरियल में, हम एक प्रोग्राम लिखने जा रहे हैं जो N से कम संख्या को n के अंकों के योग से अधिक अंकों के योग के साथ पाता है। आइए समस्या को हल करने के लिए चरणों को देखें। अंकों का योग ज्ञात करने के लिए एक फ़ंक्शन लिखें। आरंभ करें n. एक लूप लिखें जो n - 1 से 1 तक पुनरावृत्त हो। वर्तमान संख्या के

  1. उन नोड्स की गणना करें जिनका योग X के साथ C++ में एक फाइबोनैचि संख्या है

    एक बाइनरी ट्री दिया गया है जिसके नोड्स के भार संख्याओं के रूप में हैं। लक्ष्य उन नोड्स की संख्या का पता लगाना है जिनका वजन इस तरह है कि संख्या एक फाइबोनैचि संख्या है। फाइबोनैचि श्रृंखला में संख्याएं हैं:0, 1, 1, 2, 3, 5, 8, 13…। n वीं संख्या का योग है (n−1)वें और (n−2)वें। अगर वजन 13 है तो यह एक फाइ