## Problem Statement:

You are given a 2D array with dimensions 6*6. An hourglass in an array is defined as a portion shaped like this:

a b c
d
e f g


For example, if we create an hourglass using the number 1 within an array full of zeros, it may look like this:

1 1 1 0 0 0
0 1 0 0 0 0
1 1 1 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0


Actually, there are many hourglasses in the array above. The three topmost hourglasses are the following:

1 1 1     1 1 0     1 0 0
1         0         0
1 1 1     1 1 0     1 0 0


The sum of an hourglass is the sum of all the numbers within it. The sum for the hourglasses above are 7, 4, and 2, respectively.

In this problem, you have to print the largest sum among all the hourglasses in the array.

Note: If you have already solved the problem “Java 2D array” in the data structures chapter of the Java domain, you may skip this challenge.

Input Format

There will be exactly 6 lines of input, each containing 6 integers separated by spaces. Each integer will be between -9 and 9, inclusively.

Output Format

Print the answer to this problem on a single line.

Sample Input

1 1 1 0 0 0
0 1 0 0 0 0
1 1 1 0 0 0
0 0 2 4 4 0
0 0 0 2 0 0
0 0 1 2 4 0


Sample Output

19

Explanation

The hourglass possessing the largest sum is:

2 4 4
2
1 2 4

## Problem Statement:

Dexter and Debra are playing a game. They have N containers each having one or more chocolates. Containers are numbered from 1 to N, where ith container has A[i] number of chocolates.

The game goes like this. First player will choose a container and take one or more chocolates from it. Then, second player will choose a non-empty container and take one or more chocolates from it. And then they alternate turns. This process will continue, until one of the players is not able to take any chocolates (because no chocolates are left). One who is not able to take any chocolates loses the game. Note that player can choose only non-empty container.

The game between Dexter and Debra has just started, and Dexter has got the first Chance. He wants to know the number of ways to make a first move such that under optimal play, the first player always wins.

Input Format
The first line contains an integer N, i.e., number of containers.
The second line contains N integers, i.e., number of chocolates in each of the containers separated by a single space.

Output Format
Print the number of ways to make the first move such that under optimal play, the first player always wins. If the first player cannot win under optimal play, print 0.

Constraints
1 ≤ N ≤ 106
1 ≤ A[i] ≤ 109

Sample Input

2
2 3


Sample Output

1


Explanation

Only 1 set of moves helps player 1 win.

Player:      1      2      1      2      1
Chocolates: 2 3 -> 2 2 -> 1 2 -> 1 1 -> 0 1

Sample Data

Output:

321143

Theory Data for the solution and algorithm

## Problem Statement

There are N strings. Each string’s length is no more than 2020 characters. There are also Q queries. For each query, you are given a string, and you need to find out how many times this string occurred previously.

Input Format

The first line contains N, the number of strings.
The next N lines each contain a string.
The N+2nd line contains Q, the number of queries.
The following Q lines each contain a query string.

Constraints

1N1000
1Q1000
1lengtof anstring20

Sample Input

4
aba
baba
aba
xzxb
3
aba
xzxb
ab


Sample Output

2
1
0


Explanation

Here, “aba” occurs twice, in the first and third string. The string “xzxb” occurs once in the fourth string, and “ab” does not occur at all.

## Finding loop in a singly linked-list

You can detect it by simply running two pointers through the list.
Start the first pointer p1 on the first node and the second pointer p2 on the second node.

Advance the first pointer by one every time through the loop, advance the second pointer by two. If there is a loop, they will eventually point to the same node. If there’s no loop, you’ll eventually hit the end with the advance-by-two pointer.

Consider the following loop:

head -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8
^                        |
|                        |
+------------------------+

Starting A at 1 and B at 2, they take on the following values:

p1   p2
=    =
1    2
2    4
3    6
4    8
5    4
6    6


Because they’re equal, and P2 should always be beyond p1 in a non-looping list (because it’s advancing by two as opposed to the advance-by-one behavior of p1), it means you’ve discovered a loop.

The pseudo-code will go something like this:

• If hn==null; return false; //empty list
• if hn.next!=null
• p1=hn; p2=hn;
• While p2!=null loop
• if p2.next!=null
• else return false
• if p1==p2
• return true// Loop was found
• return false// till now no loop was found

