C++ प्रोग्राम क्रिप्टेरिथमेटिक पहेलियाँ हल करने के लिए

क्रिप्टे-अरिथमेटिक समस्या में, कुछ अक्षरों का उपयोग अंक निर्दिष्ट करने के लिए किया जाता है। जैसे दस अलग-अलग अक्षर 0 से 9 तक के अंक मान रखते हैं ताकि अंकगणितीय संक्रियाएं सही ढंग से हो सकें। दो शब्द दिए गए हैं और एक अन्य शब्द उन दो शब्दों के जोड़ के उत्तर के रूप में दिया गया है। उदाहरण के रूप में हम कह सकते हैं कि दो शब्द 'BASE' और 'BALL', और परिणाम 'GAMES' है। अब यदि हम BASE और BALL को उनके प्रतीकात्मक अंकों से जोड़ने का प्रयास करते हैं, तो हमें उत्तर GAMES मिलेगा।

नोट - अधिकतम दस अक्षर होने चाहिए, अन्यथा इसे हल नहीं किया जा सकता।

इनपुट

यह एल्गोरिदम तीन शब्द लेगा।

आउटपुट

यह दिखाएगा कि कौन सा अक्षर 0-9 से कौन सी संख्या रखता है।

इस मामले के लिए यह इस तरह है।

एल्गोरिदम

इस समस्या के लिए, हम एक नोड परिभाषित करेंगे, जिसमें एक अक्षर और उसके संबंधित मान होंगे।

isValid(nodeList, count, word1, word2, word3)

इनपुट - नोड्स की सूची, नोड सूची में तत्वों की संख्या और तीन शब्द।
आउटपुट - सत्य यदि word1 और word2 के मान का योग word3 के मान के समान है।

Begin 
    m := 1 
    word1 के प्रत्येक अक्षर i के लिए दाएं से बाएं, करें 
        ch := word1[i] 
        नोडलिस्ट के सभी तत्वों j के लिए, करें 
            यदि nodeList[j].letter = ch, तो 
                ब्रेक 
            done 
        val1 := val1 + (m * nodeList[j].value) 
        m := m * 10 
    done 
    m := 1 
    word2 के प्रत्येक अक्षर i के लिए दाएं से बाएं, करें 
        ch := word2[i] 
        नोडलिस्ट के सभी तत्वों j के लिए, करें 
            यदि nodeList[j].letter = ch, तो 
                ब्रेक 
            done 
        val2 := val2 + (m * nodeList[j].value) 
        m := m * 10 
    done 
    m := 1 
    word3 के प्रत्येक अक्षर i के लिए दाएं से बाएं, करें 
        ch := word3[i] 
        नोडलिस्ट के सभी तत्वों j के लिए, करें 
            यदि nodeList[j].letter = ch, तो 
                ब्रेक 
            done 
        val3 := val3 + (m * nodeList[j].value) 
        m := m * 10 
    done 
    यदि val3 = (val1 + val2), तो 
        return true 
    return false 
End

permutation(nodeList, count, n, word1, word2, word3)

इनपुट - नोड्स की सूची, सूची में आइटम्स की संख्या, असाइन किए गए अक्षरों की संख्या और तीन शब्द।
आउटपुट - सत्य जब सभी अक्षर सही ढंग से मानों के साथ असाइन किए गए हों ताकि योग हल हो सके।

Begin 
    यदि n अक्षर असाइन किए गए हैं, तो 
        0 से 9 तक सभी अंकों i के लिए, करें 
            यदि अंक i उपयोग नहीं किया गया है, तो 
                nodeList[n].value := i 
                यदि isValid(nodeList, count, word1, word2, word3) = true 
                    नोडलिस्ट में सभी आइटम्स j के लिए, करें 
                        अक्षर और संबंधित मान दिखाएं। 
                    done 
                    return true 
            done 
        return false 
    0 से 9 तक सभी अंकों i के लिए, करें 
        यदि अंक i उपयोग नहीं किया गया है, तो 
            nodeList[n].value := i 
            i को उपयोग किया गया मार्क करें 
            यदि permutation(nodeList, count, n+1, word1, word2, word3), 
                return true 
            अन्यथा i को उपयोग नहीं किया गया मार्क करें 
        done 
    return false 
