Trending February 2024 # C++ Program For Solving Cryptarithmetic Puzzles # Suggested March 2024 # Top 9 Popular

You are reading the article C++ Program For Solving Cryptarithmetic Puzzles updated in February 2024 on the website We hope that the information we have shared is helpful to you. If you find the content interesting and meaningful, please share it with your friends and continue to follow and support us for the latest updates. Suggested March 2024 C++ Program For Solving Cryptarithmetic Puzzles

   m := 1    for each letter i from right to left of word1, do       ch := word1[i]       for all elements j in the nodeList, do          if nodeList[j].letter = ch, then             break       done       val1 := val1 + (m * nodeList[j].value)       m := m * 10    done    m := 1    for each letter i from right to left of word2, do       ch := word2[i]       for all elements j in the nodeList, do          if nodeList[j].letter = ch, then             break       done       val2 := val2 + (m * nodeList[j].value)       m := m * 10    done    m := 1    for each letter i from right to left of word3, do       ch := word3[i]       for all elements j in the nodeList, do          if nodeList[j].letter = ch, then             break       done       val3 := val3 + (m * nodeList[j].value)       m := m * 10    done    if val3 = (val1 + val2), then       return true    return false    if n letters are assigned, then       for all digits i from 0 to 9, do          if digit i is not used, then             nodeList[n].value := i             if isValid(nodeList, count, word1, word2, word3) = true                for all items j in the nodeList, do                   show the letter and corresponding values.                done                return true       done       return fasle    for all digits i from 0 to 9, do       if digit i is not used, then          nodeList[n].value := i          mark as i is used          if permutation(nodeList, count, n+1, word1, word2, word3),             return true          otherwise mark i as not used    done    return false #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;       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;       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;       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();    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++)          uniqueChar++;       cout << “Invalid strings”;       return 0;    }    node nodeList[uniqueChar];    for (int i = 0, j = 0; i < 26; i++) {          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”; }

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

You're reading C++ Program For Solving Cryptarithmetic Puzzles

