Divya: ella not now, yethuva erunthalum oru 6 maasam agatum.
Shaju: Yen apathan Ganesh Indiaku varana ?
Divya: (She admitted) yes, I wanted to marry Ganesh

PS: dialogue are all my own. But the matter is same

And after this, as usual her mom was started crying. Actually I feel very very bad for her. I like her a lot and I feel very sad that becoz of me she is crying today . Sorry aunty.

Shaju was not happy with the way I handled the matter when we get caught last time. So this time he is not going to call me.

To be continued ..

# this will include the below directory for loading the modules.
use lib "C:\mydir\perlmodules\lib";

Soultion:

#include <iostream.h>
using namespace std;

typedef unsigned long long uint64;  //assume this gives 64-bits
unsigned long m1  = 0x5555555; //binary: 0101...
const uint64 m2  = 0x33333333; //binary: 00110011..
const uint64 m4  = 0x0f0f0f0f; //binary:  4 zeros,  4 ones ...
const uint64 m8  = 0x00ff00ff; //binary:  8 zeros,  8 ones ...
const uint64 m16 = 0x0000ffff; //binary: 16 zeros, 16 ones ...
const uint64 hff = 0xffffffff; //binary: all ones
const uint64 h01 = 0x01010101; //the sum of 256 to the power of 0,1,2,3...

//This is a naive implementation, shown for comparison,
//and to help in understanding the better functions.
//It uses 24 arithmetic operations (shift, add, and).
int popcount_1(uint64 x) {
    x = (x & m1 ) + ((x >>  1) & m1 ); //put count of each  2 bits into those  2 bits
    x = (x & m2 ) + ((x >>  2) & m2 ); //put count of each  4 bits into those  4 bits
    x = (x & m4 ) + ((x >>  4) & m4 ); //put count of each  8 bits into those  8 bits
    x = (x & m8 ) + ((x >>   & m8 ); //put count of each 16 bits into those 16 bits
    x = (x & m16) + ((x >> 16) & m16); //put count of each 32 bits into those 32 bits
    return x;
}

int countNaive(int number)
{
    int count = 0;
    while(number)
    {
        count++;
        number = number & (number -1);
    }

    return count;
}
int main()
{
    cout<<"Enter the number: ";
    int number;
    cin>>number;
    cout<<"Number of bits: "<<popcount_1(number)<<endl;
    cout<<"Number of bits(Naive Method): "<<countNaive(number)<<endl;
    return 0;
}

An array of size n among which there are n/2 0s and n/2 1s arranged in random order. Arrange all the 1s to left and all 0s to right but it needs to be stable i.e., the order of 1s and 0s in the i/p array should be maintained.

Expected Complexity:
——————–
O(N) with constant space.

Pseudocode:
———–
1. Have two counters, count1 = 0 and count2 = (n/2)+1
2. Traverse thru the array, if(arr[ i ] == 1) { arr[ i ] = count1++;} else { arr[ i ] = count2++ };

3) At the end of the traversal, you have array filled with numbers 0 to n-1

Now the problem reduces to sorting and array of n numbers which has elements from 0 to n-1 occuring only once which can be done in O(n).

for(j = 0; j <= 1; j++)
{
	for(i = 0; i<n; i++)
	{
		if(arr[ i ] != i)
		{
			swap(arr[ i ], arr[ arr[ i ] ]);
		}
	}
}

Note: j loop runs only twice irrespective on ‘n’ and has constant complexity. The order of this whole loop is 2*n = O(n).

4) After the array is sorted, Again traverse thru the array and make elements arr[0] to arr[n/2] to ’1′ and arr[(n/2)+1] to arr[n] as ’0′.

Space complexity is constant and time complexity is O(step2) + O(step3) + O(step4) = n + 2n +n = 4*n = O(n).

Solution #1 (Stable):
———————-

#include<iostream.h>
int a[] = { 1,0,0,0,1,1,1,0,0,1};
#define _SIZE sizeof(a)/sizeof(a[0])

/* Helper Function */
void printArray()
{
    for(int i=0;i<_SIZE; ++i)
        cout<<a[i]<<" ";

    cout<<endl;
}

