Here we will reverse a string using two methods, iterative and recursive.

Reversing a string using the Iterative method

Method 1:

Algorithm:

• Calculate the length (Len) of string.
• Initialize the indexes of the array.
  Start = 0, End = Len-1
• In a loop, swap the value of pszData[Start] with pszData[End].
• Change the indexes’ of the array as follows.
  Start = start +1; End = end – 1

#include <stdio.h>
#include <stdlib.h>


int main()
{

    char acData[100]= {0}, Temp = 0;
    int iLoop =0, iLen = 0;
    int cnt =0;

    printf("\nEnter the string :");

    //Maximum takes 100 character
    if (fgets(acData,100,stdin) == NULL)
    {
        printf("Error\n");
        return 1;
    }

    //calculate length of string
    while(acData[iLen++] != '\0');

    //Remove the null character
    iLen--;

    //Array index start from 0 to (length -1)
    iLen--;

    while (iLoop < iLen)
    {

        Temp = acData[iLoop];
        acData[iLoop] = acData[iLen];
        acData[iLen] = Temp;
        iLoop++;
        iLen--;
    }

    printf("\n\nReverse string is : %s",acData);
    return 0;
}

Method 2:

#include <stdio.h>
#include <stdlib.h>

#define SWAP_CHARACTER(a,b)  do { \
    (*a)^=(*b); \
    (*b)^=(*a);\
    (*a)^=(*b);\
    a++; \
    b--; \
    }while(0);

int main(int argc, char *argv[])
{

    char acData[100]= {0};
    char *pcStart = NULL;
    char *pcEnd = NULL;
    int iLoop =0, iLen = 0;


    printf("\nEnter the string :");

    //Maximum takes 100 character
    if (fgets(acData,100,stdin) == NULL)
    {
        printf("Error\n");
        return 1;
    }
    //Pointer point to the address of first character
    pcStart = acData;

    // calculate length of string
    while(acData[iLen++] != '\0');

    //Remove the null character
    iLen--;

    pcEnd = (pcStart + iLen-1);

    while (iLoop < iLen/2)
    {

        SWAP_CHARACTER (pcStart,pcEnd);
        iLoop++;

    }

    printf("\n\nReverse string is : %s\n\n",acData);
    return 0;
}

Recursive way to reverse a string

Algorithm:

• Calculate the length (Len) of string.
• Initialize the indexes of the array.
  Start = 0, End = Len-1
• swap the value of pszData[Start] with pszData[End].
• Change the indexes’ of an array as below and Recursively call reverse function for the rest array.
  Start = start +1; End = end – 1

#include <stdio.h>
#include <stdlib.h>

//recursive function
void StringRev(char *pszInputData, unsigned int Start, unsigned int End)
{
    if(Start >= End)
    {
        return 1;
    }
    // swap the data
    *(pszInputData + Start) = *(pszInputData + Start) ^ *(pszInputData + End);
    *(pszInputData + End) = *(pszInputData + Start) ^ *(pszInputData + End);
    *(pszInputData + Start) = *(pszInputData + Start) ^ *(pszInputData + End);

    //function called repeatedly
    StringRev(pszInputData,Start+1, End-1);
}


int main(int argc, char *argv[])
{
    char acData[100]= {0};
    int  iLen = 0;
    unsigned int Start=0;


    printf("\nEnter the string :");
    //Maximum takes 100 character
    if (fgets(acData,100,stdin) == NULL)
    {
        printf("Error\n");
        return 1;
    }

    // calculate length of string
    while(acData[iLen++] != '\0');

    //Remove the null character
    iLen--;
    //Find array last index
    iLen--;

    StringRev(acData,Start, iLen);

    printf("\n\nReverse string is : %s\n\n",acData);

    return 0;
}

Q) What is the endianness?

Ans:

The endianness is the order of bytes to store data in memory and it also describes the order of byte transmission over a digital link. In the memory data store in which order depends on the endianness of the system, if the system is big-endian then the MSB byte store first (means at lower address) and if the system is little-endian then LSB byte store first (means at lower address).

Some examples of the little-endian and big-endian system.

Q) What is big-endian and little-endian?

Ans:

Suppose, 32 bits Data is 0x11223344.

Big-endian

The most significant byte of data stored at the lowest memory address.

Little-endian

The least significant byte of data stored at the lowest memory address.

Note: Some processor has the ability to switch one endianness to other endianness using the software means it can perform like both big-endian or little-endian at a time. This processor is known as the Bi-endian, here are some architecture (ARM version 3 and above, Alpha, SPARC) who provide the switchable endianness feature.

Q) Write a C program to check the endianness of the system?

Ans:

Below I am writing C programs to check the endianness of the system.

Method 1:

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>

int main(void)
{
    uint32_t u32RawData;
    uint8_t *pu8CheckData;
    u32RawData = 0x11223344; //Assign data

    pu8CheckData = (uint8_t *)&u32RawData; //Type cast

    if (*pu8CheckData == 0x44) //check the value of lower address
    {
        printf("little-endian");
    }
    else if (*pu8CheckData == 0x11) //check the value of lower address
    {
        printf("big-endian");
    }

    return 0;
}

