सी ++ में प्राइम के रूप में सम और विषम पदों पर अंकों के योग के बीच अंतर के साथ संख्या की गणना करें

दिए गए दो नंबर रेंज वैरिएबल के रूप में शुरू और खत्म होते हैं। लक्ष्य उन संख्याओं की संख्या ज्ञात करना है जो इस श्रेणी में हैं [प्रारंभ, अंत] और सम पर अंकों के योग और अभाज्य पदों पर अंकों के योग का अंतर है।

वह है (सम स्थिति पर अंकों का योग)-(विषम स्थान पर अंकों का योग) =एक अभाज्य संख्या

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

उदाहरण के लिए

इनपुट - प्रारंभ =230, अंत =270

आउटपुट - सम और विषम पदों पर अंकों के योग के बीच अंतर के साथ रेंज में संख्याओं की संख्या हैं:6

स्पष्टीकरण - 230 से 270 के बीच की संख्याएं जो इस शर्त को पूरा करती हैं:

240 (4-2 2 है), 250 (5-2 3 है), 251 (5-3 2 है), 261 (6-3 3 है), 262 (6-4 2 है), 270 (7-2 है) 5 है)।

ये सभी अंतर 2, 3 और 5 हैं जो अभाज्य हैं।

इनपुट - प्रारंभ =1101, अंत =1120

आउटपुट - सम और विषम स्थितियों पर अंकों के योग के बीच अंतर के साथ रेंज में संख्याओं की संख्या हैं:1

स्पष्टीकरण - 1101 से 1120 के बीच की संख्याएं इस शर्त को पूरा करती हैं:

1120 (3-1 2 है)। 2 प्रधान है।

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

इसमें हम एक गतिशील प्रोग्रामिंग दृष्टिकोण का उपयोग करते हैं और उन संख्याओं की संख्या को संग्रहीत करते हैं जिनमें सम और विषम स्थिति अंकों के योग का अभाज्य अंतर होता है। यह सरणी गिरफ्तारी [आकार] [90] [90] [2] होगी। यहां आकार 10 की शक्ति है। इसलिए इनपुट के रूप में सबसे बड़ी संख्या 10^आकार . होगी .

प्रत्येक रिकर्सिव कॉल टू फंक्शन चेक (इंट प्लेस, इंट ईव, इंट ओड, इंट टेम्प, वेक्टर vec) में हम 0 से 9 तक के अंकों को बाएं से दाएं रखकर एक नंबर बनाएंगे।

गिरफ्तारी [आकार] [x] [y] [अस्थायी] में, x, x तक रखे गए सम पदों पर अंकों के योग के लिए है और y, y तक रखे गए विषम अंकों के योग के लिए है। जांचें कि क्या आवश्यक अंतर प्राइम है या सरणी arr_2[] का उपयोग नहीं कर रहा है जो सभी अभाज्य संख्याओं को क्रम में 100 तक संग्रहीत करता है।

