string program in C

/*
 Write a program that accepts two strings.
 * the program checks whether the second word is present anywhere in any word.
 * it the word is found then it prints the word from second string.
 * 
 * An example could be:
 * Input : 
 * Entr first string: this is a iss thiss. al a/
 * Enter second string: is
 * output: this is iss thiss.
 */


/* 
 * File:   main.c
 * Author: umang
 *
 * Created on November 11, 2011, 3:08 PM
 */

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

#include<string.h>
#define true 0
#define false 1

//int main(int argc, char** argv)

void main()
{

    char arr[100] = {'\0'}; // initialize whole array


    char word[10] = {'\0'};

    int i, j, temp;

    int b = false;
    printf("Enter string: ");
    gets(arr);

    printf("Enter word: ");
    gets(word);
    for (i = 0; arr[i] != '\0'; i++)
    {

        temp = i;
        b = false;
        for (j = 0; word[j] != NULL && arr[j + i] != NULL; j++)
        {

            if (word[j] != arr[i + j])
            {

                b = true;
            }
        }

        if (b == false)
        {

            j--;
            if (arr[i + j] != ' ')
            {

                while (arr[i + j] != ' ' && arr[i + j] != NULL)
                {

                    i++;
                }
            }

            while (arr[temp] != ' ' && temp >= 0)
            {

                temp--;
                if (temp < 0)
                {
                    temp = 0;

                    break;
                }
            }
            if (temp != 0)
            {
                temp++;
            }

            for (; arr[temp] != ' ' && arr[temp] != NULL; temp++)
            {

                printf("%c", arr[temp]);
            }

            printf(" ");

            i = temp;
        }
    }
    //return (EXIT_SUCCESS);
}
// input
// this a te is thisi is. t
//     4       12   18   22 

number operation

/**************************
 *   author: umang bhatt  *
 * bhatt.umang7@gmail.com *
 **************************/

/*
consider following number 45 * 45 = 2025; 20+25 = 45. Write a program
 to generate number between 32 and 99 the satisfies the abovce property.
*/


#include<stdio.h>

#define true 0
#define false 1
int foo(int n)
{
        int i = n * n;

        int j ;
        int return_val;
        j = i % 100;

        i = i / 100;
        if((i+j)==n)
        {

                return_val = true;
        }        
        else
        {
                return_val = false;
        }

        return return_val;
        
}
void main()
{
        int i ;

        for( i = 32 ; i <= 99 ; i++)
        {

                if(foo(i) == true )
                {
                        printf("%d ",i );
                }
        }

        printf("\n");
}

number program

/*
Definition from Aniruddha Guddi:
It can be seen that the number, 125874, and its double, 251748, contain exactly the same digits, but in a different order.
Find the smallest positive integer, x, such that 2x, 3x, 4x, 5x, and 6x, contain the same digits.
 */


/**************************
 *   author: umang bhatt  *
 * bhatt.umang7@gmail.com *
 **************************/

#include<stdio.h>

#define TRUE 0
#define FALSE 1 


int contains_same_digits(int no1, int no2)
{
    int arr1[10] = {0};

    int arr1_top = -1;
    int arr2[10] = {0};

    int arr2_top = -1;
    int temp = no1;

    int i, j, k;
    int returnval;

    int flag = FALSE;

    //store numbers in array
    while (temp > 0)
    {

        arr1[++arr1_top] = temp % 10;
        temp = temp / 10;
    }

    temp = no2;
    while (temp > 0)
    {

        arr2[++arr2_top] = temp % 10;
        temp = temp / 10;
    }





    for (i = 0; i <= arr1_top; i++)
    {

        flag = FALSE;
        for (j = 0; j <= arr2_top; j++)
        {

            if (arr1[i] == arr2[j])
            {
                flag = TRUE;

                // remove that element from both arrays
                for (k = i; k < arr1_top; k++)
                {

                    arr1[k] = arr1[k + 1];
                }
                arr1_top--;

                for (k = j; k < arr2_top; k++)
                {

                    arr2[k] = arr2[k + 1];
                }
                arr2_top--;


                if (j != 0)
                    j--;
            }
        }

        if (flag == TRUE)
        {
            i = -1;
        }
    }

    if (arr1_top == -1 && arr2_top == -1)
    {
        returnval = TRUE;
    }

    else
    {
        returnval = FALSE;
    }
    return returnval;
}

