In combinatorics,"n choose k"  (formally represented as   ) is called the choose function of n and k.It is interpreted as the number of ways that k things can be ‘chosen’ from a set of n things.Alternative representation of "n choose k"  include C(n, k), _nC_k or .

We define C(n, k) in the following ways:

and

where n! denotes the factorial of n.

Alternatively, a recursive definition can be written as

where,

Now having that  mathematics in our hands let us now try to  develop a program ,we will start with  simple and direct implementation and then go for efficient ones.

But before proceed any further, let us recall one more property : C(n, k) = C(n, n-k) ,this is actually a very good optimization when (k > (n/2))

First direct implementation in  C++ :     

int Factorial(int num) {
   int res = 1;
    while(num > 0){
        res = res * num;
        num = num - 1;
    }
   return res;
} 

int iterative_C(int n, int k){
     if(k > (n/2))
        k = n - k;
    return (Factorial(n)/(Factorial(k)*Factorial(n - k)));
}  

The recursive version (C++):

int recursive_C(int n,int k) {
    if(k > (n/2))
       k = n-k;
    else if((0 == k) || (n == k))
         return 1;
    else
      return recursive_C(n-1,k) + recursive_C(n-1,k-1);
}

But, both of the above two version will be very poor as per C/C++ is concerned.The reason is that C/C++ doesn’t support any BigInteger class to handle large results as produced in the intermediate steps.

                                 To understand the problem let us consider one small example,Let n = 100 and k = 9 then C(100,9), Computing 100! (which looks like this) will certainly produce overflow even if we use unsigned long long. (long long is not part of the C++09 standard but only (usually) supported as extension).

                                      But in most problems of online judges inputs are like these only,so do we have to learn python or Java for solving those problems or start breaking head in writing an arbitrary high-precision integers in C++ ? The answer is NO.

Hopefully we have a workaround , by breaking up the steps of n choose k we can easily notice that there is no need of computing all the factorials.Let us see,

C(8,2) = (8*7)/(2!) = (8*7)/(1*2)

C(15,3) = (15*14*13)/(3!) = (15*14*13)/(1*2*3)

C(100,5) = (100*99*98*97*96)/(5!) = (100*99*98*97*96)/(1*2*3*4*5)

In general,

C(n,k) = (n * n-1 * n-2 * n-3 * … * n-k+1) / (1 * 2 * 3 * … * k).

This is a simple but  huge optimization.

A straight forward implementation in C++ :

int optimized_integer_C(int n,int k){
    int i,temp = 1;
    if(k > (n/2))
         k = n-k;
    for(i = n; i >= (n-k+1); i--){
       temp = temp * i;
    }
    return (temp/Factorial(k));
}

Is it all ? Can’t we optimize more ?

The answer is No. C/C++ has very powerful data type called double.(I am calling it powerful as I personally use this data type while solving many contests problems.)But how to use double here ? The answer is quite simply, see this code snippet :

typedef typedef unsigned long long int UL;

double optimized_double_C(UL n,UL k){
    double answer = 1.0;
    UL i;
    if(k > (n/2))
        k = n-k;
    for(i = 0; i < k; i++){
         answer = answer * ((double)(n-i)/(double)(i+1));
      }
    return answer;
}

int main(void){
   double res = optimized_double_C(100,4);
   double res_1 = optimized_double_C(98,3);

   printf("C(100,4) = %.0lf \n",res);
   printf("C(98,3) = %.0lf \n",res_1);

   return 0;
}

This is best solution (AFAIK) possible in C++  for the concerned problem.I will soon also add a program that will present the relative differences between the discussed approaches.

After you finished reading this article you may be interested in solving some problems :

1. Combinations

2. Binomial Showdown

3. Marbles

4. Project Euler 53.

References:

http://en.wikipedia.org/wiki/Binomial_coefficient

In number theory a positive integer N (say) is referred to as practical number or panarithmic number if every positive integer less than N is either a divisor or a sum of distinct divisors of N.

For example: say N = 12 the divisors of 12 are 1,2,3,4,6. So 1,2,3,4 & 6 are represented by the divisors themselves.Then we have 5=3+2, 7=6+1, 8=6+2, 9=6+3, 10=6+3+1, and 11=6+3+2.So 12 is a practical number.

The first few practical numbers are: 1, 2, 4, 6, 8, 12, 16, 18, 20, 24, 28, 30, 32, 36, 40, 42, …

Careful observation of practical number sequence A005153 in On-Line Encyclopedia of Integer Sequences(OEIS), reveals:

 

1.If a number is a power of 2 then it is a practical number.

