printf("Integer numbers from -1 to %d are ...\n", num);
for(i = -1; i >= num; i--)
printf("%d\n", i);
}
elseif(num > 0)
{
printf("Integer numbers from 1 to %d are ...\n", num);
for(i = 1; i <= num; i++)
printf("%d\n", i);
}
else
{
printf("You entered zero!\n");
}
printf("\n");
return 0;
}
#include<stdio.h>
int main()
{
int num, i;
printf("Enter an integer number\n");
scanf("%d", &num);
if(num < 0)
{
printf("Integer numbers from -1 to %d are ...\n", num);
for(i = -1; i >= num; i--)
printf("%d\n", i);
}
else if(num > 0)
{
printf("Integer numbers from 1 to %d are ...\n", num);
for(i = 1; i <= num; i++)
printf("%d\n", i);
}
else
{
printf("You entered zero!\n");
}
printf("\n");
return 0;
}
Output 1: Enter an integer number 0 You entered zero!
Output 2: Enter an integer number 5 Integer numbers from 1 to 5 are … 1 2 3 4 5 Output 3: Enter an integer number -5 Integer numbers from -1 to -5 are … -1 -2 -3 -4 -5
Logic To Print Integer Numbers Till N: using For loop
For a integer number input there are 3 possible cases: Either user can input positive number, negative number or a zero. So we cover all these 3 possibilities in our program.
If user enters a number less than 0, then its a negative number. So we initialize i value to -1(which is the biggest negative number), and iterate the for loop until i is greater than or equal to the user entered number. For each iteration we reduce the value of i by 1. Inside for loop, we print the value of i.
If user entered number is greater than 0, then its a positive number. So we initialize i value to 1(smallest positive number), and iterate the for loop until i is less than or equal to user entered number, and for each iteration we increment the value of i by 1. Inside for loop we print the value of i.
If user enter number is nether greater than 0 and nor less than zero, then the user input number must be 0. In that case, we simply output the message that – user entered zero!
Note: 1. When user inputs a negative number, it’ll always be smaller than or equal to -1. 2. When user inputs a positive number, it’ll always be greater than or equal to 1.
Source Code: C Program to Print Integer Numbers Till N: using while loop
printf("Integer numbers from -1 to %d are ...\n", num);
while(count >= num)
{
printf("%d\t", count);
count--;
}
}
elseif(num > 0)
{
count = 1;
printf("Integer numbers from 1 to %d are ...\n", num);
while(count <= num)
{
printf("%d\t", count);
count++;
}
}
else
{
printf("You entered zero!\n");
}
printf("\n");
return 0;
}
#include<stdio.h>
int main()
{
int num, count;
printf("Enter a integer number\n");
scanf("%d", &num);
if(num < 0)
{
count = -1;
printf("Integer numbers from -1 to %d are ...\n", num);
while(count >= num)
{
printf("%d\t", count);
count--;
}
}
else if(num > 0)
{
count = 1;
printf("Integer numbers from 1 to %d are ...\n", num);
while(count <= num)
{
printf("%d\t", count);
count++;
}
}
else
{
printf("You entered zero!\n");
}
printf("\n");
return 0;
}
Logic To Print Integer Numbers Till N: using While loop
1. For negative value input: We initialize count value to -1, as its the biggest negative number. In while loop condition we check if user input number is less than or equal to value of count(-1), if true, we print the value of count. And for each iteration we decrement the value of count by 1.
2. For positive value input: We initialize count value to 1, as its the smallest positive number. In while loop condition we check if user input number is greater than or equal to value of count(1), if true, we print the value of count. And for each iteration we increment the value of count by 1.
Note: 1. For negative value input, we initialize count value to -1, because we want to print from -1 till user input number. 2. For positive value input, we initialize count value to 1, because we want to print from 1 till user input number.
#include<stdio.h>
#define N 100
int main()
{
int num[N], i;
for(i = 0; i < N; i++)
num[i] = i + 1;
for(i = 0; i < N; i++)
printf("%d\t", num[i]);
return 0;
}
Output: This code outputs natural numbers from 1 to 100.
Note: Array index starts from 0. So elements from index 0 to 99 will have 100 elements.
At index 0 we’ll store number 1, and at index 1 we’ll store number 2 and so on until index 99 where we store number 100. i.e., the index number is 1 less than the element/number present at that index.
Starting with the second entry in the array, set all its multiples to zero.
Here we initialize i to second entry in the array, which has element 2(first prime number). Iterate the for loop until i is less than or equal to square root of N or you can even write (num[i] * num[i]) <= N as the condition for outer for loop. We’ve shown the reason for writing that condition in our other video tutorial present here: Find Prime Numbers from 2 To N using Sieve of Eratosthenes: C Program.
Step 3: Proceed to the next non-zero element and set all its multiples to zero.
Inside inner for loop: for any non-zero element we check for their multiples and if we find any, we store 0 – indicating that it was a composite number.
We repeat Step 3 till we have set up the multiples of all the non-zero elements to zero.
Initialized j to pow(num[i], 2) ?
Because the first number to be struck off by num[i] will be pow(num[i], 2) or (num[i] x num[i]). In other words, the first number or the first multiple of num[i] where our program will insert 0 is pow(num[i], 2) or (num[i] x num[i]).
j = j + num[i] It can also be written as j += num[i]. For each iteration of inner for loop, j value should increment by num[i] times, so that the position (j – 1) will have the multiple of number present at num[i]. In that case num[j – 1] will be multiple of num[i], and hence composite number – so we store 0 at num[j – 1].
Step 5: Print Prime Numbers Finally all the non-zero numbers/elements are prime numbers.
Source Code: Prime Numbers using Sieve of Eratosthenes: C Program
Logic To Find First and Second Biggest Element In An Array using Recursion
We ask the user to enter N integer numbers and store it inside the address of array variable a[N]. Next we assign the biggest value between a[0] and a[1] to variable first and second biggest value to variable second. Then we pass the last elements address and length of the array and variables first and second to a function fsBig().
void fsBig(int *num, int n, int first, int second)
{
if(n < 2)
printf("First Big: %d\nSecond Big: %d\n", first, second);
else
{
if(*num > first)
{
second = first;
first = *num;
}
else if(*num > second && *num != first)
second = *num;
fsBig(--num, --n, first, second);
}
}
First we write the base condition or the termination condition: Once the length of the array or the variable n value is less than 2, we print the value present in variable fbig and sbig, and the control exits the function fsBig();
Note: We are checking till n < 2, because variables first and second already has values present at index 0 and 1, so need not compare them again against themselves.
Inside else block we write the actual logic to find the first and second biggest element in the array. First we check if the value present in pointer variable *num is greater than value present in variable fbig. If true, then there is a element which is bigger than fbig, that means, now whatever is present in fbig becomes second biggest element – so we transfer value present in fbig to sbig, and then transfer the new found biggest element of the array to variable fbig.
If a number is not greater than fbig, it can still be greater than sbig. So we check for that condition in else if. If its true, then we transfer the value of *num to sbig.
Recursive call Next we call the same method fsBig() with new values. i.e., we reduce the address of num by 1, we reduce the value of index n by 1, and we pass the new values of fbig and sbig. This keeps on iterating until value of n is less than 2. Once the value of n is less than 2, the base condition is met and the control executes the printf() statement and exits the function fsBig().
Using array variable to receive base address from main method
#include<stdio.h>
#define N 5
void fsBig(int num[], int n, int first, int second)
{
if(n < 2)
printf("First Big: %d\nSecond Big: %d\n", first, second);
else
{
if(num[n] > first)
{
second = first;
first = num[n];
}
else if(num[n] > second && num[n] != first)
second = num[n];
fsBig(num, --n, first, second);
}
}
int main()
{
int a[N], i, first, second, count = 0;
printf("Enter %d integer numbers\n", N);
for(i = 0; i < N; i++)
scanf("%d", &a[i]);
for(i = 0; i < N; i++)
{
if(a[i] != a[0])
{
( (a[0] > a[i]) ?
(first = a[0], second = a[i]) :
(first = a[i], second = a[0]) );
break;
}
else
count++;
}
if(count == N)
{
printf("Biggest: %d\nSmallest: %d\n", a[0], a[0]);
return 0;
}
fsBig(a, N - 1, first, second);
return 0;
}
Output 1: Enter 5 integer numbers 5 4 5 2 1 First Big: 5 Second Big: 4
Output 2: Enter 5 integer numbers 5 5 4 4 2 First Big: 5 Second Big: 4
Here we do not alter the value of num while recursively calling the method fsBig(), as we compare with all the elements of the array by changing the value of index variable n.
Whenever we use array variable, compiler converts it to pointer as below
#include<stdio.h>
#define N 5
void fsBig(int num[], int n, int first, int second)
{
if(n < 2)
printf("First Big: %d\nSecond Big: %d\n", first, second);
else
{
if(*(num + n) > first)
{
second = first;
first = *(num + n);
}
else if(*(num + n) > second && *(num + n) != first)
second = *(num + n);
fsBig(num, --n, first, second);
}
}
int main()
{
int a[N], i, first, second, count = 0;
printf("Enter %d integer numbers\n", N);
for(i = 0; i < N; i++)
scanf("%d", &a[i]);
for(i = 0; i < N; i++)
{
if(a[i] != a[0])
{
( (a[0] > a[i]) ?
(first = a[0], second = a[i]) :
(first = a[i], second = a[0]) );
break;
}
else
count++;
}
if(count == N)
{
printf("Biggest: %d\nSmallest: %d\n", a[0], a[0]);
return 0;
}
fsBig(a, N - 1, first, second);
return 0;
}
Output: Enter 5 integer numbers 1 2 3 5 5 First Big: 5 Second Big: 3
Whenever compiler encounters array variable like this a[i] or num[n] it converts it into *(a + i) and *(num + n). i.e., Variable_name[array_index] = *(Base_address + array_index) Note that, Variable_name holds Base_address. So Variable_name = Base_address.
Its faster to work with address than with variables. This example proves that arrays are pointers in disguise. i.e., arrays use pointers internally.
Explanation With Example
N = 5; a[N] = {5, 4, 6, 2, 3}; first = 5; second = 4; n = N -1 = 5 – 1 = 4;
Write a c program using pointers to find the smallest number in an array of 25 integers.
Pointers: A pointer variable is a variable which holds the address of another variable, of its own type.
Important Note: 1. Array elements are always stored in contiguous memory location. 2. A pointer when incremented always points to an immediately next location of its own type.
printf("Smallest Element In The Array: %d\n", *small);
return 0;
}
#include<stdio.h>
#define N 5
int main()
{
int a[N], i, *small;
printf("Enter %d integer numbers\n", N);
for(i = 0; i < N; i++)
scanf("%d", &a[i]);
small = &a[0];
for(i = 1; i < N; i++)
{
if( *(a + i) < *small)
*small = *(a + i);
}
printf("Smallest Element In The Array: %d\n", *small);
return 0;
}
Output: Enter 5 integer numbers 5 2 6 4 3 Smallest Element In The Array: 2
Here we are assigning base address to pointer variable small.
Logic To Find Smallest Element In An Array using Pointers
We ask the user to input N integer numbers and store it inside a[N]. Next we assign base address to pointer variable small. Next we iterate through the array elements one by one using a for loop, and check if any of the elements of the array is smaller than whatever the value present at *small. If there is any element smaller than *small, we assign that value to *small.
Once the control exits the for loop, we print the value present in pointer variable *small, which holds the smallest element in the array.
printf("Smallest Element In The Array: %d\n", *small);
return 0;
}
#include<stdio.h>
#define N 5
int main()
{
int a[N], i, *small;
printf("Enter %d integer numbers\n", N);
for(i = 0; i < N; i++)
scanf("%d", &a[i]);
small = &a[0];
for(i = 1; i < N; i++)
{
if( a[i] < *small)
*small = a[i];
}
printf("Smallest Element In The Array: %d\n", *small);
return 0;
}
Output: Enter 5 integer numbers 2 1 3 4 5 Smallest Element In The Array: 1
As you can see in the above source code we are using array variable in if condition. But compiler converts a[i] to *(a + i). So internall a[i] is denoted as *(a + i) – which is *(base address + index).
Here index variable i is initialized to 1. That is because pointer variable small has base address i.e., address of first element of the array. So we need not compare the value with itself. So we skip comparing it with a[0], and start the comparison from next index, which is 1.
printf("Smallest Element In The Array: %d\n", small);
else
{
if(small > *num)
small = *num;
smallest(++num, --n, small);
}
}
int main()
{
int a[N], i;
printf("Enter %d integer numbers\n", N);
for(i = 0; i < N; i++)
scanf("%d", &a[i]);
smallest(a, N - 1, a[0]);
return 0;
}
#include<stdio.h>
#define N 5
void smallest(int *num, int n, int small)
{
if(n < 0)
printf("Smallest Element In The Array: %d\n", small);
else
{
if(small > *num)
small = *num;
smallest(++num, --n, small);
}
}
int main()
{
int a[N], i;
printf("Enter %d integer numbers\n", N);
for(i = 0; i < N; i++)
scanf("%d", &a[i]);
smallest(a, N - 1, a[0]);
return 0;
}
Output: Enter 5 integer numbers 2 1 3 4 5 Smallest Element In The Array: 1
Logic To Find Smallest Element In An Array using Recursion
We ask the user to enter N integer numbers and store it inside array variable a[N]. We pass base address(address of first element in the array) of the array, which is present in &a[0] or a, and last index of the array(indicating size of the array, from index 0), and first element of the array(assuming first element itself as smallest element).
Inside Recursive function Base Condition: This is the condition to terminate the recursive call. Here we check if the size of the array is less than zero. If it’s less than zero, then we display the value present inside variable small, which holds the smallest element in the array.
printf("Smallest Element In The Array: %d\n", small);
else
{
if(small > *num)
small = *num;
smallest(++num, --n, small);
}
}
void smallest(int *num, int n, int small)
{
if(n < 0)
printf("Smallest Element In The Array: %d\n", small);
else
{
if(small > *num)
small = *num;
smallest(++num, --n, small);
}
}
We need to take a pointer variable to accept the base address. Next we’ll have base condition. If base condition isn’t met – we check if the value present in variable small is greater than value present at *num. If it’s true, then we transfer the value of *num to small. Next we increment the address of num by 1 and decrement the value of n by 1 and pass them to the same function(recursive call) along with the value of small. This is called recursive function call.
Once value of n is less than 0, we display the value of variable small, which holds the smallest element of the array.
Important Note:
1. Array elements are always stored in contiguous memory location. 2. A pointer when incremented always points to an immediately next location of its own type.
Source Code: Find Smallest Element of An Array using Recursion: With Return Value
printf("Smallest Element In The Array: %d\n", smallest(a, N - 1, a[0]));
return 0;
}
#include<stdio.h>
#define N 5
int smallest(int num[], int n, int small)
{
if(n < 1)
return small;
else
{
if(num[n] < small)
small = num[n];
return smallest(num, --n, small);
}
}
int main()
{
int a[N], i;
printf("Enter %d integer numbers\n", N);
for(i = 0; i < N; i++)
scanf("%d", &a[i]);
printf("Smallest Element In The Array: %d\n", smallest(a, N - 1, a[0]));
return 0;
}
Output: Enter 5 integer numbers 2 1 0 3 5 Smallest Element In The Array: 0
After repeatedly incrementing value of num and decrementing the value n, we’ll reach a point where value of n will be less than 0. That’s when all the comparisons end, and variable small will have smallest element of the array. This result will be returned to the calling function, which in turn returns the result to the calling function and so on ..until the result is returned to the first function call, which was from with in main method – where we print the value of variable small.
Source Code: Using Array Variable In Recursive Function
printf("Smallest Element In The Array: %d\n", small);
else
{
if(small > num[n])
small = num[n];
smallest(num, --n, small);
}
}
int main()
{
int a[N], i;
printf("Enter %d integer numbers\n", N);
for(i = 0; i < N; i++)
scanf("%d", &a[i]);
smallest(a, N - 1, a[0]);
return 0;
}
#include<stdio.h>
#define N 5
void smallest(int num[], int n, int small)
{
if(n < 0)
printf("Smallest Element In The Array: %d\n", small);
else
{
if(small > num[n])
small = num[n];
smallest(num, --n, small);
}
}
int main()
{
int a[N], i;
printf("Enter %d integer numbers\n", N);
for(i = 0; i < N; i++)
scanf("%d", &a[i]);
smallest(a, N - 1, a[0]);
return 0;
}
Output: Enter 5 integer numbers 1 0 2 -5 4 Smallest Element In The Array: -5
Here we are taking array variable to receive the base address. We keep checking if num[n] is smaller than value present at variable small. If true, then we transfer num[n] value to variable small, and then recursively call the same function by decrementing the value of n by 1, and also pass the new value of small.
Once the value of n is less than 0, we return the value present in variable small, which holds the smallest element of the array.
Explanation With Example
N = 5; a[N] = {5, 2, 6, 4, 3}; n = N – 1 = 5 – 1 = 4; num = a[0] = 5; big = a[0] = 5;