int main()
{
    char c[5];
    int i, j;

    int flag;
    int flag1;

    for (j = 2; j <= 6; j++)
    {

        i = 1;
        flag = FALSE;
        while (flag == FALSE)
        {

            flag = contains_same_digits(i, (i * j));
            if (flag == TRUE)
            {

                printf("\n %d * %d = %d where digits of %d and %d are same  ", i, j, (i * j), i, (i * j));

                flag = TRUE;
            }
            i++;
        }
    }
    printf("\n");

    return 0;
}

C program : largest palindrome made by multiplication of two 3 digit numbers

/*
Definition from Aniruddha Guddi:
A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.
Find the largest palindrome made from the product of two 3-digit numbers.
 */


/**************************
 *   author: umang bhatt  *
 * bhatt.umang7@gmail.com *
 **************************/




#include<stdio.h>

#define TRUE 0
#define FALSE 1 

int is_palindrome(int no)
{
    int temp = no;

    int ans = 0;
    int r;
    while (temp > 0)
    {

        ans = ((ans * 10) + (temp % 10));

        temp = temp / 10;
    }
    if (ans == no)
    {

        r = TRUE;
    }
    else
    {
        r = FALSE;
    }

    return r;
}

int main()
{
    int f_no = -1;

    int l_no = -1;
    int last_palindrom = -1;

    int flag = FALSE;
    int i, j;

    for (i = 100; i < 999; i++)
    {

        for (j = 100; j < 999; j++)
        {

            if (is_palindrome(i * j) == TRUE)
            {
                if ((i * j) > last_palindrom)
                {

                    last_palindrom = i * j;
                    f_no = i;

                    l_no = j;
                }
            }
        }
    }
    printf("%d * %d = %d \n", f_no, l_no, last_palindrom);

    return 0;
}

factorial using stack

/****************************
 *  Umang B Bhatt            *
 *   bhatt.umang7@gmail.com  *
 *****************************/

/**
 * program for factorial using stack
 */

#include<stdio.h>
#include<string.h>

#define MAX 100

// push method
int push(int *s, int top, int ele)
{

    int i;
    if (top >= MAX)
    {

        printf("\nStack Overflow");
    }
    else
    {
        s[++top] = ele;
    }

    return top;
}


//pop method
int pop(int *a, int *top)
{

    if ((*top) >= 0)
    {
        (*top) = (*top) - 1;

        return a[(*top) + 1];
    }
    else
    {

        printf("Stack underflow\n");
        return 0;
    }
}


// personally, i believe that declaring TOP and S here is bad practice


void main()
{
    int n;

    int i; // loop variable


    int ans = 1 ; // stroes the final answer

    int TOP = -1; // stack variables that mainntain stack's top


    int s[MAX]; // the stack


    printf("\nEnter number: ");

    scanf("%d",&n);


    // here we can also make sure that the use is not entering a number 
    // that can not be accomodated in the stack

    // if the user enters a number less than or equal to 0
    // then we can not find factorial
    if(n<=0)
    {

        printf("\nThe number can not be less than 0");
    }
    else
    {
        // push the numbers n,n-1 ....1 in the stack
        // you can also go in reverse manner here. the result will be the same
        // because in multiplication, order does not matter
        for(i = n ; i >0 ; i--)
        {

            TOP = push(s,TOP, i);
        }

        // now pop all the elements one by one
        // multiply them with the answer variable

        while(TOP>=0)
        {
            ans = ans * pop(s,&TOP);
        }

  
        printf("\nFactorail is %d\n",ans);
  
    }

    // getch();  // will not work on linux
}

