For example : We have sequence : 1,8,2,7,3,6,4,5 which has the longest increasing subsequence : 1,2,3,4,5. How to arrive at this in O(n log n) ?

The O(nlogn) algorithm works as follows:
Let the array be A[1...n] i.e elements are A[1], A[2], .. , A[n], assume all are distinct.
Idea is to maintain for each k, the smallest element A[ik] such that the maximum length monotone subsequence that ends at A[ik] is of length k.

Lets walk through the solution.

1. Start off with A[1] = 1. For this array we get i1 = 1. Now add A[2]=8 to the list.
• Since A[2]>A[1], we get i2=2. Now the list contains [1,8]
2. Try adding A[3]=2 to the list.
• Since 1<2<8, we set i2=3. List now has [1,2]
3. Try adding A[4]=7 to the list.
• Since 7>2, we set i3=4. List now has [1,2,7]
4. Try adding A[5]=3 to the list.
• Since 2<3<7, we set i3=5. List now has [1,2,3]
5. Try adding A[6]=6 to the list.
• Since 6>3, we set i4=6. List now has [1,2,3,6]
6. Try adding A[7]=4 to the list.
• Since 3<4<6, we set i4=7. List now has [1,2,3,4]
7. Try adding A[8]=5 to the list.
• Since 5>4, we set i5=8. List now has [1,2,3,4,5]

Note that in this case walking the tree gave you the right sequence, but that need not be true for all sequences. The algorithm I gave gives the length of the longest sequence, you will have to modify it to get the exact sequence.

private static void reverseIterative()
        {
                Node prev=null;
                Node current= head;
                Node next=null;
                while(current != null)
                {
                        next = current.next;
                        current.next = prev;
                        prev = current;
                        current = next;
                }
                head = prev;
        }

This is simple and has the following complexity :
Time Complexity: O(n)
Space Complexity: O(1)

The recursive method needs a bit of thinking – lets visualize our problem first.

The logic looks like this :
1) Divide the list in two parts – first node and rest of the linked list.
2) Call reverse for the rest of the linked list.
3) Link rest to first.
4) Fix head pointer

Example:
Inputs: 1->2->3->4->5->6->7->8->NULL and k = 3
Output: 3->2->1->6->5->4->8->7->NULL.

Inputs: 1->2->3->4->5->6->7->80->NULL and k = 5
Output: 5->4->3->2->1->8->7->6->NULL.

Algorithm: reverse(head, k)
1) Reverse the first sub-list of size k. While reversing keep track of the next node and previous node. Let the pointer to the next node be next and pointer to the previous node be prev.
2) head->next = reverse(next, k) /* Recursively call for rest of the list and link the two sub-lists */
3) return prev /* prev becomes the new head of the list (see the diagrams of iterative method of this post) */

class ReverseKLL
{
        static class Node
        {
                int data;
                Node next;
                Node(int data)
                {
                        this.data = data;
                        next =null;
                }
        }
        public static Node head = null; //Create head node
        //Recursive Reversal of a group of k elements
        //1. Reverse the first sub-list of k element and keep track of next and previous nodes
        //2. head.next = reverse(next,k ) - recursively call this function on sub-groups
        //3. return prev  - prev becomes new next
        private static Node reverse(Node node, int k)
        {
                Node current = node;
                Node next= node, prev=null;
                int count = 0;
                //reverse first k elements
                while(current != null && count < k)
                {
                        next = current.next;
                        current.next = prev;
                        prev = current;
                        current=next;
                        count ++;
                }
                //next is now pointer to k+1th node. Recursively call reverse
                //for the list starting from that point
                if (next!=null)
                {
                        node.next = reverse(next,k);
                }
                //prev is the new head
                return prev;
        }
        //utility methods
        //push a node in the ll
        private static void push(int data)
        {
                Node newnode= new Node(data);
                newnode.next = head;
                head = newnode;

        }
        public static void printList(Node node)
        {
                while (node != null)
                {
                        System.out.println(node.data);
                        node = node.next;
                }
        }
        public static void main(String args[])
        {
               ReverseKLL kll = new ReverseKLL();
               kll.push(8);
               kll.push(7);
               kll.push(6);
               kll.push(5);
               kll.push(4);
               kll.push(3);
               kll.push(2);
               kll.push(1);

               kll.printList(head);
               head=kll.reverse(head, 3);
               System.out.println("===========================");
               kll.printList(head);

        }
}

