Good Example of Implicit type using functions. Basically, it introduces the notion of boundedness in a polymorphic way.

You need to note that, we start from 0,1 and 1,0 explicitly and not from 0,0 as that would lead to inplace turning.

http://code.geeksforgeeks.org/5nOcuP

Our notes:

1. Iterator on keyset of Concurrent Hash Map does not use a separate snapshot copy of the map. So, you can witness some/none/all changes from other threads which are changing the same hashmap concurrently. It just reflects that this element existed in the hashmap at some point in time

2. In copy on write arraylist, the iterator will never pick up parallel changes by other threads, as it creates a snapshot copy at the time of iterator creation.

Iterators to iterate over different classes, via a single interface.

Integers are immutable, when you add two integers a new integer object is formed. Each integer internally keeps an int value which is final and can't be modified. + operator is compiler magic.

Good example of how gof patterns are used in the JVM, Interger.valueOf keeps a configurable cache of Integer objects, note that integer objects are immutable.

Example of adaptor pattern. Here's the array serves as the backing point for the list, all methods of list api will be driven on basis of operations on the underlying array.

Prototype design pattern with warlord, beast and mage, orcs and elfs, we keep a hashmap of each object ready in the factory at time of factory construction or lazily. Then when a new Warlord is requested, an existing warlord is cloned and used.

This example finally does a "new" inside clone(), rest is good.

Diff between flyweight and object pool pattern lies in nature of vended object is immutable or mutable.

Good example of composite design pattern.

Here we can have two underlying data structure for a stack, an array or a list (similar to different platforms, example, unix, windows). An orthogonal set of hierarchy will be StackHanoi, which only allows to add an element if it is smaller than the top of the stack. Another hierarchy is FIFO implementation using stack. Now for each of the orthogonal implementation since we can choose a list or an array for the underlying implementation.

So, the underlying implementation forms another interface hierarchy of StackImpl, and actual Stack will "have a" StackImpl.

Now you may think it is similar to decorator-

differences: ->in decorator , you try to add behaviour on top of original functionalities. (like keeping a count whenver you call original functionalities like pop, push etc) but in bridge, you are selectively calling the original functionality or else you override the original. ->decorator here will only have one class that encapsulates all original impl but in bridge , your platform independent things are kept via 'has a' relation inside your handle, and your orthogonal functionalities will be extending that handle .

Example of Adaptor pattern, slightly contrived.

Nice example of Decorator pattern.

Good explanation of Adaptor Design pattern

The SOLID principle for OOPs.

Good example of builder pattern.

Find the maximum path sum between "any" two leaves of a binary tree

Good explanation of Clone, except doesn't cover the mandatory nature of Cloneable, one of the classes up our hierarchy should implement Cloneable, for you to call clone() on it, without encountering a runtime exception.

Start Node is not needed in this program ,see : http://code.geeksforgeeks.org/r7PSjB

int _bsearchForFO(int arr[], int left, int right, int elem) {<br> if(right - left <= 1) { if(arr[left] == elem) return left; else return right; } int mid = left+right/2; if(arr[mid] == elem) { return _bsearchForFO(arr,left,mid,elem); }else{ return _bsearchForFO(arr,mid,right,elem); }

}

The third tricky solution is same as Kadane, just that we can modify the original aray, we did Kadane with two variables, here we can use the diff array itself for storing the sums, so we check the sum of i-1 at i.

if an element is not at its correct position, that means repetition has already ocured in the left if the element is at its correct position, there is possibility of repetition in the right side

All things /proc !

https://www.youtube.com/watch?v=8P-Z7Oc8x9I

just apply regular kadane from front and backward and do fw[i-1]+b[i+1] sum in the same way. Also have to keep max_so_far in consideration for an all positive number scenario. note- indexes are not visible from any of these approaches

xor was also used in the problem to find the no occrinf odd number of times in an array (all other numbers occur even number of times)

You have two options for the iteration in first loop:

Either sort the array and iterate over the elements present only in the array. Or iterate from min_value to max_value which checks every number, irrespective of its presence in given array or not.

You have two options for the iteration in first loop:

1. Either sort the array and iterate over it.
2. Or iterate from min_value to max_value

We can use the following condition as well:

value[j] == 0 || value[j/i] == 0

This is because in cases where value[j/i] =0 , the loop in doing redundant work.

When none of the left or right subtree is taken,so 1 initially.

If you can arrange left subtree in x ways and right subtree in y ways, then you can have total x*y combinations for their parent, each of which will be a full binary tree..

This is to ensure cases where left and right subtree are same are not counted twice.

This ensures that when we calculate value[j/i], it will be available.

1. Full binary tree can have leaves at any level.
2. Each node has either 2 or 0 children.

1. if negative numbers are allowed, then the solution will fail because:

-1 -2 3 4 5

We would like to use -1,-2 for solution to 4.

Also ,if we have to find the maximum this logic will not work, because then again we will like to keep all numbers, and not just one of them which is solution assumes.

In general, if we have to minimize the result, then question will keep the restriction on skipping elements, but when we have to maximize the result, then question will put restriction on including the elements.

https://www.youtube.com/watch?v=39grPZtywyQ

We want cases where maximum > k only.

9 8 7 1 2 3 4 19 12

No. of subarrays = subarrays of size 1 + subarrays of size 2 + subarrays of size 3 + .... subarrays of size n

= n + (n-1) + (n-2) + .... + 1 = n(n+1)/2

Since we use less than here, so in cases of repetition of the minimum, we do have the first occurence only.

This is because both the ends of the range li,ri are inclusive.

This is like making the node black, so basically

   a
b    c

case 1: edges are a->b, a->c, c->b (not a cycle) case 2: edges are a->b, a->c, c->a (cycle)

When we are exploring c, b is black, considering we have already visited b first during dfs from a, and any link to black nodes do not constitute a cycle.

This is an overkill, as a node cannot have two neighbours in the given problem.