int main()
{
    int countOne = 0;
    int countZero = (_SIZE)/2;

    int i=0;

	/* Fill the array with numbers from 1 to N */
    for(i=0; i < _SIZE; ++i)
    {
        if(a[i] == 1)
        {
            a[i] = countOne;
            countOne++;
        }
        else
        {
            a[i] = countZero;
            countZero++;
        }
    }
    printArray();

	/* Swap the number and make it a sorted one */
    for(int j = 0; j< 2; ++j)
    {
        for(i=0; i < _SIZE; ++i)
        {
            if(a[i] != i)
            {
                int temp = a[i];
                a[i] = a[a[i]];
                a[temp] = temp;
            }
        }
    }

    printArray();

	/* Fill the 1st N/2 elements with 1 */
    for(i=0; i<_SIZE/2; ++i)
        a[i] = 1;

	/* Fill the last N/2 elements with 1 */
    for(i=_SIZE/2; i<_SIZE; i++)
        a[i] = 0;

        printArray();

		return 0;
}

Solution #2 (UnStable):
———————-

Here is a small variation of the quick sort to solve the same problem but this solution is not stable. So I prefer #1.

#include<iostream.h>
using namespace std;
#define _SIZE sizeof(a)/sizeof(a[0])
void swap(int *a, int l, int r)
{
    cout<<"Swaping "<<l<<" "<<r<<endl;
    if(a[l] != a[r])
        a[l] ^= a[r] ^= a[l] ^= a[r];

    return;
}
bool compare_1_upper(int *a, int u, int p)
{
    return (a[u] == p);
}
bool compare_1_lower(int *a, int l, int p)
{
    return (a[l] < p);
}

bool compare_0_upper(int *a, int u, int p)
{
    return (a[u] > p);
}
bool compare_0_lower(int *a, int u, int p)
{
    return (a[u] == p);
}
bool (*funcPtr_upper)(int *, int, int) = 0;
bool (*funcPtr_lower)(int *, int, int) = 0;
void qPartition(int *a, int low, int upper)
{
    int pivot = a[low];
    int l = low - 1;
    int u = upper + 1;

    if(a[low])
    {
        funcPtr_upper = compare_1_upper;
        funcPtr_lower = compare_1_lower;
    }
    else
    {
        funcPtr_upper = compare_0_upper;
        funcPtr_lower = compare_0_lower;
    }

    while(1)
    {
        while(funcPtr_upper(a, --u, pivot));

        while(funcPtr_lower(a, ++l, pivot));

        if(l<u)
            swap(a, l, u);
        else
            return;

    }
    return;

}

int a[] = { 1,1,1,1,1,0,0,1};

void print()
{
    for(int i=0; i< _SIZE; ++i)
        cout<<a[i]<<" ";

    cout<<"\n";
}

int main()
{
    print();
    qPartition(a, 0, _SIZE - 1);
    print();
    return 0;
}

             1   2   3   4   5   6   7   8   9  10
            11  12  13  14  15  16  17  18  19  20
            21  22  23  24  25  26  27  28  29  30
            31  32  33  34  35  36  37  38  39  40
            41  42  43  44  45  46  47  48  49  50
            51  52  53  54  55  56  57  58  59  60
            61  62  63  64  65  66  67  68  69  70
            71  72  73  74  75  76  77  78  79  80
            81  82  83  84  85  86  87  88  89  90
            91  92  93  94  95  96  97  98  99 100

1. Cross out 1, because it is not prime.
2. Circle 2, because it is the smallest positive even prime. Now cross out every multiple of 2; in other words, cross out every second number.
3. Circle 3, the next prime. Then cross out all of the multiples of 3; in other words, every third number. Some, like 6, may have already been crossed out because they are multiples of 2.
4. Circle the next open number, 5. Now cross out all of the multiples of 5, or every 5th number.

Continue doing this until all the numbers through 100 have either been circled or crossed out. You have just circled all the prime numbers from 1 to 100!

#include <iostream.h>
#include <bitset>
using namespace std;
#define MAX 1000
void firstNPrime(int N)
{
    bitset<MAX> bitMap;
    bitMap.reset();

    cout<<"Printing Prime Numbers"<<endl;
    for(int i = 2; i< N; )
    {
        for(int j=i+i; j< N; j=j+i)
        {
            bitMap[j] = 1;
        }
        while(bitMap[++i]) ;
    }

    for(int k = 1; k<N; k++)
    {
        if(!bitMap[k])
        {
            cout<<k<<" ";
        }
    }
    cout<<endl;

}
int main()
{
    cout<<"Enter a no upto which u need the Prime Numbers: ";
    int number;
    cin>>number;
    firstNPrime(number);
    return 0;
}