C++ में रेंज के बीच उन संख्याओं की गिनती जिनके सभी अंक गैर-शून्य हैं, अंकों का योग N है और संख्या M से विभाज्य है

हमें दो संख्याएं START और END दी गई हैं जो संख्याओं की एक रेंज को परिभाषित करती हैं। लक्ष्य रेंज [START, END] में उन सभी संख्याओं को ढूंढना है जिनमें कोई अंक 0 नहीं है और जिनके अंकों का योग दिए गए संख्या N के बराबर है। साथ ही संख्याएं M से विभाज्य हैं।

हम START से END तक संख्याओं को पार करके और प्रत्येक संख्या के लिए व्हाइल लूप का उपयोग करके उसके अंकों का योग गिनेंगे (केवल तभी यदि सभी अंक गैर-शून्य हैं)। यदि यह योग N के बराबर है और संख्या M से विभाज्य है, तो काउंट बढ़ाएं।

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

इनपुट

START=1 END=100 N=9 M=6

आउटपुट

अंकों का योग N और M से विभाज्य वाली संख्याएं: 4

व्याख्या

संख्याएं 18, 36, 54, 72 का अंकों का योग=9 है और 6 से विभाज्य हैं। किसी में भी 0 अंक नहीं है।

इनपुट

START=100 END=200 N=10 M=2

आउटपुट

अंकों का योग N और M से विभाज्य वाली संख्याएं: 4

व्याख्या

संख्याएं 118, 136, 154, 172 का अंकों का योग=10 है और 2 से विभाज्य हैं। किसी में भी 0 अंक नहीं है।

नीचे दिए गए प्रोग्राम में प्रयुक्त दृष्टिकोण

• हम पूर्णांक START, END, N और M लेते हैं।

• फंक्शन digitSum(int start, int end, int n, int m) ऐसे नंबरों की गिनती लौटाता है जिनका अंकों का योग=n है, m से विभाज्य हैं और सभी अंक गैर-शून्य हैं।

• ऐसी संख्याओं के लिए प्रारंभिक वेरिएबल काउंट 0 लें।

• वेरिएबल digsum को 0 लें

• वेरिएबल फ्लैग को 0 लें।

• फॉर लूप का उपयोग करके संख्याओं की रेंज को पार करें। i=start से i=end

• अब प्रत्येक संख्या num=i के लिए, यदि num%m==0 (m से विभाज्य) तो आगे बढ़ें।

• व्हाइल लूप का उपयोग करके जांचें कि संख्या >0 है। और अंक ढूंढें।

• digit=num%10। यदि अंक गैर-शून्य है तो digsum+=digit की गणना करें। अगले अंक को जोड़ने के लिए num=num/10 कम करें। यदि कोई अंक 0 है तो फ्लैग=0 सेट करें और व्हाइल लूप तोड़ें

• व्हाइल के अंत में, जांचें यदि (digsum == n और फ्लैग==1)। यदि सत्य तो काउंट बढ़ाएं।

• अब i को m से बढ़ाएं (m के गुणकों में)।

• सभी लूप्स के अंत में काउंट में शर्त को संतुष्ट करने वाली कुल संख्या होगी।

• परिणाम के रूप में काउंट लौटाएं।

उदाहरण

#include <bits/stdc++.h>
using namespace std;

int digitSum(int start, int end, int n, int m) {
   int count = 0;
   int digsum = 0;
   int flag = 0;
   
   for (int i = start; i <= end; i++) {
      int num = i;
      digsum = 0;
      flag = 0;
      
      if (num % m == 0) {
         while (num > 0) {
            int digit = num % 10;
            if (digit == 0) {
               flag = 0;
               break;
            }
            digsum += num % 10; // अंकों का योग
            num = num / 10;
            flag = 1;
         }
         if (digsum == n && flag == 1) {
            count++;
            cout << i << " ";
         }
         i += m; // अब m के गुणकों में बढ़ाएं
         i--;    // फॉर लूप में i++ है
      }
   }
   return count;
}

int main() {
   int START = 1;
   int END = 100;
   int N = 9;
   int M = 6;
   cout << "अंकों का योग N और M से विभाज्य वाली संख्याएं: " << digitSum(START, END, N, M);
   return 0;
}

आउटपुट

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

अंकों का योग N और M से विभाज्य वाली संख्याएं: 4

अनुकूलन नोट

बड़ी रेंज के लिए, डिजिट DP का उपयोग करके O(log END) समय में हल किया जा सकता है।