#include <stdio.h>
 
 void printPairs(int arr[], int arr_size, int sum)
 {
     int front = 0;
     int back = arr_size - 1;
 
     while (front < back) {
        if (arr[front] + arr[back] < sum) {
            front++;
        } else if (arr[front] + arr[back] > sum) {
            back--;
        } else {
            printf ("Pair with given sum %d is (%d, %d) \n",
                    sum, arr[front], arr[back]);
            back--;
        }
    }
}

/* Driver program to test above function */
int main()
{
    int A[] = {4, 5, 6, 10, 12, 12};
    int sum = 16;
    int arr_size = 6;

    printPairs(A, arr_size, sum);

    return 0;
}

 
 #include <stdio.h>
 #define MAX 100000
 
 void printPairs(int arr[], int arr_size, int sum)
 {
     int i = 0;
     int temp = 0;
     int binMap[MAX] = {0}; /*initialize hash map as 0*/

    for(i = 0; i < arr_size; i++)
    {
        temp = sum - arr[i];
        if(temp >= 0 && binMap[temp] == 1)
        {
            printf("Pair with given sum %d is (%d, %d) \n",
                    sum, arr[i], temp);
        }
        binMap[arr[i]] = 1;
    }
}

/* Driver program to test above function */
int main()
{
    int A[] = {12, 4, 45, 6, 10, 12};
    int sum = 16;
    int arr_size = 6;

    printPairs(A, arr_size, sum);

    return 0;
}

 
 #include <stdio.h>
 
 void printPairs(int arr[], int arr_size, int sum)
 {
     int i = 0;
     int temp = 0;
     int bitmap = 0; // all bits are 0
     int bitmask = 0;

    for(i = 0; i < arr_size; i++)
    {
        temp = sum - arr[i];

        bitmask = 0;
        bitmask = 1 << temp;

        if(temp >= 0 && (bitmap & bitmask))
        {
            printf("Pair with given sum %d is (%d, %d) \n",
                   sum, arr[i], temp);
        }
        bitmap |= 1 << arr[i];
    }
}