वेरिएबल को इनपुट के रूप में प्रारंभ और अंत लें।
100 तक के प्राइम्स के लिए ग्लोबल ऐरे arr[size][90][90][2] और array arr_2[] लें।
फ़ंक्शन चेक (इंट प्लेस, इंट ईव, इंट ओडी, इंट टेम्प, वेक्टर <इंट> वीईसी) अंक की वर्तमान स्थिति को स्थान के रूप में लेता है, ईव स्थिति अंकों का वर्तमान योग सम और विषम स्थिति अंक ओडी के रूप में, अस्थायी का मान और वेक्टर vec जिसमें अंक होते हैं।
यह arr[place][eve][od][temp] पर पुनरावर्ती रूप से मानों को पॉप्युलेट करता है।
वर्तमान तत्व के लिए प्रारंभिक मान को गिनती =0 के रूप में लें।
वर्तमान स्थिति के लिए, if(place ==vec.size()) का उपयोग करके जांचें कि स्थान अंतिम स्थिति है या नहीं। यदि हाँ, तो जांचें कि क्या वह स्थिति विषम या सम है।
अगर(vec.size() &1) परिणाम सही है तो वर्तमान स्थिति विषम है इसलिए पूर्व संध्या को od के साथ स्वैप करें क्योंकि यह विषम लंबाई संख्या है।
temp_2 को योग के अंतर के रूप में पूर्व संध्या के रूप में परिकलित करें।
लूप के लिए उपयोग करते हुए, arr_2 को पार करें और जांचें कि क्या temp_2 पाया गया है। यदि हाँ तो इसका प्रमुख। इसलिए 1 लौटाएं और 0 लौटाएं।
अगर arr[place][eve][od][temp] की गणना पहले ही कर ली गई है, तो यह -1 नहीं होगा, इसलिए इसे वापस कर दें।
यदि तापमान शून्य नहीं है तो temp_3=9 सेट करें। Temp_3 उस अंक की अधिकतम सीमा है जिसे हम रख सकते हैं। यदि यह 0 है तो vec[place] रखें अन्यथा संख्या पहले से छोटी है इसलिए कोई भी अंक मान लीजिए 9 रखें।
अंकों को 0 से temp_3 तक पार करें। यदि वर्तमान स्थिति विषम है तो अद्यतन करें set_odd =set_odd + i; (पिछली विषम स्थिति योग + वर्तमान अंक i)।
यदि वर्तमान स्थिति सम है तो अपडेट करें set_even =set_even + i; (पिछली सम स्थिति योग + वर्तमान अंक i)।
सेट काउंट +=चेक (प्लेस + 1, सेट_ईवन, सेट_ऑड, सेट_टेम्प, वीईसी); और वापसी गिरफ्तारी [स्थान] [पूर्व संध्या] [ओडी] [अस्थायी] =गिनती।
Function Place_prime(int val) संख्या वैल लेता है और एक वेक्टर vec उत्पन्न करता है जिसमें एलएसबी से एमएसबी तक इसके अंक होते हैं।
पूरी सरणी arr[][][][] -1 के साथ सेट करें।
गिनती लें =चेक (0, 0, 0, 0, vec) जो अंत में परिणाम लौटाएगा।
परिणाम के रूप में गिनती लौटाएं।

उदाहरण

#include <bits/stdc++.h>
using namespace std;
const int size = 18;
int arr[size][90][90][2];
//firt 100 prime Numbers
int arr_2[] = {
   2,
   3,
   5,
   7,
   11,
   13,
   17,
   19,
   23,
   29,
   31,
   37,
   43,
   47,
   53,
   59,
   61,
   67,
   71,
   73,
   79,
   83,
   89,
   97
};

int check(int place, int eve, int od, int temp, vector < int > vec) {
   int count;
   int temp_3;
   if (place == vec.size()) {
      if (vec.size() & 1) {
         swap(od, eve);
      }
      int temp_2 = eve - od;
      for (int i = 0; i < 24; i++) {
         if (temp_2 == arr_2[i]) {
            return 1;
         }
      }
      return 0;
   }
   if (arr[place][eve][od][temp] != -1) {
      int set = arr[place][eve][od][temp];
      return set;
   }
   if (temp) {
      temp_3 = 9;
   } else {
      temp_3 = vec[place];
   }
   for (int i = 0; i <= temp_3; i++) {
      int set_temp = temp;
      int set_even = eve;
      int set_odd = od;
      if (i < vec[place]) {
         set_temp = 1;
      }
      if (place & 1) {
         set_odd = set_odd + i;
      } else {
         set_even = set_even + i;
      }
      count += check(place + 1, set_even, set_odd, set_temp, vec);
   }
   return arr[place][eve][od][temp] = count;
}

int place_prime(int val) {
   vector < int > vec;

   while (val) {
      vec.push_back(val % 10);
      val = val / 10;
   }
   reverse(vec.begin(), vec.end());
   memset(arr, -1, sizeof(arr));
   int count = check(0, 0, 0, 0, vec);
   return count;
}
int main() {
   int start = 20, end = 80;
   int count = place_prime(end) - place_prime(start - 1);
   cout << "Count of Numbers in Range with difference between Sum of digits at even and odd positions as Prime are: " << count;
   return 0;
}

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

आउटपुट

Count of Numbers in Range with difference between Sum of digits at even and odd positions as Prime are: 15