Algorithm:
For Intersection of two arrays, print the element only if the element is present in both arrays.
1) Use two index variables i and j, initial values i = 0, j = 0
2) If arr1[i] is smaller than arr2[j] then increment i.
3) If arr1[i] is greater than arr2[j] then increment j.
4) If both are same then print any of them and increment both i and j.

Code:

a1 = [1,3,4,5,7]
a2 = [2,3,5,6]
i,j = 0,0

#Get length of the larger array as the count
count = (max(len(a1), len(a2))) 

for x in range(0,count):
        if (a1[i]  a2[j]):
                j = j+1
        elif (a1[i] == a2[j]):
                print a1[i]
                i = i+1
                j = j+1

The simpler logic would be to :

1. Use some sort of a hash structure
2. Sort all words alphabetically and use the sorted word as the key
3. If the key is found, keep on adding the original word to the ‘value’ list of strings

Something like this :

def compare_sort(x):
        sorted_key_list = list(x)
        sorted_key_list.sort()
        sorted_str = ','.join(str(n) for n in sorted_key_list)
        sorted_str = sorted_str.replace(',','')
        return sorted_str

source = ['tab','bat','atb','tac','cat','xyz']

target_hash = {}

for x in source:
        sorted_key = compare_sort(x)
        print sorted_key

        if target_hash.has_key(sorted_key):
                existing_list = target_hash[sorted_key]
                existing_list.append(x)
                target_hash[sorted_key] = existing_list
        else:
                target_list =[x]
                target_hash[sorted_key] = target_list

print target_hash

also, a must read – http://news.ycombinator.com/item?id=1633892

Knuth Shuffle / Fisher-Yates Shuffle(Modified version by Durstenfeld) algorithm is the answer to all the trick questions. So how does this algorithm work ?

Fisher and Yates’ original method was designed to be implemented using pencil and paper, with a precomputed table of random numbers as the source of randomness. Modern approach suggested by – Richard Durstenfeld is as follows:

To shuffle an array a of n elements:

for i from n - 1 downto 1 do
         j ← random integer with 0 ≤ j ≤ i
         exchange a[j] and a[i]

Reduced time complexity to O(n), compared to O(n²) for the naive implementation. A sample java implementation :

import java.util.Random;

static Random rng = new Random();
public static void shuffle(int[] array) {
    // i is the number of items remaining to be shuffled.
    for (int i = array.length; i > 1; i--) {
        // Pick a random element to swap with the i-th element.
        int j = rng.nextInt(i);  // 0 <= j <= i-1 (0-based array)
        // Swap array elements.
        int tmp = array[j];
        array[j] = array[i-1];
        array[i-1] = tmp;
    }
}

Finally, today I stumbled upon a very practical article : Source Uploaded here.

Example:

     1
    / \
  2     3
 / \   / \
4   5 6   7

The tree has 5 vertical lines
Vertical-1: nodes-4 => vertical sum is 4
Vertical-2: nodes-2 => vertical sum is 2
Vertical-3: nodes-1,5,6 => vertical sum is 1+5+6 = 12
Vertical-4: nodes-3 => vertical sum is 3
Vertical-5: nodes-7 => vertical sum is 7
We need to output: 4 2 12 3 7

We can do an inorder traversal and hash the column. We call Traverse(root, 0) which means the root is at column 0. As we are doing our traversal, we can hash the column and increase its value by T.data. A rough sketch of my function looks like this -

Traverse(Tree T, int column)
{
if(T==NULL) return;
Traverse(T.left, column-1);
Hash(column) += T.data;
Traverse(T.right, column+1);
}

Traverse(root, 0);
Print Hash