/* Driver program to test above function */
int main()
{
    int A[] = {12, 4, 13, 6, 10, 3};
    int sum = 16;
    int arr_size = 6;

    printPairs(A, arr_size, sum);

    return 0;
}

  
  #include <stdio.h>
  
  int lSize = 4;
  int rSize = 3;
  int L[4] = {1, 3, 6, 7};
  int R[4] = {1, 2, 4};
  int finalArray[7];
  
 void merge()
 {
     int lIndx = 0;
     int rIndx = 0;
     int i = 0;
 
     for (i = 0; i < (lSize + rSize); i++) {
         if (L[lIndx] <= R[rIndx]) {
             finalArray[i] = L[lIndx++];
             if (lIndx == lSize) {
                 break;
             }
         } else {
             finalArray[i] = R[rIndx++];
             if (rIndx == rSize) {
                 break;
             }
         }
     }
 
     i++;
     if (lIndx != lSize) {
         while(1) {
             finalArray[i++] = L[lIndx++];
 
             if (lIndx == lSize) {
                 return;
             }
         }
     }
     if (rIndx != rSize) {
         while(1) {
             finalArray[i++] = R[rIndx++];
 
             if (rIndx == rSize) {
                 return;
             }
         }
     }
 }
 
 void display()
 {
     int i = 0;
 
     printf("\n\nArray1: ");
     for (i = 0; i < lSize; i++) {
         printf("%d ", L[i]);
     }
 
     printf("\nArray2: ");
     for (i = 0; i < rSize; i++) {
         printf("%d ", R[i]);
     }
 
     printf("\nMerge array: ");
     for (i = 0; i < lSize+rSize; i++) {
         printf("%d ", finalArray[i]);
     }
 }
 
 int main()
 {
     // Test 1
     merge();
     display();
 
     // Test 2
     R[0] = 1;
     R[1] = 3;
     R[2] = 6;
     R[3] = 7;
     L[0] = 1;
     L[1] = 2;
     L[2] = 4;
     lSize = 3;
     rSize = 4;
     merge();
     display();
 
     // test 3
     L[0] = 1;
     R[0] = 1;
     lSize = 1;
     rSize = 1;
     merge();
     display();
 
     return 0;
 }

 
 #include <stdio.h>
 
 #define ARR1SIZE 5
 #define ARR2SIZE 5
 
 int main()
 {
     int arr1[] = {6, 3, 6, 1, 7};
    int arr2[] = {5, 1, 2, 4, 6};
    int arr3[ARR1SIZE + ARR2SIZE];

    // Using bit map, All bits are 0
    int bitMap = 0;
    int bitMask = 0;
    int i = 0;
    int k = 0;

    for (i = 0; i < ARR1SIZE; i++) {
        // Check if value already exist
        bitMask = 0;
        bitMask = 1 << arr1[i];

        if (bitMap & bitMask) {
            continue;
        }
        arr3[k++] = arr1[i];

        // Mark bitMap that value exist
        bitMap |= 1 << arr1[i];
    }

    for (i = 0; i < ARR2SIZE; i++) {
        // Check if value already exist
        bitMask = 0;
        bitMask = 1 << arr2[i];

        if (bitMap & bitMask) {
            continue;
        }
        arr3[k++] = arr2[i];

        // Mark bitMap that value exist
        bitMap |= 1 << arr2[i];
    }

    printf("Merged Array\n");
    for (i = 0; i < k; i++) {
        printf("%d ", arr3[i]);
    }

    return 0;
}

 
 #include <stdio.h>
 
 #define ARRAYSIZE 6
 #define MAX 4
 
 int main()
 {
     int arr[] = {2, 1, 3, 2, 1, 4};
    int final[ARRAYSIZE];

    // Given we know max element in array
    // This technique is based on counting sort
    int count[MAX + 1] = {0};
    int i = 0;
    int j = 0;

    for (i = 0; i < ARRAYSIZE; i++) {
        count[arr[i]]++;
    }

    for (i = 0; i < MAX + 1; i++) {
        if (count[i] != 0) {
            while (count[i] != 0) {
                final[j++] = i;
                count[i]--;
            }
        }
    }

    printf("Sorted Array\n");
    for (i = 0; i < ARRAYSIZE; i++) {
        printf("%d ", final[i]);
    }

    return 0;
}

 
 #include <stdio.h>
  
 int getOddOccurrence(int ar[], int ar_size)
 {
      int i;
      int res = 0; 
      for (i=0; i < ar_size; i++)     
         res = res ^ ar[i];
      
     return res;
}
 