program for odd even

/****************************
 *  Umang B Bhatt            *
 *   bhatt.umang7@gmail.com  *
 *****************************/

/**
 * program for odd even no / number
 */

#include<stdio.h>
int main(int argc, char *argv[])
{

    int no;

    printf("Enter a no to know whether a number is odd or even: ");
    scanf("%d",&no);

    if(no%2==0)
    {
        printf("the entered number %d is even\n",no);
    }

    else
    {
        printf("the entered number %d is odd\n",no);
    }
    //getch();
    return 0;
}

pattern

/****************************
 *  Umang B Bhatt            *
 *   bhatt.umang7@gmail.com  *
 *****************************/

/*
 * two numbers are entered. Both are of 4 digits.
 * For each digit there can be three parts
 * ( eg for 1234
 * 1. 123 and 4
 * 2. 12 and 34
 * 3. 1 and 234)
 *
 * We need to find perfect suare number between first number and second number
 * where both parts of any one part (of 3 parts) are also perfect square
 * 
 */


#include<stdio.h>
#define TRUE 1
#define FALSE 0


int perfectSquare(int n1)
{
    long i;
    int return_val = FALSE;

    if (n1 == 1)
    {
        return TRUE;
    }

    for (i = 1; i < n1; i++)
    {

        if ((i * i) == n1)
        {
            return_val = TRUE;
        }
    }

    return return_val;
}

void main()
{
    int n1, n2;

    int i;
    int temp;
    int div = 1000;

    printf("\nEnter first number: ");
    scanf("%d", &n1);
    printf("\nEnter second number: ");

    scanf("%d", &n2);
    for (i = n1; i < n2; i++)
    {

        div = 1000;
        while (div >= 10)
        {

            temp = i % div;
            if (perfectSquare(temp) == TRUE)
            {

                temp = i / div;
                if (perfectSquare(temp) == TRUE)
                {

                    if (1 == perfectSquare(i))
                    {
                        printf("%d ", i);
                    }
                }
            }

            div = div / 10;
        }
    }
    printf("\n");

}

String pattern

/****************************
 *  Umang B Bhatt            *
 *   bhatt.umang7@gmail.com  *
 *****************************/

/**
 * program for string pattern
 */

/**
 * Enter string: Please      validate      my Input
 * Output:  Jnpvt my vbljdbtf Plfbsf
 */

/**
 * here all the words of a string are printed in reverse order (the last word comes first, second last wor comes second and so on)
 * here the order of words in the word is not changed.
 * whenever we encounter A, E , I , O or U replace it with the next character (eg A with B, E with F
 * and so on)
 * extra spaces in the program are also ignored
 */



#include<stdio.h>

#include<string.h>

void main()
{
    char arr[100][100] = {0};

    /* this trick also works with the structure
     * we can initialize whole structure using this technique
     */
    int x = 0, y = 0;

    char str[100];
    int i = 0;

    printf("\nEnter string: ");
    gets(str);
    /*asusual warnings with gets*/
    i = 0;

    while (str[i] != '\0' && i < strlen(str))
    {

        if (str[i] == ' ' || str[i] == '\0')
        {

            while (str[i] == ' ' && str[i] != '\0')
            {

                i++;
            }
        }
        else
        {
            if (str[i] == 'A' || str[i] == 'E' || str[i] == 'I' || str[i] == 'O' || str[i] == 'U' || str[i] == 'a' || str[i] == 'e' || str[i] == 'i' || str[i] == 'o' || str[i] == 'u')
            {

                arr[x][y] = str[i] +1 ;
                y++;

                i++;
            }
            else
            {
                arr[x][y] = str[i];

                y++;
                i++;
            }
            if (str[i] == ' ' || str[i] == '\0')
            {

                arr[x][y] = '\0';
                x++;
                y = 0;
            }

        }
    }

    printf("Output:");
    for (i = x; i >= 0; i--)
    {

        printf(" %s", arr[i]);
    }
    printf("\n");

}