2.No odd number can be a practical number.All practical numbers are even.

3.Every perfect number is a practical number.(Perfect numbers n: n is equal to the sum of the proper divisors of n.)

 

Keeping all this together I tried to devise an efficient algorithm :

1.If the number is less than Zero or an Odd number, return false.

2.If the number is a power of 2, return true.

3.Else,find all the divisors of the number.

4.Compute the the divisors summation of the number keeping in track current sum must be greater than or equal to the ( current divisors – 1 ).If any number failed in this this test then return false.

5.Check if the Final sum is greater than or equal (for perfect numbers) to the number in question.If yes return true else return false.

You can speed up the process by building a prime table and then computing for the sum in the divisor computation itself.

The algorithm put in C++ looks like this:

typedef unsigned long int UL;

bool ispractical(UL num){
       if(0 >= num)
            return false;
       if (1 == num)
            return true;
       if((1&num))
            return false;
       if(!(num &(num - 1)))
            return true;

      UL i, sum = 0;
      vector<UL> Divisors;
      Divisors.push_back(1);

      for(i=2;i*i<=num;i++){
        if(0 == (num%i)){
          if(i*i == num){
            Divisors.push_back(i);
            continue;
           }
          Divisors.push_back(i);
          Divisors.push_back(num/i);
        }
      } 

     sort(Divisors.begin(),Divisors.end()); 

     UL size = Divisors.size();
     for(i = 0; i= Divisors[i]-1)
          sum+=Divisors[i];
       else
         return false;
    }
    return (sum >= num);
}

If you are interested you can check the entire program of mine.It includes comments which  I added during the debugging phase.

List of Practical numbers I generated with my program:

Practical numbers up to 100 (0.028 sec)

Practical numbers up to 1000 (0.067 sec)

Practical numbers up to 10000 (0.623 sec)

Practical numbers up to 100000 (14.218 sec)

References :

http://en.wikipedia.org/wiki/Practical_number

http://mathworld.wolfram.com/PracticalNumber.html

1.What are the different notations in the algorithm world ?

 

A book can be written to answer this question.Well,in simple terms there are two basic notations Big Oh notation & Big Omega notation.

Big Oh notation: Big Oh notation describes the upper limit or worst case computation of an algorithm. This notation doesn’t indicate best case or average case it rather looks for the maximum amount of time an algorithm can take.

For example if you can solve some algorithm using (n^2) time complexity and after optimization, the best case might give you (nlogn) complexity but Big Oh notation will be still (n^2). Big Oh will give the idea for keeping the maximum resource to run the algorithm smoothly that is the worst case.

 

Again it will be better to conclude that Big Oh gives the upper bound of an algorithm instead of saying that its the worst case to be politically correct.

Big Omega notation: It is just opposite to the Big Oh notation. That means it is corresponding to the lower limit of any algorithm.

EDIT: There are also other few notation like theta notation,little-O notation,little omega Notation.Inquisitive persons may visit here.

 

 2.What do you mean by logn order of complexity? 

 

If a problem can be solved by divided into sub problem and each problem can be again divided into further sub problem until it comes under control to solve by looking into it.

Then the problem is solvable in logn order of complexity.

 

3. What is the base of logn complexity? Is the base is constant for all algorithm that gives logn complexity ? 

 

Well,we don’t have any fixed base.The base of the log is taken from the way the problem is divided. If the problem can be divided exactly into two sub problem and then again two then the base will be 2. If the problem can be divided into 3/2 sub problem ( 1/3 ,2/3,.. each time) then the base will be 3/2.

.

Not after much thinking I am able to write two macros:(I supposed 32 bit integer)

#define RLC(num,pos) ((num << pos)|(num >> (32 - pos)))
#define RRC(num,pos) ((num >> pos)|(num << (32 - pos)))

For guys who prefer functions instead of macros for obvious reasons :

unsigned long Rotateleft(unsigned long n,unsigned long i)
{
   return (n << i)|(n >> (32 - i));
}

unsigned long Rotateright(unsigned long n,unsigned long i)
{
   return (n >> i)|(n << (32 - i));
}

there nothing much to explain in this code,it’s pretty clean job but if you still struggle take a pencil & paper

 
* i) 3 2 7 10 should return 13 (sum of 3 and 10)
* ii) 3 2 5 10 7 should return 15 (sum of 3, 5 and 7)

An interesting interview problem a slight variation of the longest common subsequence problem.Many solution can be possible for me using DP here may be a overkill My straight forward O(n) solution:

int MaxNoncontSum(int buf[],size_t cnt)
{
     int incl = 0,    // max sequence including the previous item 
         excl = 0,   // max sequence excluding the previous item 
         excl_new = 0; 

     size_t i; 

     for(i = 0; i<cnt; i++)
       {
         excl_new = max(incl,excl); // current max excluding i 

         incl = excl + buf[i]; // current max including i 
         excl = excl_new;
       } 

       return max(incl,excl);
}

For lame guys here is the entire program.

Well this was the straight forward old interview question,What if we consider a slight variation ? Lets allow  negative numbers within the array too. I am too lazy to construct a new solution for this variation,luckily a slight variation of my above solution holds good for negative numbers too

Here is the solution:

#define max3(a,b,c) ((a)>(b))?(((a)>(c))?(a):(c)):(((b)>(c))?(b):(c))

int __MaxNoncontSum(int buf[],size_t cnt)
 {
     size_t i;
     int incl = 0,
         excl = 0,
         excl_new = 0;

     for( i = 0; i<cnt; i++)
        {
            excl_new = max3(incl,excl,0);

            incl = excl + buf[i];

            excl = excl_new;
        }

      return max3(incl,excl,0);
 }

Lame persons help yourself

Declaration is a promise that an object (or function) has been created. Definition is an instruction to create it. Therefore, definitions effectively count as declarations, but not vice versa.

Just like all cats are animals, but not all animals are cats.In mathematics  the declaration can be considered a superset of definition or definition the subset of declaration.

A possible clarification of this from standard can be :

Because of how terminology is used in the ISO Standard,
in a function like this —

int  foo(){
        int x;
        x = 3;
        return  x;
    } 

the line ‘int x;’ is a "definition" as the Standard uses the term, even though many or most developers would refer to this line just as a declaration.

I took up one of such solution:

int main()
{
    int num1 = 3, num2 = 2,sum;
   sum=printf("%*s%*s",num1,"",num2,"");
   printf("%d",sum); 

}  

this trick works good, i’m pretty sure this is conforming C, but the approach is pretty hackish.  It does seem pretty creative, though.

7.19.6.4(c99) 

" the field width takes the form of an asterisk * (described later) or a nonnegative decimal integer "

if an asterisk is used, the corresponding positional argument is used to

determine the field width.

so, the line

printf("%*s%*s", 3, "", 2, "");

prints "" within a field of 3 chars, and "" within a field 2 chars.

printf() returns the total number of chars printed, which is 5 + 7 in this

case. this effectively computes a sum without using the ‘+’ operator.

but what happen if either of num1 or num2 is negative ? will it invoke undefined behavior ?

the answer is no. in the same paragraph of the standard (7.19.6.1, paragraph 5):

"a negative field width argument is taken as a – flag followed by a positive field width."

paragraph 6 describes the effect of the – flag:  it will cause

the string to be left-justified within the field, rather than

right-justified (this obviously has no effect on the output

when the string has length 0).

printf("%*s%s\n", 10, "hello", "hello");

output:

     hellohello

printf("%*s%s\n", -10, "hello", "hello");

output:

hello     hello

thus for the following line:

      printf("%*s%*s", num1, "", num2, "");

 
is the sum of the absolute values of num1 and num2, which is the

sum of num1 and num2 only if both are nonnegative.

so a more elegant solution of this problem will be :

int add(int x, int y)

{

  return y ? add(x ^ y, (x & y) << 1) : x;

}

explanation:

lets consider you want to add 34590 and 987387065 in decimal notation.

   9 8 7 6 8 7 0 6 5

+          3 4 5 5 9 0

—————————

   9 8 7 9 2 2 5 5 5 —-> addition of digits neglecting carry

+ 0 0 0 1 1 0 1 0 0 —> represents carry

————————–

   9 8 7 0 3 2 6 5 5

+ 0 0 1 0 0 0 0 0 0

—————————

   9 8 8 0 3 2 6 5 5

+ 0 0 0 0 0 0 0 0 0

so answer is 988032655.

similarly, in terms of bit representation, for addition of two numbers ‘x’

and ‘y’, (x&y)<<1 represents the carry number and x^y represents the number neglecting the carry. so for example let the number is 43 & 14.

x = 43 = 1 0 1 0 1 1

y = 14 = 0 0 1 1 1 0

   1 0 1 0 1 1

+ 0 0 1 1 1 0

——————

   1 0 0 1 0 1 —> x^y

+ 0 1 0 1 0 0 —> (x&y)<<1

——————

   1 1 0 0 0 1

+ 0 0 1 0 0 0

——————

   1 1 1 0 0 1

+ 0 0 0 0 0 0

——————

hence 43 + 14 = 111001 = 57