End

उदाहरण

#include <iostream> 
#include<vector> 
using namespace std; 

vector<int> use(10); 
struct node { 
    char letter; 
    int value; 
}; 

int isValid(node* nodeList, const int count, string s1, string s2, string s3) { 
    int val1 = 0, val2 = 0, val3 = 0, m = 1, j, i; 
    for (i = s1.length() - 1; i >= 0; i--){ 
        char ch = s1[i]; 
        for (j = 0; j < count; j++) 
            if (nodeList[j].letter == ch) 
                break; 
        val1 += m * nodeList[j].value; 
        m *= 10; 
    } 
    m = 1; 
    for (i = s2.length() - 1; i >= 0; i--){ 
        char ch = s2[i]; 
        for (j = 0; j < count; j++) 
            if (nodeList[j].letter == ch) 
                break; 
        val2 += m * nodeList[j].value; 
        m *= 10; 
    } 
    m = 1; 
    for (i = s3.length() - 1; i >= 0; i--){ 
        char ch = s3[i]; 
        for (j = 0; j < count; j++) 
            if (nodeList[j].letter == ch) 
                break; 
        val3 += m * nodeList[j].value; 
        m *= 10; 
    } 
    if (val3 == (val1 + val2)) 
        return 1; 
    return 0; 
} 

bool permutation(int count, node* nodeList, int n, string s1, string s2, string s3) { 
    if (n == count - 1){ 
        for (int i = 0; i < 10; i++){ 
            if (use[i] == 0){ 
                nodeList[n].value = i; 
                if (isValid(nodeList, count, s1, s2, s3) == 1){ 
                    cout << "Solution found: "; 
                    for (int j = 0; j < count; j++) 
                        cout << " " << nodeList[j].letter << " = " << nodeList[j].value; 
                    return true; 
                } 
            } 
        } 
        return false; 
    } 
    for (int i = 0; i < 10; i++){ 
        if (use[i] == 0){ 
            nodeList[n].value = i; 
            use[i] = 1; 
            if (permutation(count, nodeList, n + 1, s1, s2, s3)) 
                return true; 
            use[i] = 0; 
        } 
    } 
    return false; 
} 

bool solvePuzzle(string s1, string s2,string s3) { 
    int uniqueChar = 0; 
    int len1 = s1.length(); 
    int len2 = s2.length(); 
    int len3 = s3.length(); 
    vector<int> freq(26); 
    for (int i = 0; i < len1; i++) 
        ++freq[s1[i] - 'A']; 
    for (int i = 0; i < len2; i++) 
        ++freq[s2[i] - 'A']; 
    for (int i = 0; i < len3; i++) 
        ++freq[s3[i] - 'A']; 
    for (int i = 0; i < 26; i++) 
        if (freq[i] > 0) 
            uniqueChar++; 
    if (uniqueChar > 10) { 
        cout << "Invalid strings"; 
        return 0; 
    } 
    node nodeList[uniqueChar]; 
    for (int i = 0, j = 0; i < 26; i++) { 
        if (freq[i] > 0) { 
            nodeList[j].letter = char(i + 'A'); 
            j++; 
        } 
    } 
    return permutation(uniqueChar, nodeList, 0, s1, s2, s3); 
} 

int main() { 
    string s1 = "BASE"; 
    string s2 = "BALL"; 
    string s3 = "GAMES"; 
    if (solvePuzzle(s1, s2, s3) == false) 
        cout << "No solution"; 
}

आउटपुट

Solution found: A = 4 B = 2 E = 1 G = 0 L = 5 M = 9 S = 6