pattern

/****************************
 *  Umang B Bhatt            *
 *   bhatt.umang7@gmail.com  *
 *****************************/

/**
 * program for pattern
 */


/**
 * input: 18
 * output: 21 11 1
 *
 *  18 = 1 2 3 6 9
 *  now sum of 1 2 3 6 9 is 21
 *  21 = 1 3 7
 *  now sum of 1 3 7 is 11
 *  11 = 1
 *  // we stop at 1
 *
 */


#include<stdio.h>


int fun(int n)
{
    int sum = 0;

    int i;

    for (i = 1; i < n; i++)
    {

        if (n % i == 0)
        {
            sum = sum + i;
        }
    }

    return sum;

}

void main()
{
    int n;

    int temp;
    printf("\nEnter number: ");
    scanf("%d", &n);

    /* n  is greater than 0*/
    temp = n;
    while (temp > 1)
    {

        temp = fun(temp);
        printf("%d ", temp);
    }

    printf("\n");
}

pattern

/****************************
 *  Umang B Bhatt            *
 *   bhatt.umang7@gmail.com  *
 *****************************/

/**
 * program for pattern
 */


#include<stdio.h>


void fun1(int arr[100][100], int n)
{

    int i, j;
    for (i = 0; i < n; i++)
    {

        for (j = 0; j < n; j++)
        {

            printf("%d ", arr[i][j]);
        }
        for (j = 0; j < n; j++)
        {

            printf("* ");
        }
        for (j = 0; j < n; j++)
        {

            printf("%d ", arr[i][j]);
        }

        printf("\n");
    }

}

void fun2(int arr[100][100], int n)
{

    int i, j;
    for (i = 0; i < n; i++)
    {

        for (j = 0; j < n; j++)
        {

            printf("* ");
        }
        for (j = 0; j < n; j++)
        {

            printf("%d ", arr[i][j]);
        }
        for (j = 0; j < n; j++)
        {

            printf("* ");
        }
        printf("\n");
    }

}

void main()
{

    int arr[100][100] = {0};
    /* this is a trick to assign all the values whether
       they are float integer or char this will do all the appropriate assignments.
       eg 0 to integer and long, 0.0f to float and null to a character
       :refer iso standards
     */
    int n;

    int i, j;
    int count;
    printf("Enter the number: ");

    /* the number should be between 1 to 9*/
    scanf("%d", &n);
    count = n;

    for (i = 0; i < n; i++)
    {

        for (j = 0; j < n; j++)
        {

            arr[i][j] = count;
            count++;
            if (count > 9)
            {

                count = 0;
            }
        }
    }
    fun1(arr, n);

    fun2(arr, n);
    fun1(arr, n);


}

word combination / string combination

#include<stdio.h>
#include<string.h>
#define MAX 100


void swap(char* src, char* dst)
{
    char ch = *dst;
    *dst = *src;
    *src = ch;
}

int permute(char *set, int begin, int end)
{

    int i;
    int range = end - begin;

    if (range == 1)
    {
        printf("%s\n", set);
    }

    else

    {
        for (i = 0; i < range; i++)
        {

            swap(&set[begin], &set[begin + i]);

            permute(set, begin + 1, end);

            swap(&set[begin], &set[begin + i]); /*set back*/

        }
    }
}

void main()
{
    char str[MAX];

    printf("Enter the string: ");

    /*as ussual warnings with gets*/
    gets(str);
    permute(str, 0, strlen(str));

}

power using recursion / recursive function

/*****************************
 *  Umang B Bhatt            *
 *   bhatt.umang7@gmail.com  *
 *****************************/

