एल्गोरिदम on kenji.blog

अभाज्य संख्याएँ उत्पन्न करने के लिए C कोड

Sat, 24 Aug 2024 09:38:10 +0900

नीचे एक सरल C कोड दिया गया है जो एक निर्दिष्ट सीमा के भीतर अभाज्य संख्याएँ (prime numbers) उत्पन्न करता है। इस उदाहरण में, हम 1 से n तक की अभाज्य संख्याओं को सूचीबद्ध करते हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <stdio.h>
#include <stdbool.h>

bool isPrime(int num) {
 if (num <= 1) return false;
 if (num <= 3) return true;
 if (num % 2 == 0 || num % 3 == 0) return false;

 for (int i = 5; i * i <= num; i += 6) {
 if (num % i == 0 || num % (i + 2) == 0) return false;
 }
 return true;
}

void printPrimes(int n) {
 printf("2 ");
 for (int i = 3; i <= n; i += 2) {
 if (isPrime(i)) {
 printf("%d ", i);
 }
 }
 printf("\n");
}

int main() {
 int n;
 printf("अभाज्य संख्याएँ उत्पन्न करने के लिए सीमा का अधिकतम मान दर्ज करें: ");
 scanf("%d", &n);
 printf("1 से %d तक की अभाज्य संख्याएँ निम्नलिखित हैं:\n", n);
 printPrimes(n);
 return 0;
}

यह कोड इस प्रकार काम करता है:

isPrime फ़ंक्शन: यह निर्धारित करता है कि दी गई संख्या अभाज्य है या नहीं। दक्षता के लिए, यह पहले जाँचता है कि क्या यह 2 और 3 से विभाज्य है, और फिर 6 के गुणकों में जाँच के साथ आगे बढ़ता है।
printPrimes फ़ंक्शन: निर्दिष्ट सीमा के भीतर अभाज्य संख्याएँ आउटपुट करता है। 2 सबसे पहले आउटपुट होता है, और फिर केवल विषम संख्याओं की जाँच की जाती है।
main फ़ंक्शन: उपयोगकर्ता से सीमा का अधिकतम मान दर्ज करने के लिए कहता है, और उस सीमा के भीतर अभाज्य संख्याएँ आउटपुट करता है।

यदि आप इस कोड को संकलित और चलाते हैं, तो निर्दिष्ट सीमा के भीतर अभाज्य संख्याएँ प्रदर्शित होंगी।

Mathematica के साथ ट्रैवलिंग सेल्समैन समस्या को हल करना

Wed, 12 Oct 2022 19:05:58 +0900

Mathematica के साथ ट्रैवलिंग सेल्समैन समस्या को हल करना

समस्या

電車でこんな広告を見かけました😁📸 pic.twitter.com/iXEgvtXrpL
— 早稲田大学早水桃子研究室 (@hayamizu_lab) October 11, 2022

उपाय

1

d=SparseArray[{{1,2}->10,{2,1}->10,{1,5}->15,{5,1}->15,{1,4}->12,{4,1}->12,{1,3}->20,{3,1}->20,{2,5}->10,{5,2}->10,{3,4}->10,{4,3}->10,{3,8}->30,{8,3}->30,{3,7}->20,{7,3}->20,{3,6}->25,{6,3}->25,{4,5}->15,{5,4}->15,{4,8}->20,{8,4}->20,{5,9}->18,{9,5}->18,{5,8}->15,{8,5}->15,{6,7}->5,{7,6}->5,{7,8}->35,{8,7}->35,{8,9}->12,{9,8}->12},{9,9},Infinity];

SparseArray फ़ंक्शन का उपयोग करके एक मैट्रिक्स बनाएं। प्रत्येक तत्व उस तत्व की पंक्ति और कॉलम में शहरों के बीच की दूरी का प्रतिनिधित्व करता है। उदाहरण के लिए, पहले तत्व {1,2}->10 का अर्थ है कि 1 और 2 के बीच की दूरी 10 है। दूसरा-से-अंतिम तत्व {9,9} मैट्रिक्स के आकार को इंगित करता है, और अंतिम तत्व Infinity का अर्थ है कि अनिर्दिष्ट शहरों के बीच पथ की लंबाई अनंत है। दूसरे शब्दों में, इसका मतलब है कि कोई रास्ता नहीं है।

1

{len,tour}=FindShortestTour[{1,2,3,4,5,6,7,8,9},DistanceFunction->(d[[#1,#2]]&)]

FindShortestTour फ़ंक्शन के साथ, आप ट्रैवलिंग सेल्समैन समस्या को आसानी से हल कर सकते हैं। {1,2,3,4,5,6,7,8,9} शहर के नंबरों को दर्शाता है। DistanceFunction->(d[[#1,#2]]&) मैट्रिक्स d पास करता है, जो शहरों के बीच की दूरी को दर्शाता है।

आउटपुट

1

{137, {1, 2, 5, 9, 8, 7, 6, 3, 4}}

आउटपुट सबसे छोटी दूरी और उसके संबंधित मार्ग को दर्शाता है। सबसे छोटी दूरी 137 है, और मार्ग 1→2→5→9→8→7→6→3→4→1 है। ABC वर्णमाला क्रम में बदलने पर, यह A, B, E, I, H, G, F, C, D बन जाता है।

Rust में अभाज्य संख्याओं की गणना

Fri, 09 Sep 2022 07:08:49 +0900

मैंने Rust में अभाज्य संख्याओं की गणना करने के लिए एक प्रोग्राम लिखा है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


fn main() {
 let max = 1000;
 let mut primes = vec![2];
 let mut n = 3;
 loop {
 let mut is_prime = true;
 for p in &primes {
 if n % p == 0 {
 is_prime = false;
 break;
 }
 }
 if is_prime {
 primes.push(n);
 }
 n += 2;
 if n > max {
 break;
 }
 }
 for p in &primes {
 println!("{}", p);
 }
}