UNIT 4

Arrays (1-D, 2-D)

4.1 Arrays (1-D, 2-D)

One dimensional Array

A one-dimensional array is a group of elements having the same datatype and same name. Individual elements are referred to using common name and unique index of the elements.

The simplest form of an array is one-dimensional-array. The array itself is given name and its elements are referred to by their subscripts. In , an array is denoted as follows:

Array name[array_size]

Where size specifies the number of elements in the array and the subscript (also called index) value ranges from 0 through size-1.

Declare One Dimensional Array

Here is the general form to declare one dimensional array in

Data_type array_name[array_size];

Here, data_type is any valid  data type, array_name is the name of the array, and array_size is the size of array. Here is an example, declaring an array named arr of int type, having maximum element size of 10 elements

Int arr[10];

Initialize One Dimensional Array

Here is the general form to initialize values to one dimensional array

Data_type array_name[array_size] = {comma_separated_element_list};

Here is an example, declaring and initializing values to the array name arr of type int, containing 10 elements

Int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

One Dimensional Array Example

Here is some example program, demonstrating one dimensional array

/*One Dimensional Array */

#include<iostream.h>

#include<conio.h>

Void main()

{

Clrscr();

Int arr[5] = {1, 2, 3, 4, 5};

Int i;

For(i=0; i<5; i++)

{

Cout<<"arr["<<i<<"] = "<<arr[i]<<"\n";

}

Getch();

}

Here is the sample output of this  program:

Here is another  example, also demonstrating one-dimension array in

/*  One Dimensional Array */

#include<iostream.h>

#include<conio.h>

Void main()

{

Clrscr();

Int arr[10];

Int i;

Int sum=0, avg=0;

Cout<<"Enter 10 array elements: ";

For(i=0; i<10; i++)

{

Cin>>arr[i];

Sum = sum + arr[i];

}

Cout<<"\nThe array elements are: \n";

For(i=0; i<10; i++)

{

Cout<<arr[i]<<"  ";

}

Cout<<"\n\nSum of all elements is: "<<sum;

Avg = sum/10;

Cout<<"\nAnd average is: "<<avg;

Getch();

}

Here is the sample run of the above  program:

Below is another program on one-dimensional array in

/*  One Dimensional Array */

#include<iostream.h>

#include<conio.h>

Void main()

{

Clrscr();

Int arr[5];

Int i, position, index;

Cout<<"Enter 5 array elements: ";

For(i=0; i<5; i++)

{

Cin>>arr[i];

}

Cout<<"\nIndex\t\tPosition";

For(i=0; i<5; i++)

{

Cout<<"\n";

Cout<<i<<" = "<<arr[i]<<"\t\t"<<i+1<<" = "<<arr[i+1];

}

Cout<<" (Garbage value/not of array)";

Cout<<"\n\nImportant - Array element can only be accessed by indexing the array\n";

Cout<<"Note - Array index always starts from 0";

Getch();

}

Below is the sample run of this  program:

Let's take one more  program, on single- or one-dimensional array

/*  One Dimensional Array */

#include<iostream.h>

#include<conio.h>

Void main()

{

Clrscr();

Int arr[10];

Int i, position, index;

Cout<<"Enter 10 array elements: ";

For(i=0; i<10; i++)

{

Cin>>arr[i];

}

Cout<<"Accessing element at position...Enter position...";

Cin>>position;

Cout<<"\nElement present at position "<<position<<" is "<<arr[position+1];

Cout<<"\n\nAccessing element at index..Enter index..";

Cin>>index;

Cout<<"\nElement present at index "<<index<<" is "<<arr[index];

Getch();

}

Here is the sample run of the above  program:

Two-Dimensional Array

The two-dimensional array can be defined as an array of arrays. The 2D array is organized as matrices which can be represented as the collection of rows and columns. However, 2D arrays are created to implement a relational database lookalike data structure. It provides ease of holding the bulk of data at once which can be passed to any number of functions wherever required.

Declaration of two-dimensional Array in C

The syntax to declare the 2D array is given below.

1. Data_type array_name[rows][columns];  

Consider the following example.

1. Int twodimen[4][3];  

Here, 4 is the number of rows, and 3 is the number of columns.

Initialization of 2D Array in C

In the 1D array, we don't need to specify the size of the array if the declaration and initialization are being done simultaneously. However, this will not work with 2D arrays. We will have to define at least the second dimension of the array. The two-dimensional array can be declared and defined in the following way.

1. Int arr[4][3]={{1,2,3},{2,3,4},{3,4,5},{4,5,6}};  

Two-dimensional array example in C

1. #include<stdio.h>  
2. Int main(){      
3. Int i=0,j=0;    
4. Int arr[4][3]={{1,2,3},{2,3,4},{3,4,5},{4,5,6}};     
5. //traversing 2D array    
6. For(i=0;i<4;i++){    
7. For(j=0;j<3;j++){    
8.   Printf("arr[%d] [%d] = %d \n",i,j,arr[i][j]);    
9. }//end of j    
10. }//end of i    
11. Return 0;  
12. }    

Output

Arr[0][0] = 1

Arr[0][1] = 2

Arr[0][2] = 3

Arr[1][0] = 2

Arr[1][1] = 3

Arr[1][2] = 4

Arr[2][0] = 3

Arr[2][1] = 4

Arr[2][2] = 5

Arr[3][0] = 4

Arr[3][1] = 5

Arr[3][2] = 6

C 2D array example: Storing elements in a matrix and printing it.

1. #include <stdio.h>    
2. Void main ()    
3. {    
4.    Int arr[3][3],i,j;     
5.    For (i=0;i<3;i++)    
6.    {    
7.        For (j=0;j<3;j++)    
8.        {    
9.            Printf("Enter a[%d][%d]: ",i,j);                
10.            Scanf("%d",&arr[i][j]);    
11.        }    
12.    }    
13.    Printf("\n printing the elements ....\n");     
14.    For(i=0;i<3;i++)    
15.    {    
16.        Printf("\n");    
17.        For (j=0;j<3;j++)    
18.        {    
19.            Printf("%d\t",arr[i][j]);    
20.        }    
21.    }    
22. }    

Output

Enter a[0][0]: 56  

Enter a[0][1]: 10  

Enter a[0][2]: 30 

Enter a[1][0]: 34 

Enter a[1][1]: 21

Enter a[1][2]: 34   

Enter a[2][0]: 45

Enter a[2][1]: 56

Enter a[2][2]: 78  

Printing the elements ....

56      10      30 

34      21      34 

45       56      78