/**
 * program for finding power using recursion
 */

#include<stdio.h>

int fun(int a,int b)
{

 if(b>1)
 {
  return a*fun(a,b-1);
 }

 else
 {
  return a;
 }
}

void main()
{

 int a =3 ;
 int b = 2;

 printf("\nEnter a: ");
 scanf("%d",&a);
 printf("Enter b: ");

 scanf("%d",&b);
 printf("%d^%d is: %d\n",a,b,fun(a,b));
}

factorial using recursion

/*****************************
 *  Umang B Bhatt            *
 *   bhatt.umang7@gmail.com  *
 *****************************/

/**
 * program for finding factorial using recursion
 */

#include<stdio.h>

int fun(int n)
{

 if(n>1)
 {
  return n*fun(n-1);
 }

 else
 {
  return 1;
 }
}

void main()
{

 int n =3 ;
 printf("\nEnter a number to find factorial: ");
 scanf("%d",&n);

 printf("Factorial is: %d\n",fun(n));
}

infix to prefix with bracket

/****************************
 *  Umang B Bhatt            *
 *   bhatt.umang7@gmail.com  *
 *****************************/

/**
 * program for infix to prefix with bracket
 */

#include<stdio.h>
#include<string.h>

#define MAX 100

/* 
 * this will not catch errors
 * eg if you enter (a*b]+c then it will output 
 */


/* OP:
 * Enter expression: (a*(c+d)+(e+f)*g)/(j+i)
 * prefix of entered (infix) expression is:
 * /+*a+cd*+efg+ji
 *
 */



// personally, i believe that declaring TOP and S here is bad practice

void main()
{
    int TOP = -1, PTOP = 0;

    char s[MAX];
    char pref[MAX] = {'\0'};

    int pre(char);
    int push(char[], int, char);

    int pop(char *, int *);

    char c[MAX] = {'\0'}, symb, x;

    int i, j;
    char temp;
    printf("Enter expression: ");

    gets(c);

    /*
     * gets will give error when compiling on modern compiler
     */


    /*
     * here i don't have strrev function on my compiler (gcc) so i am doing this manually
     * but you can write strrev(c); if your compiler supports it
     */
    i = 0;

    j = strlen(c) - 1;
    while (i < j)
    {

        temp = c[i];
        c[i++] = c[j];

        c[j--] = temp;
    }

    // x = pop(s,&TOP);
    // TOP = push(s,TOP,symb);

    for (i = 0; c[i] != '\0'; i++)
    {

        symb = c[i];
        if (isalpha(symb) > 0)
        {

            pref[PTOP] = symb;
            PTOP++;
        }
        else if (symb == '+' || symb == '-' || symb == '*' || symb == '/' || symb == '\\' || symb == '^' || symb == '$')
        {

            while ((pre(symb)) < (pre(s[TOP])))
            {

                x = pop(s, &TOP);
                pref[PTOP] = x;

                PTOP++;
            }
            TOP = push(s, TOP, symb);
        }

        else if (symb == '}' || symb == ']' || symb == ')')
        {

            TOP = push(s, TOP, symb);
        }
        else

        {
            x = '\0';
            while (x != '}' && x != ']' && x != ')')
            {

                x = pop(s, &TOP);
                if (x != '}' && x != ']' && x != ')')
                {

                    pref[PTOP] = x;
                    PTOP++;
                }
            }
        }
    }
    while (TOP >= 0)
    {

        x = pop(s, &TOP);
        pref[PTOP] = x;

        PTOP++;
    }
    pref[PTOP] = '\0';




    i = 0;
    j = strlen(pref) - 1;


    while (i < j)
    {
        temp = pref[i];

        pref[i++] = pref[j];
        pref[j--] = temp;
    }



    printf("\nprefix of entered (infix) expression is:\n%s\n", pref);


    // getch();  // win not work on linux
}