Method 2:

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>

typedef union
{
    uint32_t u32RawData;  // integer variable
    uint8_t  au8DataBuff[4]; //array of character
} RawData;


int main(void)
{
    RawData uCheckEndianess;
    uCheckEndianess.u32RawData = 0x11223344; //assign the value

    //check the array first index value
    if (uCheckEndianess.au8DataBuff[0] == 0x44)
    {
        printf("little-endian");
    }  //check the array first index value
    else if (uCheckEndianess.au8DataBuff[0] == 0x11)
    {
        printf("big-endian");
    }

    return 0;
}

Q) How to Convert little-endian to big-endian vice versa in C?

Ans:

Below I am writing C programs to convert little-endian to big-endian (vice versa).

Method 1:

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>

//Function to change the endianess
uint32_t ChangeEndianness(uint32_t u32Value)
{
    uint32_t u32Result = 0;
    u32Result |= (u32Value & 0x000000FF) << 24;
    u32Result |= (u32Value & 0x0000FF00) << 8;
    u32Result |= (u32Value & 0x00FF0000) >> 8;
    u32Result |= (u32Value & 0xFF000000) >> 24;
    return u32Result;
}


int main()
{
    uint32_t u32CheckData  = 0x11223344;
    uint32_t u32ResultData =0;
    u32ResultData = ChangeEndianness(u32CheckData);  //swap the data
    printf("0x%x\n",u32ResultData);
    u32CheckData = u32ResultData;
    u32ResultData = ChangeEndianness(u32CheckData);//again swap the data
    printf("0x%x\n",u32ResultData);
    
    return 0;
}

Output:

0x44332211
0x11223344

Method 2:

We can also make the macro to swap the data from one endianness to another.

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>



//Macro to swap the byte
#define ChangeEndianness(A)   ((((uint32_t)(A) & 0xff000000) >> 24) | (((uint32_t)(A) & 0x00ff0000) >> 8)  | \
(((uint32_t)(A) & 0x0000ff00) << 8)  | (((uint32_t)(A) & 0x000000ff) << 24))


int main()
{
    uint32_t u32CheckData  = 0x11223344;
    uint32_t u32ResultData =0;

    u32ResultData = ChangeEndianness(u32CheckData);
    printf("0x%x\n",u32ResultData);

    u32CheckData = u32ResultData;

    u32ResultData = ChangeEndianness(u32CheckData);
    printf("0x%x\n",u32ResultData);

    return 0;
}

Q) Write a c Program to Check Whether a Number is Prime or Not?

Ans:

A prime number is a positive natural number, whose value greater than 1 and has only two factors 1 and the number itself.

You can see Article, How to find all prime numbers up to n.

Algorithm to check prime number using division method

START

Step 1 → Take the number n

Step 2 → Divide the number n with (2, n-1) or (2, n/2) or (2, sqrt(n)).

Step 3 → if the number n is divisible by any number between (2, n-1) or (2, n/2) or (2, sqrt(n)) then it is not prime

Step 4 → If it is not divisible by any number between (2, n-1) or (2, n/2) or (2, sqrt(n)) then it is a prime number

STOP

#include <stdio.h>
#include <math.h>

#define PRIME_NUMBER  1

int IsPrimeNumber(int iNumber)
{
    int iLoop = 0;
    int iPrimeFlag = 1;
    int iLimit = sqrt(iNumber); // calculate of square root n

    if(iNumber <= 1)
    {
        iPrimeFlag = 0;
    }
    else
    {
        for(iLoop = 2; iLoop <= iLimit; iLoop++)
        {
            if((iNumber % iLoop) == 0) // Check prime number
            {
                iPrimeFlag = 0;
                break;
            }
        }
    }
    return iPrimeFlag;
}

int main(int argc, char *argv[])
{
    int iRetValue = 0;
    int iNumber = 0;

    printf("Enter the number : ");
    scanf("%d",&iNumber);

    iRetValue = IsPrimeNumber(iNumber);

    if (iRetValue == PRIME_NUMBER)
    {
        printf("\n\n%d is prime number..\n\n", iNumber);
    }
    else
    {
        printf("\n\n%d is not a prime number..\n\n", iNumber);
    }
    return 0;
}

Q) How to find the size of an array in C without using the sizeof operator?

Ans:

Method 1:

#include <stdio.h>

int main(int argc, char *argv[])
{
    int iTotalElement = 0 ;
    int  aiData[] = {10, 20, 30, 40, 50, 60};

    //Calculate numbers of elements using pointer arithmatic
    iTotalElement = *(&aiData + 1) - aiData;

    printf("Number of element = %d",iTotalElement);

    return 0;
}

Output:

Number of element = 6

Method 2:

#include <stdio.h>
// User created size of operator
#define SIZEOF(Var) ((char*)(&Var + 1) -(char*)&Var)

int main(int argc, char *argv[])
{

    int iTotalElement = 0 ;
    int  aiData[] = {10, 20, 30, 40, 50, 60};

    iTotalElement = SIZEOF(aiData)/SIZEOF(aiData[0]);

    printf("Number of element = %d",iTotalElement);

    return 0;
}

Output:

Q) How to find the size of the structure in c without using sizeof operator?

Ans:

Method 1:

When incrementing the pointer then pointer increases a block of memory (block of memory depends on pointer data type). So here we will use this technique to calculate the sizeof structure.

• First, create the structure.
• Create a pointer to structure and assign the NULL pointer.
• Increment the pointer to 1.

#include <stdio.h>
#include <stdlib.h>


typedef struct
{
    char Name[12];
    int Age;
    float Weight;
    int RollNumber;

} sStudentInfo;



int main(int argc, char *argv[])
{
    //Create pointer to the structure
    sStudentInfo *psInfo  = NULL;

    //Increment the pointer
    psInfo++;

    printf("Size of structure  =  %u\n\n",psInfo);
    
    return 0;
}

Output:

Size of structure  =  24

Method 2:

We can also calculate the size of the structure using the pointer subtraction. In the previous article “all about the pointer“, we have read that using the pointer subtraction we can calculate the number of bytes between the two pointers.

• First, create the structure.
• create an array of structure, Here aiData[2].
• Create pointers to the structure and assign the address of the first and second element of the array.
• Subtract the pointers to get the size of the structure.

Q) What is meant by structure padding?

Ans:

In the case of structure or union, the compiler inserts some extra bytes between the members of structure or union for the alignment, these extra unused bytes are called padding bytes and this technique is called padding.

Padding has increased the performance of the processor at the penalty of memory. In structure or union data members aligned as per the size of the highest bytes member to prevent the penalty of performance.

Note: Alignment of data types mandated by the processor architecture, not by language.

How to pass a 2d array as a parameter in C?

Ans:

In C language, there are a lot of ways to pass the 2d array as a parameter. In the below section, I am describing few ways to pass the 2d array as a parameter to the function.

Passing 2d array to function in c using pointers

The first element of the multi-dimensional array is another array, so here, when we will pass a 2D array then it would be split into a pointer to the array.

For example,

If int aiData[3][3], is a 2D array of integers, it would be split into a pointer to the array of 3 integers (int (*)[3]).

#include <stdio.h>

//Size of the created array
#define ARRAY_ROW      3
#define ARRAY_COL      3


void ReadArray(int(*piData)[ARRAY_COL])
{
    int iRow = 0;
    int iCol = 0;

    for (iRow = 0; iRow < ARRAY_ROW; ++iRow)
    {
        for (iCol = 0; iCol < ARRAY_COL; ++iCol)
        {
            printf("%d\n", piData[iRow][iCol]);
        }
    }
}



int main(int argc, char *argv[])
{
    //Create an 2D array
    int aiData[ARRAY_ROW][ARRAY_COL] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

    //Pass array as a parameter
    ReadArray(aiData);

    return 0;
}

Passing 2d array to function with row and column

In which prototype of the function should be same as the passing array. In another word, we can say that if int aiData[3][3] is a 2D array, the function prototype should be similar to the 2D array.

#include <stdio.h>

//Size of the created array
#define ARRAY_ROW      3
#define ARRAY_COL      3


void ReadArray(int aiData[ARRAY_ROW][ARRAY_COL])
{
    int iRow = 0;
    int iCol = 0;

    for (iRow = 0; iRow < ARRAY_ROW; ++iRow)
    {
        for (iCol = 0; iCol < ARRAY_COL; ++iCol)
        {
            printf("%d\n", aiData[iRow][iCol]);
        }
    }
}



int main(int argc, char *argv[])
{
    //Create an 2D array
    int aiData[ARRAY_ROW][ARRAY_COL] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

    //Pass array as a parameter
    ReadArray(aiData);

    return 0;
}

Passing 2d array to function, using the pointer to 2D array

If int aiData[3][3] is a 2D array of integers, then &aiData would be pointer the 2d array that has 3 row and 3 column.

#include <stdio.h>

//Size of the created array
#define ARRAY_ROW      3
#define ARRAY_COL      3


void ReadArray(int(*piData)[ARRAY_ROW][ARRAY_COL])
{
    int iRow = 0;
    int iCol = 0;

    for (iRow = 0; iRow < ARRAY_ROW; ++iRow)
    {
        for (iCol = 0; iCol < ARRAY_COL; ++iCol)
        {
            printf("%d\n", (*piData)[iRow][iCol]);
        }
    }
}



int main(int argc, char *argv[])
{
    //Create an 2D array
    int aiData[ARRAY_ROW][ARRAY_COL] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

    //Pass array as a parameter
    ReadArray(&aiData);

    return 0;
}