/* Diver function to test above function */
int main()
{
     int ar[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
     int n = sizeof(ar)/sizeof(ar[0]);
     printf("%d", getOddOccurrence(ar, n));
     return 0;
}

 
 // Program to find the two odd occurring elements
 #include<stdio.h>
  
 /* Prints two numbers that occur odd number of times. The
    function assumes that the array size is at least 2 and
    there are exactly two numbers occurring odd number of times. */
 void printTwoOdd(int arr[], int size)
 {
  int xor2 = arr[0]; /* Will hold XOR of two odd occurring elements */
  int set_bit_no;  /* Will have only single set bit of xor2 */
  int i;
  int n = size - 2;
  int x = 0, y = 0;
 
  /* Get the xor of all elements in arr[]. The xor will basically
     be xor of two odd occurring elements */
  for(i = 1; i < size; i++)
    xor2 = xor2 ^ arr[i];
 
  /* Get one set bit in the xor2. We get rightmost set bit
     in the following line as it is easy to get */
  set_bit_no = xor2 & ~(xor2-1);
 
  /* Now divide elements in two sets: 
    1) The elements having the corresponding bit as 1. 
    2) The elements having the corresponding bit as 0.  */
  for(i = 0; i < size; i++)
  {
     /* XOR of first set is finally going to hold one odd 
       occurring number x */
    if(arr[i] & set_bit_no)
      x = x ^ arr[i];
 
     /* XOR of second set is finally going to hold the other 
       odd occurring number y */
    else
      y = y ^ arr[i]; 
  }
 
  printf("\n The two ODD elements are %d & %d ", x, y);
}

/* Driver program to test above function */
int main()
{
  int arr[] = {4, 2, 4, 5, 2, 3, 3, 1};
  int arr_size = sizeof(arr)/sizeof(arr[0]);
  printTwoOdd(arr, arr_size);

  return 0;
}

 
 #include <stdio.h>
 
 int main()
 {
     int arr[] = {-2, -3, 4, -1, -2, 1, 5, -3};
 
     int best = -1110;
     int sum = 0;
    int indx = 0;
    int i = 0;
    int x = 0; // start of max sub array
    int y = 0; // end of max sub array
    int n = 8; // size of array

    for (i = 0; i < n; i++) {
        if (sum <= 0) {
            sum = arr[i];
            indx = i;
        } else {
            sum += arr[i];
        }

        if (best < sum) {
            best = sum;
            x = indx;
            y = i;
        }
    }

    printf("Max sum %d, start index %d, end index %d\n", best, x, y);

    return 0;
}

 
 #include <stdio.h>
 #include <string.h>
 
 #define TEST 1
 
 void permute(int *s, int start, int end);
 void swap(int *s, int start, int end);
 void startTesting();

int main(void) {
#ifdef TEST
    startTesting();
#endif

    return 0;
}

void swap(int *s, int start, int end) {
    int temp = s[start];
    s[start] = s[end];
    s[end] = temp;
}

void permute(int *s, int start, int end)
{
    int i = 0;
    int j = 0;

    if (start == end) {
        for (i = 0; i < 4; i++) {
            printf("%d ", s[i]);
        }
        printf("\n");
    } else {
        for (j = start; j <= end; j++) {
            swap(s, start, j);
            permute(s, start + 1, end);
            swap(s, start, j);
        }
    }
}

void test1()
{
    int s[] = {1, 2, 3, 4};
    int i = 0;

    printf("permute \n");
    for (i = 0; i < 4; i++) {
        printf("%d ", s[i]);
    }
    printf("\n");

    permute(s, 0, 3);
    printf("\n");
}

void startTesting()
{
    test1();
}

 
 #include <stdio.h>
 #include <string.h>
  
  
 int main(void) {
     int i = 0;
     char str[] = "testString";
     int len = strlen(str);
 
    for(i = 0; i < len/2; i++){
        str[len - i - 1] ^= str[i];
        str[i] ^= str[len - i - 1];
        str[len - i - 1] ^= str[i];
    }

    printf("Reverse String %s \n", str);
 
    return 0;
}

 
 #include <stdio.h>
 
 void printDup(char *str)
 {
     int count[256] = {0};
     int i = 0;
 
     while (*str != '\0') {
        count[*str++]++;
    }

    for (i = 0; i < 256; i++) {
        if (count[i] > 0) {
            printf("%c %d\n", i, count[i]);
        }
    }
}

int main()
{
    char *str = "Foo Bar";

    printDup(str);

    return 0;
}

 
 void removeDup(char *str)
 {
     int read = 0;
     int write = 0;
 
     while (str[read] != '\0') {
         while (str[read] != '\0' && str[read] != str[read + 1]) {
             str[write++] = str[read++];
        }

        while (str[read] != '\0' && str[read] == str[read++]);
    }
}

 
 #include <stdio.h>
 
 void reverseArr(int arr[], int start, int end)
 {
     int temp = 0;
 
     while (start < end) {
         temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;

        start++;
        end--;
    }

}

int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7};
    int rotate = 2;
    int size = 7;
    int i = 0;

    reverseArr(arr, 0, rotate - 1);
    reverseArr(arr, rotate, size - 1);
    reverseArr(arr, 0, size - 1);

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

    return 0;
}