int push(char *s, int top, char ele)
{

    int i;
    if (top >= MAX)
    {

        printf("\nStack Overflow");
    }
    else
    {
        s[++top] = ele;
    }

    return top;
}

int pop(char *a, int *top)
{

    if ((*top) >= 0)
    {
        (*top) = (*top) - 1;

        return a[(*top) + 1];
    }
    else
    {

        printf("Stack underflow\n");
        return 0;
    }
}

int pre(char x)
{

    int a;
    switch (x)
    {
    case '(':

    case '{':
    case '[':
        a = -5;

        break;
    case '+':
    case '-':
        a = 2;

        break;
    case '/':
    case '*':
    case '\\':

    case '%':
        a = 5;
        break;

    case '$':
    case '^':
        a = 10;

        break;
    }
    return a;
}

infix to prefix without bracket

/****************************
 *  Umang B Bhatt            *
 *   bhatt.umang7@gmail.com  *
 *****************************/

/**
 * program for infix to prefix without bracket
 */

// the actual algorithm is quiet difficult so doing this simple way

/* OP:
 * Enter expression: a*b+d/e
 * prefix of entered (infix) expression is:
 * +*ab/de
 */

// I will be following the BSD style indentation in all the programs because it feels more readable to me


#include<stdio.h>
#include<string.h>

#define MAX 100

void main()
{

    int TOP = -1, PTOP = 0;
    char s[MAX];

    char pref[MAX] = {'\0'};

    int pre(char);

    int push(char[], int, char);
    int pop(char *, int *);

    char c[MAX] = {'\0'}, symb, x;

    char temp;

    int i, j;

    printf("Enter expression: ");
    gets(c);


    /*
     * here i don't have strrev function on my compiler (gcc) so i am doing this manually
     * but you can write strrev(c); if your compiler supports it
     */

    i = 0;
    j = strlen(c) - 1;

    while (i < j)
    {
        temp = c[i];

        c[i++] = c[j];
        c[j--] = temp;
    }

    /*
     * gets will give error when compiling on modern compiler
     */

    for (i = 0; c[i] != '\0'; i++) // NULL will give error on iso compiler

    {
        symb = c[i];
        if (isalpha(symb) > 0)
        {

            pref[PTOP] = symb;
            PTOP++;
        }
        else
        {

            while ((pre(symb))<(pre(s[TOP])) && TOP >= 0)
            {

                x = pop(s, &TOP);
                pref[PTOP] = x;

                PTOP++;
            }
            TOP = push(s, TOP, symb);
        }
    }

    while (TOP >= 0)
    {
        x = pop(s, &TOP);

        pref[PTOP] = x;
        PTOP++;
    }
    pref[PTOP] = '\0';


    //strrev(pref);
    // use strrev if it is there in your compiler
    // if not available then use following code
    i = 0;
    j = strlen(pref) - 1;



    while (i < j)
    {
        temp = pref[i];

        pref[i++] = pref[j];
        pref[j--] = temp;
    }




    // now print the reverse of the string
    printf("\nprefix of entered (infix) expression is:\n %s\n", pref);
    // getch();  // win not work on linux

}

int push(char *s, int top, char ele)
{

    int i;
    if (top >= MAX)
    {

        printf("\nStack Overflow");
    }
    else
    {
        s[++top] = ele;
    }

    return top;
}

int pop(char *a, int *top)
{

    if ((*top) >= 0)
    {
        (*top) = (*top) - 1;

        return a[(*top) + 1];
    }
    else
    {

        printf("Stack underflow\n");
        return 0;
    }
}

int pre(char x)
{

    int a;
    switch (x)
    {
    case '+':

    case '-':
        a = 2;
        break;

    case '/':
    case '*':
    case '\\':

    case '%':
        a = 5;
        break;

    case '$':
    case '^':
        a = 10;

        break;
    }
    return a;
}