4.2 Character arrays and Strings

The string can be defined as the one-dimensional array of characters terminated by a null ('\0'). The character array or the string is used to manipulate text such as word or sentences. Each character in the array occupies one byte of memory, and the last character must always be 0. The termination character ('\0') is important in a string since it is the only way to identify where the string ends. When we define a string as char s[10], the character s[10] is implicitly initialized with the null in the memory.

There are two ways to declare a string in c language.

1. By char array
2. By string literal

Let's see the example of declaring string by char array in C language.

1. Char ch[10]={'j', 'a', 'v', 'a', 't', 'p', 'o', 'i', 'n', 't', '\0'};  

As we know, array index starts from 0, so it will be represented as in the figure given below.

While declaring string, size is not mandatory. So, we can write the above code as given below:

1. Char ch[]={'j', 'a', 'v', 'a', 't', 'p', 'o', 'i', 'n', 't', '\0'};  

We can also define the string by the string literal in C language. For example:

1. Char ch[]="javatpoint";  

In such case, '\0' will be appended at the end of the string by the compiler.

Difference between char array and string literal

There are two main differences between char array and literal.

• We need to add the null character '\0' at the end of the array by ourself whereas, it is appended internally by the compiler in the case of the character array.
• The string literal cannot be reassigned to another set of characters whereas, we can reassign the characters of the array.

String Example in C

Let's see a simple example where a string is declared and being printed. The '%s' is used as a format specifier for the string in c language.

1. #include<stdio.h>  
2. #include <string.h>    
3. Int main(){    
4.  Char ch[11]={'j', 'a', 'v', 'a', 't', 'p', 'o', 'i', 'n', 't', '\0'};    
5.   Char ch2[11]="javatpoint";    
6.    
7.   Printf("Char Array Value is: %s\n", ch);    
8.   Printf("String Literal Value is: %s\n", ch2);    
9. Return 0;    
10. }    

Output

Char Array Value is: javatpoint

String Literal Value is: javatpoint

Traversing String

Traversing the string is one of the most important aspects in any of the programming languages. We may need to manipulate a very large text which can be done by traversing the text. Traversing string is somewhat different from the traversing an integer array. We need to know the length of the array to traverse an integer array, whereas we may use the null character in the case of string to identify the end the string and terminate the loop.

Hence, there are two ways to traverse a string.

• By using the length of string
• By using the null character.

Let's discuss each one of them.

Using the length of string

Let's see an example of counting the number of vowels in a string.

