C में N चालों के बाद सरणी में 1s की संख्या गिनना

समस्या विवरण

हमें आकार N की एक सरणी दी गई है। सरणी में प्रारंभ में सभी 0 हैं। N चालों के बाद सरणी में 1 की संख्या गिनने का कार्य है। प्रत्येक Nवीं चाल का एक नियम है:

• 1ली चाल - स्थान 1, 2, 3, 4... पर तत्व बदलें
• 2री चाल - स्थान 2, 4, 6, 8... पर तत्व बदलें
• 3री चाल - स्थान 3, 6, 9, 12... पर तत्व बदलें

अंतिम सरणी में 1 की संख्या गिनें।

उदाहरण 1

इनपुट: Arr[] = {0,0,0,0}, N=4

आउटपुट: N चालों के बाद सरणी में 1s की संख्या: 2

व्याख्या: चालों के बाद सरणी:

चाल 1: {1,1,1,1}
चाल 2: {1,0,1,0}
चाल 3: {1,0,0,1}  // नोट: मूल में 3 लिखा था, सही है 1
चाल 4: {1,0,0,1}
अंतिम सरणी में 1 की संख्या: 2

उदाहरण 2

इनपुट: Arr[] = {0,0,0,0,0,0}, N=6

आउटपुट: N चालों के बाद सरणी में 1s की संख्या: 2

व्याख्या: चालों के बाद सरणी (7 तत्व दिखाए गए हैं लेकिन N=6):

चाल 1: {1,1,1,1,1,1}
चाल 2: {1,0,1,0,1,0}
चाल 3: {1,0,0,1,0,0}
चाल 4: {1,0,0,0,1,0}
चाल 5: {1,0,0,0,0,1}
चाल 6: {1,0,0,0,0,0}
अंतिम सरणी में 1 की संख्या: 1 (मूल में 2 लिखा था, सही है 1)

दृष्टिकोण

• पूर्णांक सरणी Arr[] को 0 से आरंभ करें और पूर्णांक N लें।
• फ़ंक्शन Onecount Arr[] और इसका आकार N लेता है और N चालों के बाद अंतिम सरणी में 1 की संख्या लौटाता है।
• for लूप 1 से सरणी के अंत तक चलता है।
• प्रत्येक i iवीं चाल को दर्शाता है।
• नेस्टेड for लूप 0वें इंडेक्स से सरणी के अंत तक चलता है।
• प्रत्येक iवीं चाल के लिए, यदि इंडेक्स j, i का गुणक है (j%i==0), तो उस स्थान पर 0 को 1 से बदलें।
• यह प्रक्रिया प्रत्येक i के लिए सरणी के अंत तक चलती है।
• नोट: इंडेक्स i=1, j=1 से शुरू होता है लेकिन सरणी इंडेक्स 0 से N-1 तक होते हैं। इस कारण arr[j-1] प्रत्येक बार परिवर्तित होता है।
• अंत में पूरी सरणी को फिर से पार करें और 1 की संख्या गिनकर count में संग्रहीत करें।
• count को वांछित परिणाम के रूप में लौटाएं।

C प्रोग्राम उदाहरण

#include <stdio.h>

int Onecount(int arr[], int N) {
    for (int i = 1; i <= N; i++) {
        for (int j = i; j <= N; j++) {
            // यदि j, i से विभाज्य है
            if (j % i == 0) {
                if (arr[j - 1] == 0)
                    arr[j - 1] = 1; // 0 को 1 में बदलें
                else
                    arr[j - 1] = 0; // 1 को 0 में बदलें
            }
        }
    }
    int count = 0;
    for (int i = 0; i < N; i++)
        if (arr[i] == 1)
            count++; // 1 की संख्या गिनें
    return count;
}

int main() {
    int size = 6;
    int Arr[6] = {0};
    printf("Number of 1s in the array after N moves: %d", Onecount(Arr, size));
    return 0;
}

आउटपुट

Number of 1s in the array after N moves: 2

नोट: यह समस्या वास्तव में पूर्ण वर्ग संख्या वाले स्थानों पर 1 होने के बराबर है (क्योंकि केवल पूर्ण वर्गों के भाजकों की संख्या विषम होती है)।