there are many other possible solution for this,but if i ever faced this in my life i will write the above one,short,simple & elegant

Well again the inspiration came from a SPOJ classical problem PALIN.

A naive brute force will always show TLE ! Just go through the next section you may solve PALIN ,
Let us first simply rotate the number around its center,Let us  refer to this as mirroring from here onwards.

Suppose a number 15110, mirror the first half values across the central ’1′ to give 15151. If the number has an even number of digits, just mirror it about the center of the number, like 4629 to 4664.

That strategy works as long as the resulting ‘mirror-imaged result’ is greater than the original number.

If it results in a number less than or equal to the Inputted number then we need to do some more work.Now there are few cases to consider here:

If the number had odd number of digits:
For this we have to increment the middle digit and then do a mirror image.
So,121 becomes 131 and some bigger number like 12321 will become 12421.

If the number had even number of digits:
For this let us increment the digit to the left of the middle , and do the mirror image.
Thus,4334 becomes 4444.

There is one more problem ,what happen when 9 is encountered,Lets, see 31925. Simple mirroring would give 31913, but that’s not the correct answer!Incrementing the 9 to 10 would give 311013, which is again not a palindrome.

I will tackle that with carrying over ,Wherever the 10 occurred (incrementing 9), we would keep the 0 there itself, carry over the 1 to the previous digit.

 
So here, 98989 would become 99089 which on applying mirroring (according to the number of digits it now have) would give 99099.

One of the advantage of this Algorithm is the cases such as ‘999999’  take care of themselves and no ‘special cases’ is necessary.

Wow ! I explained a lot this time So I will not give away my AC solution this time instead of that you may have this,It’s an exact implementation of the above algorithm in C.

Hint for PALIN:Either implement your Bignum library in C/C++ or convert this code into Python or Java

EDIT: After couple of months today (October 21,2009) I solved PALIN again (On Pinged by my friend Saurabh) but this time I used a bit different approach,although I got AC but this time the time complexity is  bad compared to my previous solution !,Well today I am not in a mood to explain the whole Algorithm  so I give away the code this time.

PS: If you think of cheating,go ahead but you are cheating no one except yourself !

int i, n=20;
int main() {
  for(i=0; i<n; i--) {
    printf("*");
  }
}

Now the challenge is to modify this code such that it prints exactly 20 ‘*’ and nothing more, you are only permitted to make exactly ONE of these modifications to the source:

1) Add one character to the source.

2) Delete one character from the source.

3) Replace one character in the source by a different one.

This is quite an easy and the three  solution of this  puzzle can be found here.

But I haven’t found any solution using the constraint 2,If you have it let me know.

Now the variation that interests me is to modify the same code such that it prints exactly 21 ‘*’ and nothing more, the constraints remaining the same.

Well this is now a bit interesting isn’t ?

Well I can think of a solution with bitwise complement operator (~)

The bitwise complement operator, the tilde, ~, flips every bit. if you have a 1, it’s a 0, and if you have a 0, it’s a 1. For sample program  visit here.

So now the solution of the variant using constraint 1:

int i, n=20;
int main() {
  for(i=0; ~i<n; i--) {
    printf("*");
  }
}

Well this is an implementation dependent solution considering that most modern computers typically use the two’s-complement representation.But fails otherwise.Have a look here.

But considering it’s an interview question my solution is not that bad at all

Well,still if you had some other solution don’t forget to share.

Now as you completed reading this may be you are interested in solving a SPOJ tutorial problem BCEASY

Well,there is another option you have with the dos command NETSTAT.The documentation of the command can be found here.

For this program I am not at all interested in options,other than –e,

NETSTAT [-a] [-b] [-e] [-f] [-n] [-o] [-p proto] [-r] [-s] [-t] [interval]

 
  -e            Displays Ethernet statistics.

NWTSTAT –e outputs in the following format :

Interface Statistics

                               Received              Sent

Bytes                        105168          358931
Unicast packets              279              1507
Non-unicast packets       836              1216
Discards                              0                    0
Errors                                  0                    0
Unknown protocols             0

Now of these things what we need is bytes received & sent,this gives your net usage in bytes but am too lazy to divide it every time  by 1024×1024 or 1048576 bytes ,to get the usage in MB. So why not write a program which shows the output in MB every time it’s get executed

well,this is actually not my idea it’s rather a friend of mine Sai Krishna who first created this,his code can be found here.But it needs a batch file which generate the output,Sai’s code independently do not produces the output.

I just made it to work from a single source file for that I send the output of the netstat –e to a temporary file and then use fscanf() to get it from there.Pretty nice trick .Well, here is what I the final code stands.