1. #include<stdio.h>  
2. Void main ()  
3. {  
4.    Char s[11] = "javatpoint";  
5.    Int i = 0;   
6.    Int count = 0;  
7.    While(i<11)  
8.    {  
9.        If(s[i]=='a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'u' || s[i] == 'o')  
10.        {  
11.            Count ++;  
12.        }  
13.        i++;  
14.    }  
15.    Printf("The number of vowels %d",count);  
16. }  

Output

The number of vowels 4

Using the null character

Let's see the same example of counting the number of vowels by using the null character.

1. #include<stdio.h>  
2. Void main ()  
3. {  
4.    Char s[11] = "javatpoint";  
5.    Int i = 0;   
6.    Int count = 0;  
7.    While(s[i] != NULL)  
8.    {  
9.        If(s[i]=='a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'u' || s[i] == 'o')  
10.        {  
11.            Count ++;  
12.        }  
13.        i++;  
14.    }  
15.    Printf("The number of vowels %d",count);  
16. }  

Output

The number of vowels 4

Accepting string as the input

Till now, we have used scanf to accept the input from the user. However, it can also be used in the case of strings but with a different scenario. Consider the below code which stores the string while space is encountered.

1. #include<stdio.h>  
2. Void main ()  
3. {  
4.    Char s[20];  
5.    Printf("Enter the string?");  
6.    Scanf("%s",s);  
7.    Printf("You entered %s",s);  
8. }  

Output

Enter the string?javatpoint is the best                                                                

You entered javatpoint

It is clear from the output that, the above code will not work for space separated strings. To make this code working for the space separated strings, the minor changed required in the scanf function, i.e., instead of writing scanf("%s",s), we must write: scanf("%[^\n]s",s) which instructs the compiler to store the string s while the new line (\n) is encountered. Let's consider the following example to store the space-separated strings.

1. #include<stdio.h>  
2. Void main ()  
3. {  
4.    Char s[20];  
5.    Printf("Enter the string?");  
6.    Scanf("%[^\n]s",s);  
7.    Printf("You entered %s",s);  
8. }  

Output

Enter the string?javatpoint is the best

You entered javatpoint is the best

Here we must also notice that we do not need to use address of (&) operator in scanf to store a string since string s is an array of characters and the name of the array, i.e., s indicates the base address of the string (character array) therefore we need not use & with it.

Some important points

However, there are the following points which must be noticed while entering the strings by using scanf.

• The compiler doesn't perform bounds checking on the character array. Hence, there can be a case where the length of the string can exceed the dimension of the character array which may always overwrite some important data.
• Instead of using scanf, we may use gets() which is an inbuilt function defined in a header file string.h. The gets() is capable of receiving only one string at a time.

Pointers with strings

We have used pointers with the array, functions, and primitive data types so far. However, pointers can be used to point to the strings. There are various advantages of using pointers to point strings. Let us consider the following example to access the string via the pointer.

1. #include<stdio.h>  
2. Void main ()  
3. {  
4.    Char s[11] = "javatpoint";  
5.    Char *p = s; // pointer p is pointing to string s.   
6.    Printf("%s",p); // the string javatpoint is printed if we print p.  
7. }  

Output

Javatpoint

As we know that string is an array of characters, the pointers can be used in the same way they were used with arrays. In the above example, p is declared as a pointer to the array of characters s. P affects similar to s since s is the base address of the string and treated as a pointer internally. However, we cannot change the content of s or copy the content of s into another string directly. For this purpose, we need to use the pointers to store the strings. In the following example, we have shown the use of pointers to copy the content of a string into another.

1. #include<stdio.h>  
2. Void main ()  
3. {  
4.    Char *p = "hello javatpoint";  
5.    Printf("String p: %s\n",p);  
6.    Char *q;  
7.    Printf("copying the content of p into q...\n");  
8.    q = p;  
9.    Printf("String q: %s\n",q);  
10. }  

Output

String p: hello javatpoint

Copying the content of p into q...

String q: hello javatpoint

Once a string is defined, it cannot be reassigned to another set of characters. However, using pointers, we can assign the set of characters to the string. Consider the following example.

1. #include<stdio.h>  
2. Void main ()  
3. {  
4.    Char *p = "hello javatpoint";  
5.    Printf("Before assigning: %s\n",p);  
6.    p = "hello";  
7.    Printf("After assigning: %s\n",p);  
8. }  

Output

Before assigning: hello javatpoint 

After assigning: hello

Handling strings as array of characters

Strings are actually one-dimensional array of characters terminated by a null character '\0'. Thus, a null-terminated string contains the characters that comprise the string followed by a null.

The following declaration and initialization create a string consisting of the word "Hello". To hold the null character at the end of the array, the size of the character array containing the string is one more than the number of characters in the word "Hello."

Char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

If you follow the rule of array initialization then you can write the above statement as follows −

Char greeting[] = "Hello";

Following is the memory presentation of the above defined string in C/C++ −

Actually, you do not place the null character at the end of a string constant. The C compiler automatically places the '\0' at the end of the string when it initializes the array. Let us try to print the above-mentioned string −

#include <stdio.h>

Int main () {

Char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

Printf("Greeting message: %s\n", greeting );

Return 0;

}

When the above code is compiled and executed, it produces the following result −

Greeting message: Hello

C supports a wide range of functions that manipulate null-terminated strings −

The following example uses some of the above-mentioned functions −

#include <stdio.h>

#include <string.h>

Int main () {

Char str1[12] = "Hello";

Char str2[12] = "World";

Char str3[12];

Int  len ;

/* copy str1 into str3 */

Strcpy(str3, str1);

Printf("strcpy( str3, str1) :  %s\n", str3 );

/* concatenates str1 and str2 */

Strcat( str1, str2);

Printf("strcat( str1, str2):   %s\n", str1 );

/* total lenghth of str1 after concatenation */

Len = strlen(str1);

Printf("strlen(str1) :  %d\n", len );

Return 0;

}

When the above code is compiled and executed, it produces the following result −

Strcpy( str3, str1) :  Hello

Strcat( str1, str2):   HelloWorld

Strlen(str1) :  10

4.3 Function, Functions (including using built in libraries)

In c, we can divide a large program into the basic building blocks known as function. The function contains the set of programming statements enclosed by {}. A function can be called multiple times to provide reusability and modularity to the C program. In other words, we can say that the collection of functions creates a program. The function is also known as procedure or subroutine in other programming languages.

Advantage of functions in C

There are the following advantages of C functions.

• By using functions, we can avoid rewriting same logic/code again and again in a program.
• We can call C functions any number of times in a program and from any place in a program.
• We can track a large C program easily when it is divided into multiple functions.
• Reusability is the main achievement of C functions.
• However, Function calling is always an overhead in a C program.

Function Aspects

There are three aspects of a C function.

• Function declaration A function must be declared globally in a c program to tell the compiler about the function name, function parameters, and return type.

• Function call Function can be called from anywhere in the program. The parameter list must not differ in function calling and function declaration. We must pass the same number of functions as it is declared in the function declaration.

• Function definition It contains the actual statements which are to be executed. It is the most important aspect to which the control comes when the function is called. Here, we must notice that only one value can be returned from the function.

The syntax of creating function in c language is given below:

1. Return_type function_name(data_type parameter...){  
2. //code to be executed  
3. }  

Types of Functions

There are two types of functions in C programming:

1. Library Functions: are the functions which are declared in the C header files such as scanf(), printf(), gets(), puts(), ceil(), floor() etc.
2. User-defined functions: are the functions which are created by the C programmer, so that he/she can use it many times. It reduces the complexity of a big program and optimizes the code.

Return Value

A C function may or may not return a value from the function. If you don't have to return any value from the function, use void for the return type.

Let's see a simple example of C function that doesn't return any value from the function.

Example without return value:

1. Void hello(){  
2. Printf("hello c");  
3. }  

If you want to return any value from the function, you need to use any data type such as int, long, char, etc. The return type depends on the value to be returned from the function.

Let's see a simple example of C function that returns int value from the function.

Example with return value:

1. Int get(){  
2. Return 10;  
3. }  

In the above example, we have to return 10 as a value, so the return type is int. If you want to return floating-point value (e.g., 10.2, 3.1, 54.5, etc), you need to use float as the return type of the method.

1. Float get(){  
2. Return 10.2;  
3. }  

Now, you need to call the function, to get the value of the function.

Different aspects of function calling

A function may or may not accept any argument. It may or may not return any value. Based on these facts, there are four different aspects of function calls.

• Function without arguments and without return value
• Function without arguments and with return value
• Function with arguments and without return value
• Function with arguments and with return value

Example for Function without argument and return value

Example 1

1. #include<stdio.h>  
2. Void printName();  
3. Void main ()  
4. {  
5.    Printf("Hello ");  
6.    PrintName();  
7. }  
8. Void printName()  
9. {  
10.    Printf("Javatpoint");  
11. }  

Output

Hello Javatpoint

Example 2

1. #include<stdio.h>  
2. Void sum();  
3. Void main()  
4. {  
5.    Printf("\nGoing to calculate the sum of two numbers:");  
6.    Sum();  
7. }  
8. Void sum()  
9. {  
10.    Int a,b;   
11.    Printf("\nEnter two numbers");  
12.    Scanf("%d %d",&a,&b);   
13.    Printf("The sum is %d",a+b);  
14. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10

24

The sum is 34

Example for Function without argument and with return value

Example 1

1. #include<stdio.h>  
2. Int sum();  
3. Void main()  
4. {  
5.    Int result;   
6.    Printf("\nGoing to calculate the sum of two numbers:");  
7.    Result = sum();  
8.    Printf("%d",result);  
9. }  
10. Int sum()  
11. {  
12.    Int a,b;   
13.    Printf("\nEnter two numbers");  
14.    Scanf("%d %d",&a,&b);  
15.    Return a+b;   
16. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10

24

The sum is 34

Example 2: program to calculate the area of the square

1. #include<stdio.h>  
2. Int sum();  
3. Void main()  
4. {  
5.    Printf("Going to calculate the area of the square\n");  
6.    Float area = square();  
7.    Printf("The area of the square: %f\n",area);  
8. }  
9. Int square()  
10. {  
11.    Float side;  
12.    Printf("Enter the length of the side in meters: ");  
13.    Scanf("%f",&side);  
14.    Return side * side;  
15. }  

Output

Going to calculate the area of the square

Enter the length of the side in meters: 10

The area of the square: 100.000000

Example for Function with argument and without return value

Example 1

1. #include<stdio.h>  
2. Void sum(int, int);  
3. Void main()  
4. {  
5.    Int a,b,result;   
6.    Printf("\nGoing to calculate the sum of two numbers:");  
7.    Printf("\nEnter two numbers:");  
8.    Scanf("%d %d",&a,&b);  
9.    Sum(a,b);  
10. }  
11. Void sum(int a, int b)  
12. {  
13.    Printf("\nThe sum is %d",a+b);      
14. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10

24

The sum is 34

Example 2: program to calculate the average of five numbers.

1. #include<stdio.h>  
2. Void average(int, int, int, int, int);  
3. Void main()  
4. {  
5.    Int a,b,c,d,e;   
6.    Printf("\nGoing to calculate the average of five numbers:");  
7.    Printf("\nEnter five numbers:");  
8.    Scanf("%d %d %d %d %d",&a,&b,&c,&d,&e);  
9.    Average(a,b,c,d,e);  
10. }  
11. Void average(int a, int b, int c, int d, int e)  
12. {  
13.    Float avg;   
14.    Avg = (a+b+c+d+e)/5;   
15.    Printf("The average of given five numbers : %f",avg);  
16. }  

Output

Going to calculate the average of five numbers:

Enter five numbers:10

20

30

40

50

The average of given five numbers : 30.000000

Example for Function with argument and with return value

Example 1

1. #include<stdio.h>  
2. Int sum(int, int);  
3. Void main()  
4. {  
5.    Int a,b,result;   
6.    Printf("\nGoing to calculate the sum of two numbers:");  
7.    Printf("\nEnter two numbers:");  
8.    Scanf("%d %d",&a,&b);  
9.    Result = sum(a,b);  
10.    Printf("\nThe sum is : %d",result);  
11. }  
12. Int sum(int a, int b)  
13. {  
14.    Return a+b;  
15. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers:10

20

The sum is : 30  

Example 2: Program to check whether a number is even or odd

1. #include<stdio.h>  
2. Int even_odd(int);  
3. Void main()  
4. {  
5. Int n,flag=0;  
6. Printf("\nGoing to check whether a number is even or odd");  
7. Printf("\nEnter the number: ");  
8. Scanf("%d",&n);  
9. Flag = even_odd(n);  
10. If(flag == 0)  
11. {  
12.    Printf("\nThe number is odd");  
13. }  
14. Else   
15. {  
16.    Printf("\nThe number is even");  
17. }  
18. }  
19. Int even_odd(int n)  
20. {  
21.    If(n%2 == 0)  
22.    {  
23.        Return 1;  
24.    }  
25.    Else   
26.    {  
27.        Return 0;  
28.    }  
29. }  

Output

Going to check whether a number is even or odd

Enter the number: 100

The number is even

C Library Functions

Library functions are the inbuilt function in C that are grouped and placed at a common place called the library. Such functions are used to perform some specific operations. For example, printf is a library function used to print on the console. The library functions are created by the designers of compilers. All C standard library functions are defined inside the different header files saved with the extension .h. We need to include these header files in our program to make use of the library functions defined in such header files. For example, to use the library functions such as printf/scanf we need to include stdio.h in our program which is a header file that contains all the library functions regarding standard input/output.

The list of mostly used header files is given in the following table.

4.4 Parameter passing in functions, Call by value, idea of call by reference

There are two methods to pass the data into the function in C language, i.e., call by value and call by reference.

Let's understand call by value and call by reference in c language one by one.

Call by value in C

• In call by value method, the value of the actual parameters is copied into the formal parameters. In other words, we can say that the value of the variable is used in the function call in the call by value method.
• In call by value method, we cannot modify the value of the actual parameter by the formal parameter.
• In call by value, different memory is allocated for actual and formal parameters since the value of the actual parameter is copied into the formal parameter.
• The actual parameter is the argument which is used in the function call whereas formal parameter is the argument which is used in the function definition.

Let's try to understand the concept of call by value in c language by the example given below:

1. #include<stdio.h>  
2. Void change(int num) {    
3.    Printf("Before adding value inside function num=%d \n",num);    
4.    Num=num+100;    
5.    Printf("After adding value inside function num=%d \n", num);    
6. }    
7. Int main() {    
8.    Int x=100;    
9.    Printf("Before function call x=%d \n", x);    
10.    Change(x);//passing value in function    
11.    Printf("After function call x=%d \n", x);    
12. Return 0;  
13. }    

Output

Before function call x=100

Before adding value inside function num=100

After adding value inside function num=200

After function call x=100

Call by Value Example: Swapping the values of the two variables

1. #include <stdio.h>  
2. Void swap(int , int); //prototype of the function   
3. Int main()  
4. {  
5.    Int a = 10;  
6.    Int b = 20;   
7.    Printf("Before swapping the values in main a = %d, b = %d\n",a,b); // printing the value of a and b in main  
8.    Swap(a,b);  
9.    Printf("After swapping values in main a = %d, b = %d\n",a,b); // The value of actual parameters do not change by changing the formal parameters in call by value, a = 10, b = 20  
10. }  
11. Void swap (int a, int b)  
12. {  
13.    Int temp;   
14.    Temp = a;  
15.    a=b;  
16.    b=temp;  
17.    Printf("After swapping values in function a = %d, b = %d\n",a,b); // Formal parameters, a = 20, b = 10   
18. }  

Output

Before swapping the values in main a = 10, b = 20

After swapping values in function a = 20, b = 10

After swapping values in main a = 10, b = 20 

Call by reference in C

• In call by reference, the address of the variable is passed into the function call as the actual parameter.
• The value of the actual parameters can be modified by changing the formal parameters since the address of the actual parameters is passed.
• In call by reference, the memory allocation is similar for both formal parameters and actual parameters. All the operations in the function are performed on the value stored at the address of the actual parameters, and the modified value gets stored at the same address.

Consider the following example for the call by reference.

1. #include<stdio.h>  
2. Void change(int *num) {    
3.    Printf("Before adding value inside function num=%d \n",*num);    
4.    (*num) += 100;    
5.    Printf("After adding value inside function num=%d \n", *num);    
6. }      
7. Int main() {    
8.    Int x=100;    
9.    Printf("Before function call x=%d \n", x);    
10.    Change(&x);//passing reference in function    
11.    Printf("After function call x=%d \n", x);    
12. Return 0;  
13. }    

Output

Before function call x=100

Before adding value inside function num=100

After adding value inside function num=200

After function call x=200

Call by reference Example: Swapping the values of the two variables

1. #include <stdio.h>  
2. Void swap(int *, int *); //prototype of the function   
3. Int main()  
4. {  
5.    Int a = 10;  
6.    Int b = 20;   
7.    Printf("Before swapping the values in main a = %d, b = %d\n",a,b); // printing the value of a and b in main  
8.    Swap(&a,&b);  
9.    Printf("After swapping values in main a = %d, b = %d\n",a,b); // The values of actual parameters do change in call by reference, a = 10, b = 20  
10. }  
11. Void swap (int *a, int *b)  
12. {  
13.    Int temp;   
14.    Temp = *a;  
15.    *a=*b;  
16.    *b=temp;  
17.    Printf("After swapping values in function a = %d, b = %d\n",*a,*b); // Formal parameters, a = 20, b = 10   
18. }  

Output

Before swapping the values in main a = 10, b = 20

After swapping values in function a = 20, b = 10

After swapping values in main a = 20, b = 10 

Difference between call by value and call by reference in c

4.5 Passing arrays to functions

In C, there are various general problems which requires passing more than one variable of the same type to a function. For example, consider a function which sorts the 10 elements in ascending order. Such a function requires 10 numbers to be passed as the actual parameters from the main function. Here, instead of declaring 10 different numbers and then passing into the function, we can declare and initialize an array and pass that into the function. This will resolve all the complexity since the function will now work for any number of values.

As we know that the array_name contains the address of the first element. Here, we must notice that we need to pass only the name of the array in the function which is intended to accept an array. The array defined as the formal parameter will automatically refer to the array specified by the array name defined as an actual parameter.

Consider the following syntax to pass an array to the function.

1. Functionname(arrayname);//passing array  

Methods to declare a function that receives an array as an argument

There are 3 ways to declare the function which is intended to receive an array as an argument.

First way:

1. Return_type function(type arrayname[])  

Declaring blank subscript notation [] is the widely used technique.

Second way:

1. Return_type function(type arrayname[SIZE])  

Optionally, we can define size in subscript notation [].

Third way:

1. Return_type function(type *arrayname)  

You can also use the concept of a pointer. In pointer chapter, we will learn about it.

C language passing an array to function example

1. #include<stdio.h>  
2. Int minarray(int arr[],int size){    
3. Int min=arr[0];    
4. Int i=0;    
5. For(i=1;i<size;i++){    
6. If(min>arr[i]){    
7. Min=arr[i];    
8. }    
9. }//end of for    
10. Return min;    
11. }//end of function    
12.    
13. Int main(){      
14. Int i=0,min=0;    
15. Int numbers[]={4,5,7,3,8,9};//declaration of array    
16.  
17. Min=minarray(numbers,6);//passing array with size    
18. Printf("minimum number is %d \n",min);    
19. Return 0;  
20. }    

Output

Minimum number is 3

C function to sort the array

1. #include<stdio.h>   
2. Void Bubble_Sort(int[]);  
3. Void main ()    
4. {    
5.    Int arr[10] = { 10, 9, 7, 101, 23, 44, 12, 78, 34, 23};     
6.    Bubble_Sort(arr);    
7. }    
8. Void Bubble_Sort(int a[]) //array a[] points to arr.   
9. {  
10. Int i, j,temp;     
11.    For(i = 0; i<10; i++)    
12.    {    
13.        For(j = i+1; j<10; j++)    
14.        {    
15.            If(a[j] < a[i])    
16.            {    
17.                Temp = a[i];    
18.                a[i] = a[j];    
19.                a[j] = temp;     
20.            }     
21.        }     
22.    }     
23.    Printf("Printing Sorted Element List ...\n");    
24.    For(i = 0; i<10; i++)    
25.    {    
26.        Printf("%d\n",a[i]);    
27.    }  
28. }  

Output

Printing Sorted Element List ...

7 

9 

10 

12 

23

23 

34 

44 

78 

101 

Returning array from the function

As we know that, a function cannot return more than one value. However, if we try to write the return statement as return a, b, c; to return three values (a,b,c), the function will return the last mentioned value which is c in our case. In some problems, we may need to return multiple values from a function. In such cases, an array is returned from the function.

Returning an array is similar to passing the array into the function. The name of the array is returned from the function. To make a function returning an array, the following syntax is used.

1. Int * Function_name() {  
2. //some statements;   
3. Return array_type;  
4. }  

To store the array returned from the function, we can define a pointer which points to that array. We can traverse the array by increasing that pointer since pointer initially points to the base address of the array. Consider the following example that contains a function returning the sorted array.

1. #include<stdio.h>   
2. Int* Bubble_Sort(int[]);  
3. Void main ()    
4. {    
5.    Int arr[10] = { 10, 9, 7, 101, 23, 44, 12, 78, 34, 23};     
6.    Int *p = Bubble_Sort(arr), i;  
7.    Printf("printing sorted elements ...\n");  
8.    For(i=0;i<10;i++)  
9.    {  
10.        Printf("%d\n",*(p+i));  
11.    }  
12. }    
13. Int* Bubble_Sort(int a[]) //array a[] points to arr.   
14. {  
15. Int i, j,temp;     
16.    For(i = 0; i<10; i++)    
17.    {    
18.        For(j = i+1; j<10; j++)    
19.        {    
20.            If(a[j] < a[i])    
21.            {    
22.                Temp = a[i];    
23.                a[i] = a[j];    
24.                a[j] = temp;     
25.            }     
26.        }     
27.    }     
28.    Return a;  
29. }  

Output

Printing Sorted Element List ...

7 

9  

10 

12 

23

23 

34 

44 

78 

101 

4.6 Recursion as a different way of solving problems

Recursion is a common form of the general-purpose problem-solving technique called divide and conquer''. The principle of divide-and-conquer, is that you solve a given problem P in 3 steps:

1. Divide P into several subproblems, P1,P2,...Pn.
2. Solve, however you can, each of the subproblems to get solutions S1...Sn.
3. Use S1...Sn to construct a solution to the original problem, P.

This is often recursive, because in order to solve one or more of the subproblems, you might use this very same strategy. For instance, you might solve P1 be subdividing it into P1a,P1b..., solving each one of them, and putting together their solutions to get the solution S1 to problem P1.

An Everyday Example

To give a simple example, suppose you want to solve this problem:

P = carry a pile of 50 books from your office to your car.

Well, you can't even lift such a big pile, never mind carry it. So, you split the original pile into 3 piles:

P1 contains 10 books, P2 contains 15 books, P3 contains 25 books.

Your plan, of course, is to carry each pile to the car separately, and then put them back together into one big pile once they are all there. This is a recursive divide-and-conquer strategy; you have divided the original problem P into 3 problems of the same kind.

Now suppose you can directly solve P1 and P2 - they are small enough that you can carry them to the car. So, P1 and P2 are now sitting out there by the car. Once you get P3 there, you will pile them up again.

But P3 is too big to be carried. You apply the same strategy recursively: divide P3 into smaller problems, solve them, and combine the results to make the solution for P3. You divide P3 into two piles, P3a has 11 books, P3b has 14, and carry these separately to the car. Then you put P3a back onto P3b to form the pile P3 there at the car.

Now you have solved all the subproblems: P1, P2, P3 are sitting at the car. You stack them into one big pile, and presto, you have solved the original problem.

This may seem like a rather hokey example, but it illustrates very well the principles of divide-and-conquer. Let us see how we can use the very same ideas to solve mathematical and computer science problems.

A Mathematical Example

Find an algorithm for raising a number X to the power N, where N is a positive integer. You may use only two operations: multiplication, subtraction. We would like to multiply N copies of X all at once, but, like the piles of books, we do not have an operation that directly allows us to do that: we can only multiply two numbers at a time. In other words, the problems we can solve directly are these:

• Raise X to the power 1: answer = X.
• Raise X to the power 2: answer = X * X.

Any other problem we have to solve indirectly, by breaking it down into smaller and smaller problems until we have reduced it to one of these base cases.

So, if N > 2, we split the original problem into two subproblems:

• P1: raise X to the power I. The answer to this is S1.
• P2: raise X to the power N-I. The answer to this is S2.
• To get the final answer, S, combine S1 and S2: S = S1 * S2.

How do we solve P1 and P2? They are problems of exactly the same type as original problem, so we can apply to them exactly the same strategy that we applied to the original problem. We check to see if we can solve them directly... If I=1 or I=2 we can solve P1 directly; if N-I=1 or N-I=2 we can solve P2 directly. The problems we cannot solve directly, we solve recursively, as just described. An interesting feature of this strategy is that it works no matter how we split up N.

We can't directly solve this problem, so we divide it into:

• P1: raise 3 to the power 2. (choose I=2, no particular reason)
• P2: raise 3 to the power 5.

We can directly solve P1, the answer is S1 = 9. But P2 we have to further decompose:

• P2.1: raise 3 to the power 1. (choose I=1, no particular reason)
• P2.2: raise 3 to the power 4.

Again, P2.1 can be directly solved, S2.1 = 3, but P2.2 must be further decomposed:

• P2.2.1: raise 3 to the power 2.
• P2.2.2: raise 3 to the power 2.

These both can be directly solved; S2.2.1 = S2.2.2 = 9. These are combined to give S2.2 = 9*9 = 81.

Now that we have the solutions to P2.1 and P2.2 we combine them to get the solution to P2, S2 = 3*81 = 243.

Now that we have solutions for P1 and P2, we combine them to get the final solution, S = S1*S2 = 9*243 = 2187.

I said that the strategy would work no matter how we chose to subdivide the problem: any choice of I' will give the correct answer. However, some choices of I' compute the final answer faster than others. Which do you think is faster: choosing I=1 (every time) or I=2?

Answer: The computation will be faster if you choose I=2 because there will be half the number of recursive calls, and therefore half the overhead.

This is true of most recursive strategies: they usually work correctly for many different ways of decomposing the problem, but some ways are much more efficient than others. In our first example, we also were free to divide the pile of books into as many piles and whatever sizes we liked. But it obviously would be very inefficient to carry one book at a time.

Data Structures Examples

Many problems involving data structures are naturally solved recursively. This is because most data structures are collections of components and they can easily be divided into subcollections that can be independently processed, just as, in our first example, we divided the pile of books into smaller piles that could be carried to the car separately.

For example, suppose we want to add up the numbers stored in array X between positions FIRST and LAST. We can solve this directly in two very simple cases:

FIRST=LAST:

There is one number to be added, the answer is X[FIRST].

FIRST+1=LAST:

There are 2 numbers to be added, the answer is X[FIRST] + X[LAST].

Otherwise, there are too many numbers to be added all at once, so we divide the problem into two subproblems by dividing the array into two parts:

• P1: add up the numbers in X between positions FIRST and M; the answer is S1.
• P2: add up the numbers in X between positions M+1 and LAST; the answer is S2.

The final answer is obtained by combining S1 and S2 in an appropriate way. In order to get the sum of all the numbers in the array, we add together the two partial sums: S = S1 + S2.

The exact way we divide up the array does not affect the correctness of this strategy: M can be any value at all, FIRST<M<LAST.

The structure' of the collection dictates which are the easiest ways to divide up the collection. As we've just seen arrays are very flexible, it is easy to divide them into a front and a back at any division point we care to choose. Other data structures are easily divided only in certain ways.

For example, suppose we want to add up all the numbers in a stack. We'll base our solution on the recursive definition of stack we saw earlier: a stack is Empty, or has 2 parts, Top and Remainder.

We can directly add up all the numbers in an Empty stack! There are none, and by convention, the sum of no numbers is 0.

To add up the numbers in a non-empty stack, we will divide the stack into two parts, add up the parts separately, and combine the results. This is exactly what we did for arrays, but now we have to think, what is an easy way to divide a stack into two parts?

The definition of stack gives us an immediate answer: a stack naturally decomposes into a Top element (which is a number, not a stack), and a Remainder, which is a stack. So, we can decompose the problem of adding up the numbers in a nonempty stack into these two subproblems:

• P1: add up all the numbers in the Top part. This is not a recursive call, because Top is not a stack. In fact, Top is just a number, so the solution to this subproblem is just the top value itself. S1=Top value.
• P2: add up all the numbers in Remainder. This is a recursive call, because Remainder is a stack. The solution is S2.

Now, combine S1 and S2 in the appropriate way to construct the final solution: S=S1+S2, or, S=Top value + S2.

Of course, there is nothing special about adding'. The very same strategy would work if we wanted to multiply together all the values in a collection, to find the largest value, to print out the elements, to count the number of elements, and so on.

Suppose we wished to sort the values in array X between positions FIRST and LAST. We can solve this directly in two very simple cases:

FIRST=LAST:

There is one number to be sorted, nothing needs to be done.

FIRST+1=LAST:

There are 2 numbers to be sorted; compare them and, if they are out of order, swap them.

Otherwise, there are too many numbers to be sorted all at once, so we divide the problem into two subproblems by dividing the array into two parts:

• P1: sort the numbers in X between positions FIRST and M; the answer is S1.
• P2: sort the numbers in X between positions M+1 and LAST; the answer is S2.

The final answer is obtained by combining S1 and S2 in an appropriate way. The method for combining them is called merging', and it is a simple, efficient process. You can read about it in the textbook (section 5.4) or wait until we study sorting in detail later in the course.

As before, the exact way we divide up the array does not affect the correctness of this strategy: M can be any value at all, FIRST<M<LAST. Certain values of M correspond to well-known sorting algorithms:

M = 1

Gives rise to the sorting algorithm called insertion sort.

M = the midpoint between FIRST and LAST

Gives rise to the MergeSort algorithm.

Both are correct, but their efficiency is very different: MergeSort is extremely fast (optimal in fact), whereas insertion sort is very slow.

4.7 Recursion:Example programs, such as Finding Factorial, Fibonacci series, Ackerman function etc.

Recursion is the process which comes into existence when a function calls a copy of itself to work on a smaller problem. Any function which calls itself is called recursive function, and such function calls are called recursive calls. Recursion involves several numbers of recursive calls. However, it is important to impose a termination condition of recursion. Recursion code is shorter than iterative code however it is difficult to understand.

Recursion cannot be applied to all the problem, but it is more useful for the tasks that can be defined in terms of similar subtasks. For Example, recursion may be applied to sorting, searching, and traversal problems.

Generally, iterative solutions are more efficient than recursion since function call is always overhead. Any problem that can be solved recursively, can also be solved iteratively. However, some problems are best suited to be solved by the recursion, for example, tower of Hanoi, Fibonacci series, factorial finding, etc.

In the following example, recursion is used to calculate the factorial of a number.

1. #include <stdio.h>  
2. Int fact (int);  
3. Int main()  
4. {  
5.    Int n,f;  
6.    Printf("Enter the number whose factorial you want to calculate?");  
7.    Scanf("%d",&n);  
8.    f = fact(n);  
9.    Printf("factorial = %d",f);  
10. }  
11. Int fact(int n)  
12. {  
13.    If (n==0)  
14.    {  
15.        Return 0;  
16.    }  
17.    Else if ( n == 1)  
18.    {  
19.        Return 1;  
20.    }  
21.    Else   
22.    {  
23.        Return n*fact(n-1);  
24.    }  
25. }  

Output

Enter the number whose factorial you want to calculate?5

Factorial = 120

We can understand the above program of the recursive method call by the figure given below:

Recursive Function

A recursive function performs the tasks by dividing it into the subtasks. There is a termination condition defined in the function which is satisfied by some specific subtask. After this, the recursion stops and the final result is returned from the function.

The case at which the function doesn't recur is called the base case whereas the instances where the function keeps calling itself to perform a subtask, is called the recursive case. All the recursive functions can be written using this format.

Pseudocode for writing any recursive function is given below.

1. If (test_for_base)  
2. {  
3.    Return some_value;  
4. }  
5. Else if (test_for_another_base)  
6. {  
7.    Return some_another_value;  
8. }  
9. Else  
10. {  
11.    // Statements;  
12.    Recursive call;  
13. }  

Example of recursion in C

Let's see an example to find the nth term of the Fibonacci series.

1. #include<stdio.h>  
2. Int fibonacci(int);  
3. Void main ()  
4. {  
5.    Int n,f;  
6.    Printf("Enter the value of n?");  
7.    Scanf("%d",&n);  
8.    f = fibonacci(n);  
9.    Printf("%d",f);  
10. }  
11. Int fibonacci (int n)  
12. {  
13.    If (n==0)  
14.    {  
15.    Return 0;  
16.    }  
17.    Else if (n == 1)  
18.    {  
19.        Return 1;   
20.    }  
21.    Else  
22.    {  
23.        Return fibonacci(n-1)+fibonacci(n-2);  
24.    }  
25. }  

Output

Enter the value of n?12

144

Memory allocation of Recursive method

Each recursive call creates a new copy of that method in the memory. Once some data is returned by the method, the copy is removed from the memory. Since all the variables and other stuff declared inside function get stored in the stack, therefore a separate stack is maintained at each recursive call. Once the value is returned from the corresponding function, the stack gets destroyed. Recursion involves so much complexity in resolving and tracking the values at each recursive call. Therefore, we need to maintain the stack and track the values of the variables defined in the stack.

Let us consider the following example to understand the memory allocation of the recursive functions.

1. Int display (int n)  
2. {  
3.    If(n == 0)  
4.        Return 0; // terminating condition  
5.    Else   
6.    {  
7.        Printf("%d",n);  
8.        Return display(n-1); // recursive call  
9.    }  
10. }  

Explanation

Let us examine this recursive function for n = 4. First, all the stacks are maintained which prints the corresponding value of n until n becomes 0, Once the termination condition is reached, the stacks get destroyed one by one by returning 0 to its calling stack. Consider the following image for more information regarding the stack trace for the recursive functions.

A function that calls itself is known as a recursive function. And, this technique is known as recursion.

How recursion works?

Void recurse()

{

... .. ...

Recurse();

... .. ...

}

Int main()

{

... .. ...

Recurse();

... .. ...

}

The recursion continues until some condition is met to prevent it.

To prevent infinite recursion, if...else statement (or similar approach) can be used where one branch makes the recursive call, and other doesn't.

Example: Sum of Natural Numbers Using Recursion

#include <stdio.h>

Int sum(int n);

Int main() {

Int number, result;

Printf("Enter a positive integer: ");

Scanf("%d", &number);

Result = sum(number);

Printf("sum = %d", result);

Return 0;

}

Int sum(int n) {

If (n != 0)

// sum() function calls itself

Return n + sum(n-1);

Else

Return n;

}

Output

Enter a positive integer:3

Sum = 6

Initially, the sum() is called from the main() function with number passed as an argument.

Suppose, the value of n inside sum() is 3 initially. During the next function call, 2 is passed to the sum() function. This process continues until n is equal to 0.

When n is equal to 0, the if condition fails and the else part is executed returning the sum of integers ultimately to the main() function.

Advantages and Disadvantages of Recursion

Recursion makes program elegant. However, if performance is vital, use loops instead as recursion is usually much slower.

That being said, recursion is an important concept. It is frequently used in data structure and algorithms. For example, it is common to use recursion in problems such as tree traversal.

Program to find factorial of number using Recursion

This Program prompts user for entering any integer number, finds the factorial of input number and displays the output on screen. We will use a recursive user defined function to perform the task. Here we have a function find_factorial that calls itself in a recursive manner to find out the factorial of input number. We have involved the user interaction in the below program, however if you do not want that part then you can simply assign an integer value to variable num and ignore the scanf statement. In short you can tweak it in any way you want, the logic would be the same for each case.

Program to find factorial

/* Program Name: Find Factorial

Written by: Chaitanya Singh

Published on: beginnersbook.com

*/

#include<stdio.h>

Int find_factorial(int);

Int main()

{

Int num, fact;

//Ask user for the input and store it in num

Printf("\nEnter any integer number:");

Scanf("%d",&num);

//Calling our user defined function

Fact =find_factorial(num);

//Displaying factorial of input number

Printf("\nfactorial of %d is: %d",num, fact);

Return 0;

}

Int find_factorial(int n)

{

//Factorial of 0 is 1

If(n==0)

Return(1);

//Function calling itself: recursion

Return(n*find_factorial(n-1));

}

Output:

Enter any integer number: 4

Factorial of 4 is: 24

Fibonacci Series

Fibonacci Series in C: In case of fibonacci series, next number is the sum of previous two numbers for example 0, 1, 1, 2, 3, 5, 8, 13, 21 etc. The first two numbers of fibonacci series are 0 and 1.

There are two ways to write the fibonacci series program:

• Fibonacci Series without recursion
• Fibonacci Series using recursion

Fibonacci Series in C without recursion

Let's see the fibonacci series program in c without recursion.

1. #include<stdio.h>    
2. Int main()    
3. {    
4. Int n1=0,n2=1,n3,i,number;    
5. Printf("Enter the number of elements:");    
6. Scanf("%d",&number);    
7. Printf("\n%d %d",n1,n2);//printing 0 and 1    
8. For(i=2;i<number;++i)//loop starts from 2 because 0 and 1 are already printed    
9. {    
10.  n3=n1+n2;    
11.  Printf(" %d",n3);    
12.  n1=n2;    
13.  n2=n3;    
14. }  
15.  Return 0;  
16. }    

Output:

Enter the number of elements:15

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Fibonacci Series using recursion in C

Let's see the fibonacci series program in c using recursion.

1. #include<stdio.h>    
2. Void printFibonacci(int n){    
3.    Static int n1=0,n2=1,n3;    
4.    If(n>0){    
5.         n3 = n1 + n2;    
6.         n1 = n2;    
7.         n2 = n3;    
8.         Printf("%d ",n3);    
9.         PrintFibonacci(n-1);    
10.    }    
11. }    
12. Int main(){    
13.    Int n;    
14.    Printf("Enter the number of elements: ");    
15.    Scanf("%d",&n);    
16.    Printf("Fibonacci Series: ");    
17.    Printf("%d %d ",0,1);    
18.    PrintFibonacci(n-2);//n-2 because 2 numbers are already printed    
19.  Return 0;  
20. }    

Output:

Enter the number of elements:15

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Ackermann Function

In computability theory, the Ackermann function, named after Wilhelm Ackermann, is one of the simplest and earliest-discovered examples of a total computable function that is not primitive recursive. All primitive recursive functions are total and computable, but the Ackermann function illustrates that not all total computable functions are primitive recursive. It’s a function with two arguments each of which can be assigned any non-negative integer.

Ackermann function is defined as:

Ackermann algorithm:

Ackermann(m, n)

{next and goal are arrays indexed from 0 to m, initialized so that next[O]

Through next[m] are 0, goal[O] through goal[m - l] are 1, and goal[m] is -1}

Repeat

Value <-- next[O] + 1

Transferring <-- true

Current <-- O

While transferring does begin

If next[current] = goal[current] then goal[current] <-- value

Else transferring <-- false

Next[current] <-- next[current]+l

Current <-- current + 1

End while

Until next[m] = n + 1

Return value {the value of A(m, n)}

End Ackermann

Here’s the explanation of the given Algorithm:
Let me explain the algorithm by taking the example A(1, 2) where m = 1 and n = 2
So according to the algorithm initially the value of next, goal, value and current are:

Though next[current] != goal[current], so else statement will execute and transferring become false.
So now, the value of next, goal, value and current are:

Similarly, by tracing the algorithm until next[m] = 3 the value of next, goal, value and current are changing accordingly. Here’s the explanation how the values are changing,

Finally returning the value e.g 4

Analysis of this algorithm:

• The time complexity of this algorithm is: O(mA(m, n)) to compute A(m, n)
• The space complexity of this algorithm is: O(m) to compute A(m, n)

Let’s understand the definition by solving a problem!

Solve A(1, 2)?

Answer:

Given problem is A(1, 2)
Here m = 1, n = 2 e.g m > 0 and n > 0
Hence applying third condition of Ackermann function
A(1, 2) = A(0, A(1, 1)) ———- (1)
Now, Let’s find A(1, 1) by applying third condition of Ackermann function
A(1, 1) = A(0, A(1, 0)) ———- (2)
Now, Let’s find A(1, 0) by applying second condition of Ackermann function
A(1, 0) = A(0, 1) ———- (3)
Now, Let’s find A(0, 1) by applying first condition of Ackermann function
A(0, 1) = 1 + 1 = 2
Now put this value in equation 3
Hence A(1, 0) = 2
Now put this value in equation 2
A(1, 1) = A(0, 2) ———- (4)
Now, Let’s find A(0, 2) by applying first condition of Ackermann function
A(0, 2) = 2 + 1 = 3
Now put this value in equation 4
Hence A(1, 1) = 3
Now put this value in equation 1
A(1, 2) = A(0, 3) ———- (5)
Now, Let’s find A(0, 3) by applying first condition of Ackermann function
A(0, 3) = 3 + 1 = 4
Now put this value in equation 5
Hence A(1, 2) = 4

So, A (1, 2) = 4

Let’s solve another two questions on this by yourself!

Question: Solve A(2, 1)?
Answer: 5

Question: Solve A(2, 2)?
Answer: 7

Here is the simplest c and python recursion function code for generating Ackermann function

Text Books:

1. Satinder Bal Gupta & Amit Singla, Fundamental of Computers and Programming in C, Shree Mahavir Book (Publishers), New Delhi

2. Ajay Mittal, Programming in C, ‘A Practical Approach’, Pearson Education.

3. Byron Gottfried, Schaum's Outline of Programming with C, McGraw-Hill

4. E. Balaguruswamy, Programming in ANSI C, Tata McGraw-Hill

5. YashavantKanetkar, Let Us C, BPB Publication.