Once you know a node within the loop, there’s an O(n) guaranteed method to find the start of the loop.

Let’s return to the original position after you’ve found an element somewhere in the loop but you’re not sure where the start of the loop is.

                                 p1,p2 (this is where p1 and p2
|               first met).
v
head -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8
^                        |
|                        |
+------------------------+


This is the process to follow:

• First, advance p2 and set the loopsize to 1.
• Second, while p1 and p2 are not equal, continue to advance p2, increasing the loopsize each time. That gives the size of the loop, six in this case.
If the loopsize ends up as 1, you know that you must already be at the start of the loop, so simply return A as the start, and skip the rest of the steps below.
• Third, simply set both p1 and p2 to the first element then advance p2 exactly loopsize times (to the 7 in this case). This gives two pointers that are different by the size of the loop.
• Lastly, while p1 and p2 are not equal, you advance them together. Since they remain exactly loopsize elements apart from each other at all times, p1 will enter the loop at exactly the same time as p2 returns to the start of the loop. You can see that with the following walk through:
• loopsize is evaluated as 6
• set both p1 and p2 to 1
• advance p2 by loopsize elements to 7
• 1 and 7 aren’t equal so advance both
• 2 and 8 aren’t equal so advance both
• 3 and 3 are equal so that is your loop start

Now, since each those operations are O(n) and performed sequentially, the whole thing is O(n).

Source

Algorithm Name: Floyd–Warshall algorithm

## Combinations of a String

Problem:
Write an algorithm to print all possible combinations of characters in a string.

Solution:
Since we need to generate combinations, we can start with a single character and then continue to add a character to combinations we have seen so far.

Let’s use “XYZ” as an example.

public void buildTree(String input, StringBuffer output, int k)
{
for (int i = k; i < input.length(); i++)
{
output.append(input.charAt(i));
buildTree(input, output, i + 1);
output.deleteCharAt(output.length() - 1);
}
}

public static void main(String[] args){
buildTree("XYZ", new StringBuffer(), 0);
}


Dry Run just to give an idea:

X–>Y–>Z
–>Z–>Y

Y–>X–>Z
–>Z–>X

Z–>Y–>X
–>X–>Y

## Gold for 7 Days of Work Puzzle

Problem Statement:

You’ve got someone working for you for seven days and a gold bar to pay them. You must pay the worker for their work at the end of every day. If you are only allowed to make two breaks in the gold bar, how do you pay your worker?
(Assuming equal amount of work is done during each day thus requiring equal amount of pay for each day)

The trick is not to try and how to cut in such a way to make 7 equal pieces but rather to make transactions with the worker. Make two cuts on the gold bar such that you have the following sizes of bars.

1/7, 2/7 and 4/7.

 Day Pay Take Back Total Paid Amount Balance Amount 1 1/7 N/A 1/7 2/7, 4/7 2 2/7 1/7 2/7 1/7, 4/7 3 1/7 N/A 3/7 4/7 4 4/7 1/7, 2/7 4/7 2/7, 1/7 5 1/7 N/A 5/7 2/7 6 2/7 1/7 6/7 1/7 7 1/7 N/A 7/7 N/A

## Problem Statement

You have 25 horses, and you want to pick the fastest 3 horses out of those 25. Each race can have maximum of 5 horses at the same time. What is the minimum number of races required to find the 3 fastest horses without using a stopwatch?

## Solution

Let’s say that we have 5 races of 5 horses each, so each row in the table above represents a race.

 H1 H2 H3 H4 H5 H6 H7 H8 H9 H10 H11 H12 H13 H14 H15 H16 H17 H18 H19 H20 H21 H22 H23 H24 H25

Let each row represent a race.

Step 1: Perform 5 races of each set.

Result:

 1st 2nd 3rd 4th 5th H1 H2 H3 H4 H5 H6 H7 H8 H9 H10 H11 H12 H13 H14 H15 H16 H17 H18 H19 H20 H21 H22 H23 H24 H25

Step 2: Elimination by logical analysis:

• We can eliminate the slowest 2 horses in each group since those horses are definitely not in the top 3
• The 5 group leaders are not necessarily the 5 fastest horses, therefore race those 5 horses against each other (H1, H6, H11, H16, and H21) {Race 6}, Let’s say that the 3 fastest in that group are H1, H6, and H11 – automatically we can eliminate H16 and H21 since those 2 are definitely not in the top 3
• We can automatically eliminate all the horses that H16 and H21 competed against in the preliminary races as they were slower than H16 and H21
• We also know that H1 is the fastest horse in the group since he was the fastest horse out of the 5 group leaders
• if H6 and H11 are the 2nd and 3rd fastest in the group leaders, then we should be able to eliminate H8 since H6 raced against him and he was in 3rd place in that race
• We can also eliminate H12 and H13 since H11 was the 3rd fastest in the group leaders, and H12 and H13 were slower than H11
• This leaves us with the following horses to determine the 2nd and 3rd fastest horses:
 H2 H3 H6 H7 H11

Race the last Set {Race 7} to get the Top 2nd and 3rd racers with H1 as the fastest.

Total number of Races: 7

## Problem Statement:

There is a building of 100 floors  If an egg drops from the Nth floor or above it will break. If it’s dropped from any floor below, it will not break. You’re given 2 eggs.

Give an Algorithm to find N, while minimizing the number of drops for the worst case.

## Solution:

The Problem comes with a general equation as X(Max Number of floors) = n*n;

So in this case for example, X= 100 Floors( => n=10)

now use the value n to traverse. This means that drop the first egg from 10th floor, then 20th floor, then 30th and so on up to 90.

The floor from which it breaks, say 60th, then go back 10 floors and try each floor to find N.

After Floor 90, Start moving 1 by 1.

Worst case scenario:

eggs break at 99th floor.

Egg drops: 10 -> 20 -> 30 -> 40 -> 50 -> 60 -> 70 -> 80 -> 90 -> 91 -> 92 -> 93 -> 94 -> 95 -> 96 -> 97 -> 98 -> 99

Max Attempts: 18

## The water jug problem

We have three water jugs, and each can hold 3oz., 5oz., and 8oz. of water, respectively.
Without the possibility of water spilling when poured from one jug to another, and given that the jugs have no calibration, how do we divide the 8oz. of water equally among two jugs?

We will define a class named State holding the capacity of A and B jars.
It should be noted that only 2 jars are sufficient to define a state, as water held in third jar can be calculated by subtracting the sum of two from the total.

Define class State like this…

