# Number of ways to make coin change

Given some amount N, and a set of denominations, how do you find the number of ways to make change for N? Let us assume that there is infinite supply of coins for each denomination.

For example, if we have to make change for 4, and the given denominations are {1, 2, 3}, the possibilities are {1, 1, 1, 1}, {1, 1, 2}, {1, 3}, {2, 2}. So there are 4 possibilities in total.

Let us try to solve this problem using recursion. Let `N` be the amount for which we have to make change, and D is the set of denominations. Assume we have a method `Count` which takes in the parameter amount `N`, and the `index` of current denomination, we can have pseudo code like this

`Count(N, index)`

• `Base case#1: If N < 0 or index < 0 return 0. There is no way to make change for negative numbers or if there are no denominations`
• `Base case#2: If N == 0, return 1. There is only one possibility to make change for 0 amount, selecting none.`
• ```Otherwise return Count(N, index-1) + Count( N-D[index], index ). Either ignore the current denomination (First term), or take the current denomination(second term) and recurse accordingly. ```

Since this recursive method solves the same problem multiple times, we can think of a dynamic programming solution for this problem. In dynamic programming, we solve the smaller sub problems first and use their results in solving bigger sub problems. We store the results in a table. Lets create a `table[N+1][M]` where `N` is the amount, and `M` is the denomination count.

• `table[0][j] = 1, Only one way to make 0.`
• ```table[i][0] = 1 if N is divisible by D[0], otherwise 0 ```
• `table[i][j] = table[i][j-1] if D[j] > i`
`= table[i][j-1] + table[i- D[j]][j]`

Here is the Java code which implements the above approach.

# Maximum Xor of two bit patterns

Given two numbers `A, B`, What is the maximum value of `A' XOR B'`, where `A', B'` are obtained by permuting the binary representations of `A, B` respectively.

For example assume `A = 3, B = 1` and they are represented in 4 bits. `A = 0011, B = 0001` in binary. Suppose `A' = 1100, B' = 0010`, then we get the` A' ^ B' = 1110 = 13`. So 13 is the answer. For no other values of A’, B’, the XOR will be maximum.

Let us look at another example `A = 3, B = 7`, again represented using 4 bits. `A' = 0011, B' = 1101` and `A' ^ B' = 0011 ^ 1101 = 1110 = 14`. So 14 is the answer.

This problem was originally appeared on Codechef. The problem has 3 inputs N (number of bits), A, B. How many 1s are possible in the result number?

Since `1^0 = 1 and 0^1 = 1`, to get a 1 in the final result, We should have a

• 1 bit in A, and 0 bit in B or
• 0 bit in A, and 1 bit in B

So the total number 1s possible in the result is Minimum( 1s in A, 0s in B) + Minimum( 0s in A, 1s in B). The remaining bits are Zeros.

How should we arrange these bits to get the maximum value? All 1s should be pushed to left (Most significant bits). So the result will be of the form 1111…00

Here is the Java code which implements the above approach.

# Finding the the number at a given position in even odd array

Given a number N, an array is created by first adding all the odd numbers, and then adding all the even numbers below N, How do we find the number at a given position K?

For example consider N = 10, the array is `[1, 3, 5, 7, 9, 2, 4, 6, 8, 10]`, the number at position K = 3 is 5, similarly at K = 6, the number is 2 etc.

Let us look at a solution for this. First of all, we need not build the entire array for finding out a number at a given position. We can simply find a formula to calculate the number, as the array can be divided into two halves, and both of them are in arithmetic progression.

If the given index is in first half, `2*(pos-1)+1`, otherwise `2*(pos-n/2)` will give the required answer. Following is the C++ implementation.

This problem was originally appeared in Codeforces.

# Maximum increasing sub array

Given an array of numbers, how to find the maximum length of increasing (non-decreasing) continuous sub-sequence?

For example consider the array [7, 9, 1, 3, 5, 8, 2], the maximum length is 4. Similarly for [23, 10, 18, 18, 6], it is 3.

This is a straight forward implementation problem (appeared on Codeforces). Following is an implementation of O(n) algorithm.

# Check if an array has a sub-array with given sum

Given an array of numbers and a sum, how to check if there is any sub-array with the given sum.

For example consider an array A = [7, 2, 9, 1, 5], and the sum is 12, then we can find a sub-array [2, 9, 1] which sums up to 12. So the answer is Yes. If we want to check for sum 14, we can not find a sub-array with that sum.

A simple method is to check if a sum can be found for all possible sub-arrays. This solution takes O(n3) time.

A more efficient method is the sliding window method. We maintain two indices, one indicates the beginning of the window, and the other indicates the ending of the window.

While iterating through the elements, we increment the end-index as long as the current sum is less than or equal to the target. If we find the target sum, then we are done. If we exceed the target sum, we deduct the beginning elements from the current sum until it is less than or equal to target sum.

This approach takes O(n) time. Here is the C++ code.