C++ Program For Priority Scheduling

   Set wt[0] = 0    Loop For i = 1 and i < n and i++       Set wt[i] = pro[i-1].bt + wt[i-1]    End    Loop For i = 0 and i < n and i++       Set tat[i] = pro[i].bt + wt[i]    End Loop    Declare and initialize wt[n], tat[n], total_wt = 0, total_tat = 0    Call function waitingtime(pro, n, wt)    Call function turnarround(pro, n, wt, tat)    Print “Processes, Burst time, Waiting time, Turn around time”    Loop For i=0 and i<n and i++       Set total_wt = total_wt + wt[i]       total_tat = total_tat + tat[i]    End Loop    Print values of “Processes, Burst time, Waiting time, Turn around time”    Print Average waiting time, Average turn around time    Call function sort(pro, pro + n, compare)    Loop For i = 0 and i < n and i++       Print the order.    End Loop    Call function avgtime(pro, n)    Declare and initialize Process pro[] = {{1, 10, 2}, {2, 5, 0}, {3, 8, 1}}    Declare and initialize n = sizeof pro / sizeof pro[0]    Call function scheduling(pro, n) using namespace std; struct Process {    int pid;    int bt;    int priority; }; bool compare(Process a, Process b) { } void waitingtime(Process pro[], int n, int wt[]) {    // Initial waiting time for a process is 0    wt[0] = 0;    // calculating waiting time    for (int i = 1; i < n ; i++ )       wt[i] = pro[i-1].bt + wt[i-1] ; }  // Function to calculate turn around time void turnarround( Process pro[], int n, int wt[], int tat[]) {    // calculating turnaround time by adding    // bt[i] + wt[i]    for (int i = 0; i < n ; i++)       tat[i] = pro[i].bt + wt[i]; } void avgtime(Process pro[], int n) {    int wt[n], tat[n], total_wt = 0, total_tat = 0;    //Function to find waiting time of all processes    waitingtime(pro, n, wt);    //Function to find turn around time for all processes    turnarround(pro, n, wt, tat);    //Display processes along with all details    cout << “nProcesses “<< ” Burst time ” << ” Waiting time ” << ” Turn around timen”;    // Calculate total waiting time and total turn    // around time    for (int i=0; i<n; i++) {       total_wt = total_wt + wt[i];       total_tat = total_tat + tat[i];       cout << ” ” << pro[i].pid << “tt” << pro[i].bt << “t ” << wt[i] << “tt ” << tat[i] <<endl;    }    cout << “nAverage waiting time = ” << (float)total_wt / (float)n;    cout << “nAverage turn around time = ” << (float)total_tat / (float)n; } void scheduling(Process pro[], int n) {    // Sort processes by priority    sort(pro, pro + n, compare);    cout<< “Order in which processes gets executed n”;    for (int i = 0 ; i < n; i++)       cout << pro[i].pid <<” ” ;    avgtime(pro, n); } int main() {    Process pro[] = {{1, 10, 2}, {2, 5, 0}, {3, 8, 1}};    int n = sizeof pro / sizeof pro[0];    scheduling(pro, n);    return 0; }

Output Order in which processes gets executed 1 3 2 Processes  Burst time  Waiting time  Turn around time  1              10         0              10  3              8          10             18  2              5          18             23   Average waiting time = 9.33333 Average turn around time = 17

Ml Trends For Solving Business Intelligence Problems

This article was published as a part of the Data Science Blogathon


In September 2023, Gartner released a separate report on artificial intelligence technologies, ranging from conceptual concepts like neural networks to hardware implementations of Machine Learning algorithms in the form of industrial robots and unmanned vehicles.

Notably, in this report, autonomous vehicles (drones, unmanned cars, and other vehicles) are now at the bottom of frustration, while Automatic Machine Learning (AutoML), Explainable AI (XAI), chatbots, and other conversational user interfaces are at the peak of inflated expectations. And in general, speech recognition systems and video card-based process acceleration (GPU) tools have reached a productivity plateau.

From the point of view of industrial applications, the most promising are technologies for creating robotic software for the automation of production processes and calendar planning. These trends correlate with the most in-demand trends in the Internet of Things, which people have been discussing since 2023.

ML Trend #1 – AutoML

AutoML is Automated machine learning or AutoML. To tell the truth, the AutoML paradigm is about having one big button that lets you “build a good model”.

The popularity of such tools grows every day, but it is too early to talk about AutoML as a stand-alone approach, especially in the context of large corporations.

ML Trend #2 – XAI

We are talking about Explainable Artificial Intelligence (Explainable AI or XAI).

The fact is that it is extremely important for the business user to understand the logic behind the decision-making, which is more typical for areas of activity that were historically dominated by easily interpretable models such as logistic regression or decision trees (calculation of credit risks, targeted marketing, insurance).

Recently, methods like LIME and XSHAPE have been closing the gap between interpretation and accuracy and, judging by the activity in the academic environment, they are expected to spread further.

ML Trend #3 – RL

RL or Reinforcement Learning is learning with reinforcement and is essentially a development of the concept of continuous A/B testing with the only difference that instead of two segments we have thousands of them, and the process functions continuously.

Once it was used only for games, but in recent years it has been used to solve great business problems. Today experts continue to improve the methods of using RL for business. There are already lots of successful application cases on the market:

– choosing the most appropriate campaign in marketing optimization;

– personalization of pages and mailings in digital marketing;

– work with bad debts in credit risks, etc.

ML Trend #4 – graph analytics

Graph analytics refers to a set of methods that focus on analyzing the structure of relationships between entities, rather than the properties of those entities. For example, connections between people in social networks, connections of bank account through transfers passing through these accounts, different ownership structures, etc.

The methods of graph analytics are used to analyze the structure of relations and to identify non-obvious relations. As for the ML problems, graph analytics gives the opportunity to build stronger predictors – variables that describe the neighborhood of the entity of interest. For example, we can answer the question of how the credit rating of the firm is affected by the rating of its counterparties.

Using methods of graph analytics, you can be limited not only to direct links but also to neighborhoods by links of different lengths.

Today graphs are successfully used to analyze entities that have a “natural” network structure, such as social networks. It is predicted that graphs for entities with non-obvious network structures will become more and more frequent. Such graphs are good for building sequences of customer events or analyzing cause-effect relationships for marketing communications management tasks.

ML Trend #5 – ModelOps

MLOps (Machine Learning Operations) is a kind of DevOps for machine learning that helps standardize the process of developing machine learning models and reduces the time to roll them out into production.

MLOps helps to break down the barrier between Data scientists and Data engineers. What often happens is that the Data Scientist experiments develop a new model, gives it to the Data Engineer, and goes off again to set up new experiments and try new models. And the Data Engineer tries to deploy that model in production, but since he was not involved in its development, it may take about several months to do so. It can take up to six months from the time he starts developing the model to its deployment in production. All that time the model is not working and useful, the data becomes obsolete, and the reproducibility of experiments becomes an issue.

With MLOps, the new model is quickly put into production and begins to benefit the business. MLOps also solves model tracking, versioning, and model monitoring tasks in production.

If you use the MLOps approach and special tools, like Kubeflow, in conjunction with proper planning, such as at chúng tôi you can significantly speed up the process of rolling out experimental models into production, which means that they will solve business problems faster.

The media shown in this article are not owned by Analytics Vidhya and is used at the Author’s discretion. 


Swap Two Numbers Without Using A Third Variable: C, Python Program

In programming, language swapping means swapping the value of two variables. The variable might contain a number, string, list or array, object, etc. The general way of swapping is to use a temporary variable to hold values. For example,

The general steps of swapping two numbers are:

Declared a temporary variable C

Assign the value of A to C, meaning C = A. Now C = 20

Assign the value of B to A, So A = 30

Assign the value of C to B, So B = 20, as C has the value 20.

It is how swapping is done with the help of a temporary variable. This method will work both for integer numbers and float numbers as well.

Swap using Arithmetic Equation

As we know, swapping means to interchange the content of two objects or fields or variables. Swap using arithmetic operation means to perform the swap operation using the mathematical equation, i.e., addition and subtraction.

If we’re given two numbers and asked to swap without using a temporary variable, then using three arithmetic equations, we can swap the numbers.

Pseudocode for swapping numbers using arithmetic operation:

A = A + B B = A - B A = A - B

Let’s assume we have two numbers, A = 20 and B = 30.

Condition 1:    A = A+B

                  So, current value of A is 20+30 = 50

Condition 2:    B = A-B

                   We can see that we got the value of A in B

Condition 3:    A = A-B

                   A has the initial value of B.

So, we just swapped the numbers.

Here’s the program to swap two numbers in C/C++:

int main() { int a, b; printf(“Enter value of A: “); scanf(“%d”, & a); printf(“Enter value of B: “); scanf(“%d”, & b); printf(“A = %d, B = %d”, a, b); a = a + b; b = a – b; a = a – b; printf(“nNow, A = %d, B = %d”, a, b); }


Enter value of A: 20 Enter value of B: 30 A = 20 , B = 30 Now, A = 30 , B = 20

Program in Python:

a = int(input("Enter value of A: ")) b = int(input("Enter value of B: ")) print("A = {} and B = {}".format(a, b)) a = a + b b = a - b a = a - b print("Now, A = {} and B = {}".format(a, b))


Enter value of A: 20 Enter value of B: 30 A = 20 , B = 30 Now, A = 30 , B = 20

Now in Python, we don’t even need to perform arithmetic operations. We can use:

a,b = b,a

Here’s a demonstration where a=20, b=30;

Swap using Bitwise XOR Operator

This method is also known as XOR swap. XOR mean exclusive OR. We take two bits as inputs to the XOR in this bitwise operation. To get one output from XOR, only one input must be 1. Otherwise, the output will be 0. The following table shows the output for all combinations of input A B.

We need to know how the XOR operation works to swap two numbers using the bitwise operation. Here’s a table for XOR where A and B is input values.


0 0 0

0 1 1

1 0 1

1 1 0

If two input has the same value, then the XOR operation gives 0; otherwise, 1. For this example, we will be using a 3 XOR operation. In most programming languages, XOR is denoted as “^”.

Let’s assume A=4 (in Binary = 0100) and B=7(In Binary, 0111)

Condition 1:    A = A ^ B

A 0 1 0 0

B 0 1 1 1

A ^ B 0 0 1 1

Now, A = 0011 (in Binary).

Condition 2:    B = A^B

A 0 0 1 1

B 0 1 1 1

A ^ B 0 1 0 0

So B = 0100, which was the initial binary value of A.

Condition 3:    A = A^B

A 0 0 1 1

B 0 1 0 0

A ^ B 0 1 1 1

Finally, A = 0111, which was the equivalent binary value of B.

Program in C/C++:

int main() { int a, b; printf(“Enter value of A: “); scanf(“%d”, & a); printf(“Enter value of B: “); scanf(“%d”, & b); printf(“A = %d, B = %d”, a, b); a = a ^ b; b = a ^ b; a = a ^ b; printf(“nNow, A = %d, B = %d”, a, b); }


Enter value of A:4 Enter value of B:7 A=4, B=7 Now, A=7, B=4.

Program in Python:

a = int(input("Enter value of A: ")) b = int(input("Enter value of B: ")) print("A = {} and B = {}".format(a, b)) a = a ^ b b = a ^ b a = a ^ b print("Now, A = {} and B = {}".format(a, b))


Enter the value of A:10 Enter the value of B:15 A=10 and B=15 Now, A=15,B=10. Swap Numbers using Bitwise-Arithmetic

This method is the same as the arithmetic method, but we will use Bitwise operations such as AND, OR, and Compliment to perform addition and subtraction. Before going to the steps, let’s look over” Compliment” quickly.

1’s complement means to change all the 0 to 1 and 1 to 0. Let’s have an example.

Let’s assume a number   23, a decimal number.

Converting to Binary gives use 10111. There are only 5 bits, but the computer stores number in 8,16,32,64 .. bits. So let’s add zero in front of the Binary. It will not change the original value of the number. So it will become 00010111.

As we know, 1’s compliment means to change all the 0 to 1 and 1 to 0, so performing 1’s complement over 00010111 gives 11101000

This 1’s complement is represented with “~” this symbol in most programming languages. Putting this symbol before any integer values or floating-point values will give the 1’s complement.

And 2’s complement means adding binary “1” to the 1’s complement. If we do 2’s complement to the above number:

Binary = 00010111

1’s compliment = 11101000

2’s compliment:


          +              1


In summary, for performing 2’s complement of a number A, it will look like:

2’s complement of A = (~A) + 1

Now let’s assume A=8 (binary 00001000), B=10(00001010)

                   It’s equivalent to A = A + B.

                   A & B = 00001000 & 00001010 = 00001000

Now, 00001000 + 00001010 = 00010010 (decimal 18)

So, A = 18

Condition 2:

          B = A + (~B) + 1

                   Its equivalent to B = A-B

Here, B = A – B

From the above discussion, if we need to perform subtraction, we perform 2’s complement to the negative number and then add it.

So, -B = ~B + 1

Now,      B = 00010010 + (11110101) + 1 = 00001000

B’s value is equivalent to decimal 8, which was the initial value.

Condition 3:

A = A + (~B) + 1

                   Its equivalent to A = A-B

Now, A = 00010010 + 11110111 + 1

          A = 00001010 (equivalent to decimal 10)

Finally, A got the value of B. Thus, the swapping was completed.

Program in C/C++:

int main() { int a, b; printf(“Enter value of A: “); scanf(“%d”, & a); printf(“Enter value of B: “); scanf(“%d”, & b); printf(“A = %d, B = %d”, a, b); b = a + ~b + 1; a = a + ~b + 1; printf(“nNow, A = %d, B = %d”, a, b); }


Enter the value of A: 8 Enter the value of B:10 A=8, B=10 Now, A=10, B=8

Program in Python:

a = int(input("Enter value of A: ")) b = int(input("Enter value of B: ")) print("A = {} and B = {}".format(a, b)) b = a + ~b + 1 a = a + ~b + 1 print("Now, A = {} and B = {}".format(a, b))


Enter the value of A: 25 Enter the value of B: 25 A = 25 and B = 25 Now, A = 25 and B = 25 What is Arithmetic Overflow?

Integer number representation in a 32-bit system

The consequence of the arithmetic overflow can be:

The addition of two positive numbers becomes negative. Because the sign bit might become 1, meaning a negative number.

The addition of two negative numbers becomes positive. Because the sign bit might become 0, meaning a positive number.

C# Program To Check If A Path Is A Directory Or A File


Let us learn how to write C# program to check if a path is a directory or a file. A directory, also known as a folder, is a place on your computer where you can save files. A directory holds other directories or shortcuts in addition to files.

A file is a collection of data on a drive that has a unique identifier and a directory path. When a file is opened for viewing or writing, it is transformed into a stream. The stream is simply a sequence of bytes traversing the communication route.

Files vs Directory

Files are real data files, whereas directories are repositories for logical file placement on your system. To work with files and directories, the common language runtime (CLR) has the classes File, FileInfo, Directory, and DirectoryInfo in the chúng tôi namespace.

To deal with directories in C#, we can use Directory or DirectoryInfo. Directory class is a static class with static functions for dealing with directories. This class can not be inherited. A DirectoryInfo instance gives information about a specific directory.

There is a file class and a fileinfo class for folders. The File class is used for common tasks such as duplicating, moving, renaming, making, opening, deleting, and adding to a single file. The File class can also be used to get and change file characteristics or DateTime information associated with file creation, access, and writing. Both the File and FileInfo classes have the same fundamental functionality.

The only difference is that the File class has intrinsic methods for dealing with files, whereas the FileInfo class has instance methods for dealing with files.

Public static bool Exists (string? path); is used to check if the file or directory exists. Here the parameter is string? path. Which is the path to check. Its return type is boolean. The reason for this function to be boolean is that when the path is checked then there are only two outcomes. Either the file or directory exists or not, much like the keyword of the function. So here true is returned if there is the existence of the directory or the file and false is returned if it does not exist or any type of error occurs while trying to access the address such as a broken address or more.


The algorithm below will give a step-by-step procedure to write a program to check if the path given is a directory or a file.

Step 1 − Firstly we have to declare a string that contains the address which we want to check whether it is a file or directory

Step 2 − Then there has to be a condition check in which we use the method public static bool Exists (string? path); to check the existence of a file.

Step 3 − It is solely on the programmer to decide what he wants to check first. Whether he wants to check the path as a file or a directory.

Step 4 − If the path fails both of the checks then the output comes as an invalid path and the same is displayed as a message.

Example using System; using System.IO; class ttpt { static void Main() { string PathCheck = “D:/ipl”; if(File.Exists(PathCheck)) { Console.WriteLine(“A file exists on this path”); } else if(Directory.Exists(PathCheck)) { Console.WriteLine(“A directory exists on this path”); } else { Console.WriteLine("{0} is invalid. The input is neither a file nor a directory.", path); } } } Output A file exists on this path

The above-mentioned code is to check whether the path provided is a file or not. In the code first, we have declared a string to store the address to check whether it is a file or a directory. Then we use the public static bool Exists (string? path); which can be used with File as well as Directory class to check the existence of a file or directory by using the respective class keyword. This can be done by using the conditional check. If the person wants to do a bulk check then an array of addresses can be passed as a parameter by making a class. And then check them one by one. As public static bool Exists (string? path); returns a boolean is the reason we are doing the condition check.

Before verifying whether the directory exists, trailing spaces are deleted from the conclusion of the path argument.

The path parameter’s case sensitivity correlates to the file system on which the code is executing. For example, NTFS (the usual Windows file system) is case-insensitive, whereas Linux file systems are case-sensitive.

Time Complexity

In the algorithm after the string is declared. The public static bool Exists (string? path); the method is a boolean returning method. Because it makes a single call straight to the element we are searching for, the algorithm has a time complexity of O(1).


So, we have reached the end of the article and we have learned how to check whether the path provided is the directory or a file. We started with the definition of the file and directory and then we moved on and saw the difference between files and directory. Then we understood the algorithm of the program and after that, we saw the program to check the path. We hope that this article enhances your knowledge regarding C#.

Queries To Update A Given Index And Find Gcd In Range In C++ Program

In this problem, we are given an array arr[] of size N and Q queries which can be of two types. Our task is to create a program to solve the queries to update a given index and find GCD in the range.

Queries are −

Type 1 − {1, index, value} – increase the element at given index by value.

Type 2 − {2, L, R} – find the GCD of elements in the index range [L, R].

Problem Description − We need to find the GCD of the elements that are in the range [L, R] and return the value.

Let’s take an example to understand the problem,

Input arr[] = {5, 1, 7, 3, 8}, Q = 3 using namespace std; int calcGcdRangeRec(int* st, int segL, int segR, int L, int R, int currNode) {       return st[currNode];       return 0;    int mid = (segL + (segR - segL)/2);    int GcdL = calcGcdRangeRec(st, segL, mid, L, R, 2 * currNode + 1) ;    int GcdR = calcGcdRangeRec(st, mid + 1, segR, L, R, 2 * currNode + 2);    return __gcd(GcdL, GcdR); } void updateArrayValueRec(int* st, int L, int R, int index, int diff, int currNode) {       return;    st[currNode] = st[currNode] + diff;    if (R != L) {       int mid = (L + (R - L)/ 2);       updateArrayValueRec(st, L, mid, index, diff, 2 * currNode + 1);       updateArrayValueRec(st, mid + 1, R, index, diff, 2 * currNode + 2);    } } void updateArrayValue(int arr[], int* st, int n, int index, int newVal) {       cout << "Invalid Input";    else{       int diff = newVal - arr[index];       arr[index] = newVal;       updateArrayValueRec(st, 0, n - 1, index, diff, 0);    } } int calcGcdRange(int* st, int n, int L, int R) {       cout << "Invalid Input";       return -1;    }    return calcGcdRangeRec(st, 0, n - 1, L, R, 0); } int constructGcdST(int arr[], int L, int R, int* st, int currNode) {    if (L == R) {       st[currNode] = arr[L];       return arr[L];    }    int mid = (L + (R - L)/2);    int GcdL = constructGcdST(arr, L, mid, st, currNode * 2 + 1);    int GcdR = constructGcdST(arr, mid + 1, R, st, currNode * 2 + 2);    st[currNode] = __gcd(GcdL, GcdR);    return st[currNode]; } int main() {    int arr[] = { 1, 3, 6, 9, 9, 11 };    int n = sizeof(arr) / sizeof(arr[0]);    int Q = 3;    int query[3][3] = {{2, 1, 3}, {1, 1 , 10}, {2, 1, 3}};    int value = (int)(ceil(log2(n)));    int size = 2 * (int)pow(2, value) - 1;    int* st = new int[size];    constructGcdST(arr, 0, n - 1, st, 0);    for(int i = 0; i < n; i++){       if(query[i][0] == 1){          cout<<"Query "<<(i + 1)<<": Updating Values!n";          updateArrayValue(arr, st, n, query[i][1], query[i][2]);       }       if(query[i][0] == 2)       cout<<"Query "<<(i + 1)<<": GCD is "<<calcGcdRange(st, n, query[i][1], query[i][2])<<endl;    }    return 0; } Input Query 1: GCD is 3 Query 2: Updating Values! Query 3: GCD is 1

Update the detailed information about C++ Program For Solving Cryptarithmetic Puzzles on the website. We hope the article's content will meet your needs, and we will regularly update the information to provide you with the fastest and most accurate information. Have a great day!