package mystate;import bfs.threejugproblem.NotSupportedException;import java.util.ArrayList;import java.util.List;public class State{    int a=0;//3    int b=0;//5    int c=8;//8    public State(int a, int b)    {        this.a=a;        this.b=b;        this.c=8-a-b;    }    public boolean isGoal()    {        return (b==4 && c==4);    }    public boolean equals(Object xx)    {        State x = (State) xx;        if(this.a==x.a && this.b==x.b && this.c==x.c)        {            return true;        }        else        {            return false;        }    }    public int hashCode()    {        return 8;    }    public List getChildren()     {        List children = new ArrayList();        // a -> b        if(a!=0 && b!=5)// if a is not empty        {            if(a+b<=5)            {                children.add(new State(0, a+b));            }            else            {                children.add(new State(a+b-5,5));            }        }        //a->c        if(a!=0 && c!=8)        {            // We are pouring completely from a to c            // a will be 0            // b will be 8-a-c            // c will be a+c            children.add(new State(0, 8-a-c));        }        //b->a        if(b!=0 && a!=3)        {            if(a+b<=3)            {                children.add(new State(a+b, 0));            }            else            {                children.add(new State(3, a+b-3));            }        }        // b->c        if(b!=0 && c!=8)        {            // We are pouring completely from b to c            // a will be 8-b-c            // b will be 0            // c will be b+c            children.add(new State(8-b-c, 0));                    }        //c->a        if(c!=0 && a!=3)        {            if(c+a<=3)            {                children.add(new State(c+a, 8-c-a));            }            else            {                    // a will be full i.e. 3 liters                    // b will be 8-c-a                    // c will be c+a-3                    children.add(new State(3, 8-c-a));                            }        }        // c->b        if(c!=0 && b!=5)        {            if(c+b<=5)            {                children.add(new State(8-c-b , c+b));            }            else            {                children.add(new State(8-c-b, 5));            }        }        return children;    }    @Override    public String toString()    {        return "{"+a+","+b+","+c+"}";    }}

Depth First Search Algorithm

public class DFSThreeJugProblem {    public static void main(String[] args)    {        State currentState = new State(0,0);        List visitedStates=new ArrayList();          // Check if the current State has a solution        // given a set of visited States.        dfs(currentState, visitedStates);    }    public static void dfs(State currentState, List vStates)    {        // if it is GOAL        if(currentState.isGoal())        {            // That's it we are done.            for(State v : vStates)            {                System.out.println(v);                System.out.println(currentState);            }            System.exit(0);                    }                // if visisted state contains currentState, then just return.        // This is the wrong branch, and we need not traverse it further.        if(vStates.contains(currentState))            return;                // Add current state to visited states.        vStates.add(currentState);                        // Make clone of visited states.        List clonedVStates = new ArrayList(vStates);        // Find the set of possible children of current state.        List children = currentState.getChildren();        for(State c : children)        {            // if a children C is not in the visited states             // again call DFS on current child and visited States.            if(!clonedVStates.contains(c))            {                dfs(c, clonedVStates);            }        }    }}

public class BFSThreeJugProblem {    private static List visitedStates=new ArrayList();    private static Queue stateQueue = new LinkedList();    public static void main(String[] args) throws NotSupportedException     {        State currentState = new State(0,0);        // Add current state to state Queue.        stateQueue.add(currentState);        do        {            // Get the first Element from Queue.            State firstElementInQueue = stateQueue.peek();            // If the first Element is the Goal            // We are done.            if(firstElementInQueue.isGoal())            {                for(State p : visitedStates)                {                    System.out.println(p.toString());                }                // There is no recursion here, so simple return would do.                return;            }            else            {                // Add firstElement to visited States                visitedStates.add(firstElementInQueue);                    // Get the children of first element                List children = firstElementInQueue.getChildren();                for(State v : children)                {                    // if children has not already been visited.                    if(!visitedStates.contains(v))                    {                        // add the child to state Queue.                        stateQueue.add(v);                    }                }                // Remove the first element from state queue.                stateQueue.remove(firstElementInQueue);            }            // do this till state queue is empty.        }while(!stateQueue.isEmpty());    }}

## Comparable vs Comparator

There are many articles available on internet for this. But still I would write something about it.

### What when and why?

A Comparable class is a class, which can be compared with the objects of its own type. Let us take an example of a book.

public class Book implements Comparable {
String title;
int    isbn;

Book(String title, int isbn) {
this.title = title;
this.isbn  = isbn;
}
/* This method will be the default method used
to sort Book objects in a list or Array */
public int compareTo(Object object) {
// It should throw NullPointerException if object passed is null
if (object==null)
{
throw new NullPointerException("compareTo: Argument passed is null");
}
Book other = (Book) object;
if (this.title.equals(other.title)) {
return this.isbn - other.isbn;
}
return this.title.compareTo(other.title);
}
}

The moment your class implements Comparable, you can then use

List list = new LinkedList();

Collections.sort(list);

Using this you can sort your list.

But what if now, you want to add or use another sorting criteria defined in Book class… Here comes the need of Comparator.
There are two ways listed here to use the Comparator class.

First method

We create a anonymous class that implements Comparator and overrides compare method.

Collections.sort(list, new Comparator() {
public int compare(Object obj1, Object obj2) {
if(obj1 == null || obj2 == null){
throw new NullPointerException("compareTo: Argument passed is null");
}
Book book1 = (Book) obj1;
Book book2 = (Book) obj2;
return book1.isbn - book2.isbn;
}
});

#### Second Method

You define a class that implements Comparator like as below.

class BookComparator implements Comparator{

public int compare(Object book1, Object book2){

int b1= ((Book)book1).isbn;
int b2= ((Book)book2).isbn;

if(b1> b2)
return 1;
else if(b1< b2)
return -1;
else
return 0;
}

}

And use this newly defined comparator class as an argument to Collections.sort.

Arrays.sort(list, new BookComparator ());

### Good reasons to use Comparator interface

• I do not have permissions to edit the Book class.
• Book class already implements Comparable interface, but I want to sort the objects using a different criteria
• I want to have more than 1 criterias to sort the objects in different orders.

### Reasons to implement Comparable interface

• I want my class to have a default sorting criteria that can be used by the users of my class
• Usually, one would like to sort the objects based on primary key