[
{
"path": ".gitignore",
"content": "interview.iml\ninterview.ipr\ninterview.iws\nbuild/\n.gradle/\n.classpath\n.project\n.settings/\n/bin/\n/out\n.DS_Store\npython/graph/__pycache__/\npython/.idea\ntarget/\n"
},
{
"path": ".idea/misc.xml",
"content": "\n\n \n"
},
{
"path": ".idea/vcs.xml",
"content": "\n\n \n \n \n"
},
{
"path": "C++/Arrays/Trapping the rain water.cpp",
"content": "#include \nusing namespace std;\n\nint trapped_water(int array[],int size){\n int amount = 0;\n int left[size],right[size];\n left[0] = array[0]; right[size-1] = array[size-1];\n for(int i = 1; i < size; i++){\n left[i] = max(left[i-1],array[i]);\n }\n for(int i = size-2; i >=0; i--){\n right[i] = max(right[i+1],array[i]);\n }\n for(int i = 0 ; i < size;i++){\n amount += min(left[i],right[i]) - array[i];\n }\n return amount;\n}\n\nint main(){\n int array[] = {1,0,3,4,5,0,5,7,7,8,9,0};\n int size = sizeof(array) / sizeof(int);\n cout << trapped_water(array,size);\n return 0;\n}\n"
},
{
"path": "C++/Bit Manipulation/Checking Whether K-th Bit is Set or Not.cpp",
"content": "#include\nusing namespace std;\nint main(){\n int n,k;\n cout << \"Enter the number and the value of K : \";\n cin >> n >> k;\n int mask = 1 << (k-1);\n if(n & mask){\n cout << \"Yes K-th bit is set\" << endl;\n }\n else{\n cout << \"No K-th bit is not set\" << endl;\n }\n return 0;\n}\n"
},
{
"path": "C++/Bit Manipulation/Clearing the K-th bit of a number.cpp",
"content": "#include\nusing namespace std;\nint main(){\n int n,k,mask;\n cout << \"Enter the number and the value of K : \";\n cin >> n >> k;\n mask = ~(1 << (k-1));\n n = n&mask;\n cout << \"The number after clearing the K-th bit is : \" << n << endl;\n return 0;\n}\n"
},
{
"path": "C++/Bit Manipulation/Setting the K-th bit of a number.cpp",
"content": "#include\nusing namespace std;\nint main(){\n int n,k;\n cout << \"Enter the number and the value of K :\";\n cin >> n >> k;\n int mask = 1 << (k - 1);\n n = n | mask;\n cout << \"The number after setting the K-th bit is:\" << n;\n return 0;\n}\n"
},
{
"path": "C++/Bit Manipulation/Toggling Rightmost Set Bit of a number.cpp",
"content": "#include\nusing namespace std;\nint main(){\n int n;\n cout << \"Enter the number : \";\n cin >> n ;\n n = n & (n-1);\n cout << \"The number after toggling right most set bit : \" << n << endl;\n return 0;\n}\n"
},
{
"path": "C++/Bit Manipulation/Toggling the K-th bit of a number.cpp",
"content": "#include\nusing namespace std;\nint main(){\n int n,k,mask;\n cout << \"Enter the number and the value of K : \";\n cin >> n >> k;\n mask = 1 << (k-1);\n n = n ^ mask;\n cout << \"The number after toggling the K-th bit is : \" << n << endl;\n return 0;\n}\n"
},
{
"path": "C++/Dynamic Programming/Edit Distance.cpp",
"content": "int editDistance(string s1, string s2){\n int m = s1.length();\n int n = s2.length();\n int dp[m+1][n+1];\n for (int i = 0; i <= m; i++) {\n dp[i][0] = i;\n }\n for (int j = 0; j <= n; j++) {\n dp[0][j] = j;\n }\n\n for (int i = 1; i <= m; i++) {\n for (int j = 1; j <= n; j++) {\n if (s1[i-1] == s2[j-1]) dp[i][j] = dp[i-1][j-1];\n else dp[i][j] = 1 + min(min(dp[i][j-1],dp[i-1][j]),dp[i-1][j-1]);\n }\n }\n return dp[m][n];\n}\n"
},
{
"path": "C++/Dynamic Programming/Longest Common Subsequence.cpp",
"content": "int lcs(string x,string y){\n int m = x.size(),n = y.size();\n int dp[m+1][n+1];\n for(int i=0;i<=m;i++){\n dp[i][0] = 0;\n }\n for(int j=0;j<=m;j++){\n dp[0][j] = 0;\n }\n for(int i=1;i<=m;i++){\n for(int j=1;j<=n;j++){\n if(x[i-1] == y[j-1]){\n dp[i][j] = dp[i-1][j-1]+1;\n }\n else{\n dp[i][j] = max(dp[i][j-1],dp[i-1][j]);\n }\n }\n }\n return dp[m][n];\n}\n"
},
{
"path": "C++/Dynamic Programming/Longest Common Substring.cpp",
"content": "#include \nusing namespace std;\n\nint longest_common_substring(string x,string y){\n int m = x.size();\n int n = y.size();\n int lcs[m+1][n+1];\n for(int i = 0 ; i < m; i++){\n lcs[i][0] = 0;\n }\n for(int j = 0; j < n; j++){\n lcs[0][j] = 0;\n }\n for(int i = 1; i <= m; i++){\n for(int j = 1; j <=n; j++){\n if(x[i-1] == y[j-1]){\n lcs[i][j] = 1 + lcs[i-1][j-1];\n }\n else{\n lcs[i][j] = 0;\n }\n }\n }\n return lcs[m][n];\n}\nint main(){\n string x,y;\n cin >> x >> y;\n cout << longest_common_substring(x,y);\n return 0;\n}"
},
{
"path": "C++/Dynamic Programming/Longest Increasing Subsequence.cpp",
"content": "int lis(int array[],int n){\n int dp[n],lis_value = -1;\n for(int i=0;i array[j] and dp[i] < dp[j]+1){\n dp[i] = dp[j] + 1;\n }\n }\n }\n for(int i=0;i\nusing namespace std;\nint longest_palindromic_subsequence(string str){\n int table[str.size()][str.size()];\n for(int i = 0 ; i < str.size(); i++){\n table[i][i] = 1;\n }\n for(int l = 1 ; l < str.size() ; l++){\n int i = 0, j = l;\n while(j != str.size()){\n if(str[i] == str[j]){\n table[i][j] = 2 + table[i+1][j-1];\n }\n else{\n table[i][j] = max(table[i+1][j],table[i][j-1]);\n }\n i++;j++;\n }\n }\n return table[0][str.size()-1];\n}\nint main(){\n string str;\n cin >> str;\n cout << longest_palindromic_subsequence(str);\n return 0;\n}"
},
{
"path": "C++/Dynamic Programming/Matrix Chain Multiplication.cpp",
"content": "int mcm(int p[], int n){\n int m[n][n];\n int i, j, k, L, q;\n for (i = 1; i < n; i++)\n m[i][i] = 0;\n for (L=2; L\n#include\nusing namespace std;\n\nvoid floydWarshall(vector> &graph){\n for (int k=0; k> graph;\n int v,e,src,des,weight;\n cin >> v >> e;\n graph.resize(v,vector(v,0));\n while(e--){\n cin >> src >> des >> weight;\n graph[src][des] = weight;\n }\n floydWarshall(graph);\n for(int i=0;i\n#include\n#include\n#include\nusing namespace std;\nvoid breadth_first_search(vector> graph,int src){\n vectorvisited(graph.size(),false);\n queueQ;\n Q.push(src);\n visited[src] = true;\n while(!Q.empty()){\n int vertex = Q.front(); Q.pop();\n cout << vertex << \" \";\n for(list::iterator itr = graph[vertex].begin();itr!=graph[vertex].end();itr++){\n if(!visited[*itr])\n Q.push(*itr);\n visited[*itr] = true;\n }\n }\n}\nint main(){\n vector> graph;\n int v,e,src,des;\n cin >> v >> e;\n graph.resize(v);\n while(e--){\n cin >> src >> des;\n graph[src].push_back(des);\n graph[des].push_back(src);\n }\n cin >> src;\n breadth_first_search(graph,src);\n return 0;\n}\n"
},
{
"path": "C++/Graph Algorithms/Connected Components Algorithm DFS.cpp",
"content": "#include\n#include\n#include\nusing namespace std;\n\nvoid connectedComponentsDFS(vector> graph,int src,vector &visited){\n if(!visited[src]){\n visited[src] = true;\n for(list::iterator itr = graph[src].begin();itr != graph[src].end();itr++){\n connectedComponentsDFS(graph,*itr,visited);\n }\n }\n}\n\nint connectedComponents(vector> graph){\n int components = 0;\n vector visited(graph.size(),false);\n for(int src = 0; src < graph.size();src++){\n if(!visited[src]){\n components++;\n connectedComponentsDFS(graph,src,visited);\n }\n }\n return components;\n}\n\nint main(){\n vector> graph;\n int v,e,src,des;\n cin >> v >> e;\n graph.resize(v);\n while(e--){\n cin >> src >> des;\n graph[src].push_back(des);\n }\n cout << connectedComponents(graph);\n return 0;\n}\n\n"
},
{
"path": "C++/Graph Algorithms/Depth First Search.cpp",
"content": "#include\n#include\n#include\n#include\nusing namespace std;\nvoid depth_first_search(vector> graph,int src){\n vectorvisited(graph.size(),false);\n stackS;\n S.push(src);\n visited[src] = true;\n while(!S.empty()){\n int vertex = S.top(); S.pop();\n cout << vertex << \" \";\n for(list::iterator itr = graph[vertex].begin();itr!=graph[vertex].end();itr++){\n if(!visited[*itr])\n S.push(*itr);\n visited[*itr] = true;\n }\n }\n}\nint main(){\n vector> graph;\n int v,e,src,des;\n cin >> v >> e;\n graph.resize(v);\n while(e--){\n cin >> src >> des;\n graph[src].push_back(des);\n graph[des].push_back(src);\n }\n cin >> src;\n depth_first_search(graph,src);\n return 0;\n}\n"
},
{
"path": "C++/Graph Algorithms/Kruskal's Minimum Spanning Tree Algorithm.cpp",
"content": "#include\n#include\n#include\nusing namespace std;\n\nstruct edge{int src,des,weight;};\n\nclass UnionFind {\n int *parent, *ranks, _size;\npublic:\n UnionFind(){\n }\n UnionFind(int size){\n parent = new int[size]; ranks = new int[size];\n for(int element = 0 ; element < size ; element++){\n parent[element] = element , ranks[element] = 0 ;\n }\n _size = size;\n }\n void resize(int size){\n parent = new int[size]; ranks = new int[size];\n for(int element = 0 ; element < size ; element++){\n parent[element] = element , ranks[element] = 0 ;\n }\n _size = size;\n }\n int find(int element){\n if(parent[element] == element){\n return element;\n }\n else{\n return parent[element] = find(parent[element]); // Path Compression algorithm\n }\n }\n bool connected(int x,int y){\n if(find(x) == find(y)){\n return true;\n }\n else{\n return false;\n }\n }\n void merge(int x,int y){\n x = find(x);\n y = find(y);\n if(x != y){ // Union by Rank algorithm\n if(ranks[x] > ranks[y]){\n parent[y] = x;\n }\n else if(ranks[x] < ranks[y]){\n parent[x] = y;\n }\n else{\n parent[x] = y; ranks[y] ++ ;\n }\n _size--;\n }\n }\n void clear(){\n delete [] parent; delete [] ranks;\n }\n int size(){\n return _size;\n }\n};\nbool comparator(const edge &a,const edge &b){\n return a.weight < b.weight;\n}\n\nvector kruskalsAlgorithm(vectorgraph,int vertices){\n UnionFind uf(vertices);\n vectorspanningTree;\n sort(graph.begin(),graph.end(),comparator);\n spanningTree.push_back(graph[0]);\n uf.merge(graph[0].src,graph[0].des);\n for(int i=1;igraph;\n int e,v;\n cin >> e >> v;\n graph.resize(e);\n for(int i=0;i> graph[i].src >> graph[i].des >> graph[i].weight;\n }\n vector spanningTree = kruskalsAlgorithm(graph,v);\n for(edge x : spanningTree){\n cout << x.src << \" \" << x.des << \" \" << x.weight << endl;\n }\n return 0;\n}\n"
},
{
"path": "C++/Graph Algorithms/Prims Minimum Spanning Tree Algorithm.cpp",
"content": "#include\n#include\n#include\n#include\n#include\nusing namespace std;\n\nconst int INF = INT_MAX;\n\nclass edge{ public: int src,des,weight; edge(){}edge(int s,int d,int w): src(s),des(d),weight(w){}};\nclass compare { public: bool operator()(const edge &a,const edge &b){ return a.weight < b.weight; }};\n\nvector primsAlgorithm(vector>> graph,edge minEdge){\n vectorspanningTree;\n priority_queue,compare> Q;\n while(spanningTree.size() == graph.size()-1){\n spanningTree.push_back(minEdge);\n for(list>::iterator it = graph[minEdge.src].begin();it!=graph[minEdge.src].end();it++){\n Q.push(edge(minEdge.src,it->first,it->second));\n }\n for(list>::iterator it = graph[minEdge.des].begin();it!=graph[minEdge.des].end();it++){\n Q.push(edge(minEdge.des,it->first,it->second));\n }\n minEdge = Q.top(); Q.pop();\n }\n return spanningTree;\n}\n\nint main(){\n vector>>graph;\n int v,e,src,des,weight;\n cin >> v >> e;\n graph.resize(v);\n edge minEdge;\n minEdge.weight = INF;\n while(e--){\n cin >> src >> des >> weight;\n graph[src].push_back(make_pair(des,weight));\n graph[des].push_back(make_pair(src,weight));\n if(weight < minEdge.weight){\n minEdge.src = src, minEdge.des = des, minEdge.weight = weight;\n }\n }\n vector spanningTree = primsAlgorithm(graph,minEdge);\n for(edge x : spanningTree){\n cout << x.src << \" \" << x.des << \" \" << x.weight << endl;\n }\n return 0;\n}\n"
},
{
"path": "C++/Graph Algorithms/Recursive Depth First Search.cpp",
"content": "#include\n#include\n#include\nusing namespace std;\nvoid depth_first_search(vector> graph,int src,vector &visited){\n if(!visited[src]){\n cout << src << \" \";\n visited[src] = true;\n for(list::iterator itr = graph[src].begin();itr != graph[src].end();itr++){\n depth_first_search(graph,*itr,visited);\n }\n }\n}\nint main(){\n vector> graph;\n vector visited;\n int v,e,src,des;\n cin >> v >> e;\n graph.resize(v);\n visited.resize(v,false);\n while(e--){\n cin >> src >> des;\n graph[src].push_back(des);\n }\n cin >> src;\n depth_first_search(graph,src,visited);\n return 0;\n}\n"
},
{
"path": "C++/Graph Algorithms/Single Shortest Path Bellman Ford Algorithm.cpp",
"content": "#include\n#include\n#include\nusing namespace std;\n\nstruct edge {int src, des, weight;};\n\npair> bellmanFord(vector graph,int vertex,int source){\n vector distances(vertex,INT_MAX);\n distances[source] = 0;\n for(int i=0;i distances[graph[j].src] + graph[j].weight){\n distances[graph[j].des] = distances[graph[j].src] + graph[j].weight;\n }\n }\n }\n for(int j=0;j distances[graph[j].src] + graph[j].weight){\n return make_pair(false,vector());\n }\n }\n return make_pair(true,distances);\n}\n\nint main(){\n int edges,source,vertex;\n vector graph;\n cin >> edges >> vertex;\n for(int i = 0; i < edges; i++){\n cin >> graph[i].src >> graph[i].des >> graph[i].weight;\n }\n cin >> source;\n pair> result = bellmanFord(graph,vertex,source);\n if(result.first == true){\n cout << \"No Cycle Exist ! \" << endl;\n for(vector::iterator itr = (result.second).begin();itr!=(result.second).end();itr++){\n cout << *itr << \" \";\n }\n }\n else{\n cout << \"Graph Has Negative Weight Cycle\" << endl;\n }\n return 0;\n}\n"
},
{
"path": "C++/Graph Algorithms/Single Source Shortest Path Dijkstra Algorithm.cpp",
"content": "#include\n#include\n#include\n#include\n#include\nusing namespace std;\nstruct compare{\n bool operator()(const pair &a,const pair &b){\n return a.second > b.second;\n }\n};\nvector dijkshtra(vector>> graph,int src){\n priority_queue,vector>,compare> Q;\n vector distances(graph.size(),INT_MAX);\n vector visited(graph.size(),false);\n distances[src] = 0;\n Q.push(make_pair(src,0));\n while(!Q.empty()){\n pair current = Q.top(); Q.pop();\n cout << \"Currently at\" << current.first << endl;\n if(!visited[current.first]){\n visited[current.first] = true;\n for(list> :: iterator vertex = graph[current.first].begin();vertex != graph[current.first].end();vertex++){\n if(current.second + vertex->second < distances[vertex->first]){\n distances[vertex->first] = current.second + vertex->second;\n Q.push(make_pair(vertex->first,distances[vertex->first]));\n }\n }\n }\n }\n return distances;\n}\nint main(){\n vector>> graph;\n int v,e,src,des,weight;\n cin >> v >> e;\n graph.resize(v);\n while(e--){\n cin >> src >> des >> weight;\n graph[src].push_back(make_pair(des,weight));\n }\n cin >> src;\n vector distances = dijkshtra(graph,src);\n for(vector :: iterator itr = distances.begin();itr != distances.end();itr++){\n cout << *itr << \" \";\n }\n return 0;\n}\n"
},
{
"path": "C++/Graph Algorithms/Topological Sorting.cpp",
"content": "#include\n#include\n#include\nusing namespace std;\n\nvoid topologicalSortDFS(vector> graph,int src,vector &visited,list &topologicalSortedList){\n if(!visited[src]){\n visited[src] = true;\n for(list::iterator itr = graph[src].begin();itr != graph[src].end();itr++){\n topologicalSortDFS(graph,*itr,visited,topologicalSortedList);\n }\n topologicalSortedList.push_front(src);\n }\n}\n\nlist topologicalSort(vector> graph){\n list topologicalSortedList;\n vector visited(graph.size(),false);\n for(int src = 0; src < graph.size();src++){\n topologicalSortDFS(graph,src,visited,topologicalSortedList);\n }\n return topologicalSortedList;\n}\n\nint main(){\n vector> graph;\n int v,e,src,des;\n cin >> v >> e;\n graph.resize(v);\n while(e--){\n cin >> src >> des;\n graph[src].push_back(des);\n }\n list topologicalSortedList = topologicalSort(graph);\n for(list::iterator itr = topologicalSortedList.begin();itr!=topologicalSortedList.end();itr++){\n cout << *itr << \" \";\n }\n return 0;\n}\n"
},
{
"path": "C++/Heaps - Priority Queues/K-th Largest element of the stream.cpp",
"content": "#include \n#include \nusing namespace std;\n\nint main(){\n int n,k;\n priority_queue,greater>Q;\n cout << \"Enter the the value of K : \";\n cin >> k;\n while(cin >> n){\n cout << k << \"-th largest element of the stream : \";\n if(Q.size() < k){\n Q.push(n);\n if(Q.size() == k){\n cout << Q.top() 3<< endl;\n }\n else{\n cout << \"NULL\" << endl;\n }\n }\n else{\n if(Q.top() < n){\n Q.pop();\n Q.push(n);\n }\n cout << Q.top() << endl;\n }\n cout << \"Enter next element of the stream : \";\n }\n return 0;\n}\n"
},
{
"path": "C++/Linked List/Reverse a linked list recursively.cpp",
"content": "void reverse_list(list_node *head){\n list_node *\n}\n"
},
{
"path": "C++/Number Theory Algorithms/Divisors.cpp",
"content": "#include\n#include\nusing namespace std;\nset generateDivisors(long long int num){\n set divisors;\n for(int i = 1 ; i*i <= num; i++ ){\n if(num % i == 0){\n divisors.insert(i);\n if( i != num/i ){\n divisors.insert(num/i);\n }\n }\n }\n return divisors;\n}\nint main(){\n set d = generateDivisors(23);\n for(int x : d){\n cout << x << \" \";\n }\n return 0;\n}\n"
},
{
"path": "C++/Number Theory Algorithms/Sieve of Eratosthenes.cpp",
"content": "#include\n#include\n#include\nusing namespace std;\n\nconst int MAX = 1000*1000;\nconst int LMT = 1000;\n\nvector prime(MAX+1,true);\n\nint seiveEratosthenes(){\n prime[0] = prime[1] = false;\n for(int i = 2; i <= LMT; i++){\n if(prime[i]){\n for(int j = i + i; j <= MAX ; j += i){\n prime[j] = false;\n }\n }\n }\n return count_if(prime.begin(),prime.end(),[](bool p){ return p == true;});\n}\nint main(){\n cout << seiveEratosthenes();\n return 0;\n}\n"
},
{
"path": "C++/Recursion/Partition of array on the pivot.cpp",
"content": "#include\nusing namespace std;\nvoid partition(int array[],int low,int high){\n int i = low-1, pivot = array[high-1];\n for(int j = low ; j < high ; j++){\n if(array[j] <= pivot){\n i++;\n swap(array[i],array[j]);\n }\n }\n swap(array[i+1],array[high-1]);\n}\nint main(){\n int n;\n cin >> n;\n int array[n];\n partition(array,0,n);\n return 0;\n}\n"
},
{
"path": "C++/Recursion/Permutation of a string.cpp",
"content": "#include \nusing namespace std;\n\nvoid permutation(char str[],int k,int n){\n if(k == n){\n for(int j = 0; j < n; j++){\n cout << str[j];\n }\n cout << endl;\n }\n else{\n for(int i = k ; i < n; i++){\n swap(str[i],str[k]);\n permutation(str,k+1,n);\n swap(str[i],str[k]);\n }\n }\n}\nint main(){\n char str[] = {'A','B','C','D'};\n permutation(str,0,4);\n return 0;\n}\n"
},
{
"path": "C++/Segment Tree/Segment Tree.cpp",
"content": "void buildTree (int tree[],int array[], int index, int low, int high) {\n\tif (low == high)\n\t\ttree[index] = array[low];\n\telse {\n\t\tint mid = (low + high) >> 1;\n\t\tbuildTree (tree,array, index*2, low, mid);\n\t\tbuildTree (tree,array, index*2+1, mid+1, high);\n\t\ttree[index] = tree[index*2] + tree[index*2+1];\n\t}\n}\nint rangeQuery (int tree[],int index, int low, int high, int l, int r) {\n\tif (l > r)\n\t\treturn 0;\n\tif (l == low && r == high)\n\t\treturn tree[index];\n\tint mid = (low + high) >> 1;\n\treturn rangeQuery (tree,index*2, low, mid, l, min(r,mid))\n\t\t+ rangeQuery (tree,index*2+1, mid+1, high, max(l,mid+1), r);\n}\nvoid updateQuery (int tree[],int index, int low, int high, int pos, int delta) {\n\tif (low == high)\n\t\ttree[index] = delta;\n\telse {\n\t\tint mid = (low + high) >> 1;\n\t\tif (pos <= mid)\n\t\t\tupdateQuery (tree,index*2, low, mid, pos, delta);\n\t\telse\n\t\t\tupdateQuery (tree,index*2+1, mid+1, high, pos, delta);\n\t\ttree[index] = tree[index*2] + tree[index*2+1];\n\t}\n}\n"
},
{
"path": "C++/Stacks - Queue/CircularQueue.cpp",
"content": "#include \nusing namespace std;\nclass circular_queue\n{\n\tprivate :\n\t\tint *array ;\n\t\tint front, back ;\n\t\tint MAX;\n\tpublic :\n\t\tcircular_queue( int maxsize = 10 ) ;\n\t\tvoid enqueue ( int item ) ;\n\t\tint dequeue( ) ;\n\t\tvoid display( ) ;\n} ;\ncircular_queue :: circular_queue( int maxsize )\n{\n\tMAX = maxsize ;\n\tarray = new int [ MAX ];\n\tfront = back = -1 ;\n\tfor ( int i = 0 ; i < MAX ; i++ )\n\t\tarray[i] = 0 ;\n}\nvoid circular_queue :: enqueue(int item){\n\tif((back+1)%MAX == front){\n\t\tcout << \"Queue is full\" << endl;\n\t\treturn ;\n\t}\n\tback = ( back + 1 ) % MAX;\n\tarray[back] = item ;\n\tif ( front == -1 )\n\t\tfront = 0 ;\n}\nint circular_queue :: dequeue(){\n\tint data ;\n\tif ( front == -1 )\n\t{\n\t\tcout << \"\\nQueue is empty\" ;\n\t\treturn NULL ;\n\t}\n\n\tdata = array[front] ;\n\tarray[front] = 0 ;\n\tif ( front == back )\n\t{\n\t\tfront = -1 ;\n\t\tback = -1 ;\n\t}\n\telse\n\t\tfront = ( front + 1 ) % MAX;\n\treturn data ;\n}\nvoid circular_queue :: display()\n{\n\tcout << endl ;\n\tfor ( int i = 0 ; i < MAX ; i++ )\n\t\tcout << array[i] << \" \" ;\n\tcout << endl ;\n}\nint main(){\n\tcircular_queue cq(10) ;\n\tcq.enqueue(14);\n\tcq.enqueue(22);\n\tcq.enqueue(13);\n\tcq.enqueue(-6);\n\tcq.enqueue(25);\n\tcout << \"\\nElements in the circular queue: \" ;\n\tcq.display();\n\tint i = cq.dequeue() ;\n\tcout << \"Item deleted: \" << i ;\n\ti = cq.dequeue();\n\tcout << \"\\nItem deleted: \" << i ;\n\tcout << \"\\nElements in the circular queue after deletion: \" ;\n\tcq.display();\n\tcq.enqueue(21);\n\tcq.enqueue(17);\n\tcq.enqueue(18);\n\tcq.enqueue(9);\n\tcq.enqueue(20);\n\tcout << \"Elements in the circular queue after addition: \" ;\n\tcq.display();\n\tcq.enqueue(32);\n\tcout << \"Elements in the circular queue after addition: \" ;\n\tcq.display();\n\treturn 0;\n}\n\n"
},
{
"path": "C++/String Algorithms/KMP.cpp",
"content": "vector computePrefix(string pat){\n int m = pat.size();\n vector longestPrefix(m);\n for(int i = 1, k = 0; i < m; i++){\n while(k > 0 && pat[k] != pat[i]){\n k = longestPrefix[k - 1];\n }\n if(pat[i] == pat[k]){\n longestPrefix[i] = ++k;\n }\n else{\n longestPrefix[i] = k;\n }\n }\n return longestPrefix;\n}\nvoid KMP(string str,string pat){\n int n = str.size();\n int m = pat.size();\n vector longestPrefix = computePrefix(pat);\n for(int i = 0, k = 0; i < n; i++){\n while(k > 0 && pat[k] != str[i]){\n k = longestPrefix[k - 1];\n }\n if(str[i] == pat[k]){\n k++;\n }\n if(k == m){\n cout << i - m + 1 << \"\\n\";\n k = longestPrefix[k - 1];\n }\n }\n}\n"
},
{
"path": "C++/String Algorithms/Trie.cpp",
"content": "struct Trie {\n\tTrie* child[26];\n\tbool isLeaf;\n\n\tTrie() {\n\t\tmemset(child, 0, sizeof(child));\n\t\tisLeaf = 0;\n\t}\n\n\tvoid pushWord(char *str) {\n\t\tif(*str == '\\0')\n\t\t\tisLeaf = 1;\n\t\telse {\n\t\t\tint cur = *str - 'a';\n\t\t\tif(child[cur] == 0 )\n\t\t\t\tchild[cur] = new Trie();\n\t\t\tchild[cur]->pushWord(str+1);\n\t\t}\n\t}\n\n\tbool wordExist(char* str) {\n\t\tif(*str == '\\0')\n\t\t\treturn isLeaf;\n\n\t\tint cur = *str - 'a';\n\t\tif(child[cur] == 0 )\n\t\t\treturn false;\n\n\t\treturn child[cur]->wordExist(str+1);\n\t}\n\n\tbool prefixExist(char* str) {\n\t\tif(*str == '\\0')\n\t\t\treturn true;\n\n\t\tint cur = *str - 'a';\n\t\tif(child[cur] == 0 )\n\t\t\treturn false;\n\n\t\treturn child[cur]->prefixExist(str+1);\n\t}\n};\n"
},
{
"path": "C++/Union Find/Union Find.cpp",
"content": "#include\nusing namespace std;\n\nclass UnionFind {\n int *parent, *ranks, _size;\npublic:\n UnionFind(){\n }\n UnionFind(int size){\n parent = new int[size]; ranks = new int[size];\n for(int element = 0 ; element < size ; element++){\n parent[element] = element , ranks[element] = 0 ;\n }\n _size = size;\n }\n void resize(int size){\n parent = new int[size]; ranks = new int[size];\n for(int element = 0 ; element < size ; element++){\n parent[element] = element , ranks[element] = 0 ;\n }\n _size = size;\n }\n int find(int element){\n if(parent[element] == element){\n return element;\n }\n else{\n return parent[element] = find(parent[element]); // Path Compression algorithm\n }\n }\n bool connected(int x,int y){\n if(find(x) == find(y)){\n return true;\n }\n else{\n return false;\n }\n }\n void merge(int x,int y){\n x = find(x);\n y = find(y);\n if(x != y){ // Union by Rank algorithm\n if(ranks[x] > ranks[y]){\n parent[y] = x;\n }\n else if(ranks[x] < ranks[y]){\n parent[x] = y;\n }\n else{\n parent[x] = y; ranks[y] ++ ;\n }\n _size--;\n }\n }\n void clear(){\n delete [] parent; delete [] ranks;\n }\n int size(){\n return _size;\n }\n};\n\n\nint main(){\n UnionFind uf(5);\n cout << uf.size() << endl; // 5 disjoint sets are there\n uf.merge(0,1);\n cout << uf.size() << endl; // 4 disjoint sets are there\n uf.merge(0,2);\n cout << uf.size() << endl; // 3 disjoint sets are there\n uf.merge(1,2);\n cout << uf.size() << endl; // 3 disjoint sets are there\n uf.clear();\n return 0;\n}\n"
},
{
"path": "LICENSE",
"content": "Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"{}\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright {yyyy} {name of copyright owner}\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License."
},
{
"path": "README.md",
"content": "\nPlease visit my wiki link for full list of questions
\nhttps://github.com/mission-peace/interview/wiki
\n\n Like my facebook page for latest updates on my youtube channel
\nhttps://www.facebook.com/tusharroy25
\n\n Contribution
\nPlease contribute to this repository to help it make better. Any change like new question, code improvement, doc improvement etc. is very welcome. Just send me a pull request and I will review the request and approve it if it looks good. \n\n How to use this repository
\n\n Softwares to install
\n* Install JDK8 https://docs.oracle.com/javase/8/docs/technotes/guides/install/install_overview.html\n* Install Git https://git-scm.com/book/en/v2/Getting-Started-Installing-Git\n* Install either Intellij https://www.jetbrains.com/idea/download/\n* If you like eclipse instead of intellij install eclipse https://eclipse.org/downloads/\n\n Set up your desktop
\n* Pull the git repository. Go to command line and type git clone https://github.com/mission-peace/interview.git\n* Go to root directory of checked out project.\n* Run ./gradlew idea to generate idea related classes\n* Fire up intellij. Go to Open. Go to git repo folder and open interview.ipr . On file menu go to project structure. Update language level support to 8\n* If you use eclipse, do ./gradlew eclipse . This will generate eclipse related files. Go to eclipse and open up folder containing this repo.\n* Go to any program and run that program\n* Go to any test and run the junit test.\n* Run ./gradlew build to create classes, run tests and create jar.\n"
},
{
"path": "build.gradle",
"content": "apply plugin: 'java'\napply plugin: 'idea'\napply plugin: 'eclipse'\napply plugin: \"jacoco\"\n\nsourceCompatibility = '1.8'\ntargetCompatibility = '1.8'\n\nrepositories {\n mavenCentral()\n}\n\ndependencies {\n testCompile 'junit:junit:4.12'\n}\n\nsourceSets {\n main {\n java {\n srcDir 'src'\n }\n }\n\n test {\n java {\n srcDir 'test'\n }\n }\n}\n\njacocoTestReport {\n reports {\n xml.enabled false\n csv.enabled false\n html.destination \"${buildDir}/jacocoHtml\"\n }\n}"
},
{
"path": "gradle/wrapper/gradle-wrapper.properties",
"content": "#Sat Apr 02 16:59:09 PDT 2016\ndistributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\nzipStoreBase=GRADLE_USER_HOME\nzipStorePath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-2.11-bin.zip\n"
},
{
"path": "gradlew",
"content": "#!/usr/bin/env bash\n\n##############################################################################\n##\n## Gradle start up script for UN*X\n##\n##############################################################################\n\n# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nDEFAULT_JVM_OPTS=\"\"\n\nAPP_NAME=\"Gradle\"\nAPP_BASE_NAME=`basename \"$0\"`\n\n# Use the maximum available, or set MAX_FD != -1 to use that value.\nMAX_FD=\"maximum\"\n\nwarn ( ) {\n echo \"$*\"\n}\n\ndie ( ) {\n echo\n echo \"$*\"\n echo\n exit 1\n}\n\n# OS specific support (must be 'true' or 'false').\ncygwin=false\nmsys=false\ndarwin=false\ncase \"`uname`\" in\n CYGWIN* )\n cygwin=true\n ;;\n Darwin* )\n darwin=true\n ;;\n MINGW* )\n msys=true\n ;;\nesac\n\n# Attempt to set APP_HOME\n# Resolve links: $0 may be a link\nPRG=\"$0\"\n# Need this for relative symlinks.\nwhile [ -h \"$PRG\" ] ; do\n ls=`ls -ld \"$PRG\"`\n link=`expr \"$ls\" : '.*-> \\(.*\\)$'`\n if expr \"$link\" : '/.*' > /dev/null; then\n PRG=\"$link\"\n else\n PRG=`dirname \"$PRG\"`\"/$link\"\n fi\ndone\nSAVED=\"`pwd`\"\ncd \"`dirname \\\"$PRG\\\"`/\" >/dev/null\nAPP_HOME=\"`pwd -P`\"\ncd \"$SAVED\" >/dev/null\n\nCLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar\n\n# Determine the Java command to use to start the JVM.\nif [ -n \"$JAVA_HOME\" ] ; then\n if [ -x \"$JAVA_HOME/jre/sh/java\" ] ; then\n # IBM's JDK on AIX uses strange locations for the executables\n JAVACMD=\"$JAVA_HOME/jre/sh/java\"\n else\n JAVACMD=\"$JAVA_HOME/bin/java\"\n fi\n if [ ! -x \"$JAVACMD\" ] ; then\n die \"ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\n fi\nelse\n JAVACMD=\"java\"\n which java >/dev/null 2>&1 || die \"ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\nfi\n\n# Increase the maximum file descriptors if we can.\nif [ \"$cygwin\" = \"false\" -a \"$darwin\" = \"false\" ] ; then\n MAX_FD_LIMIT=`ulimit -H -n`\n if [ $? -eq 0 ] ; then\n if [ \"$MAX_FD\" = \"maximum\" -o \"$MAX_FD\" = \"max\" ] ; then\n MAX_FD=\"$MAX_FD_LIMIT\"\n fi\n ulimit -n $MAX_FD\n if [ $? -ne 0 ] ; then\n warn \"Could not set maximum file descriptor limit: $MAX_FD\"\n fi\n else\n warn \"Could not query maximum file descriptor limit: $MAX_FD_LIMIT\"\n fi\nfi\n\n# For Darwin, add options to specify how the application appears in the dock\nif $darwin; then\n GRADLE_OPTS=\"$GRADLE_OPTS \\\"-Xdock:name=$APP_NAME\\\" \\\"-Xdock:icon=$APP_HOME/media/gradle.icns\\\"\"\nfi\n\n# For Cygwin, switch paths to Windows format before running java\nif $cygwin ; then\n APP_HOME=`cygpath --path --mixed \"$APP_HOME\"`\n CLASSPATH=`cygpath --path --mixed \"$CLASSPATH\"`\n JAVACMD=`cygpath --unix \"$JAVACMD\"`\n\n # We build the pattern for arguments to be converted via cygpath\n ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`\n SEP=\"\"\n for dir in $ROOTDIRSRAW ; do\n ROOTDIRS=\"$ROOTDIRS$SEP$dir\"\n SEP=\"|\"\n done\n OURCYGPATTERN=\"(^($ROOTDIRS))\"\n # Add a user-defined pattern to the cygpath arguments\n if [ \"$GRADLE_CYGPATTERN\" != \"\" ] ; then\n OURCYGPATTERN=\"$OURCYGPATTERN|($GRADLE_CYGPATTERN)\"\n fi\n # Now convert the arguments - kludge to limit ourselves to /bin/sh\n i=0\n for arg in \"$@\" ; do\n CHECK=`echo \"$arg\"|egrep -c \"$OURCYGPATTERN\" -`\n CHECK2=`echo \"$arg\"|egrep -c \"^-\"` ### Determine if an option\n\n if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition\n eval `echo args$i`=`cygpath --path --ignore --mixed \"$arg\"`\n else\n eval `echo args$i`=\"\\\"$arg\\\"\"\n fi\n i=$((i+1))\n done\n case $i in\n (0) set -- ;;\n (1) set -- \"$args0\" ;;\n (2) set -- \"$args0\" \"$args1\" ;;\n (3) set -- \"$args0\" \"$args1\" \"$args2\" ;;\n (4) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" ;;\n (5) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" ;;\n (6) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" ;;\n (7) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" ;;\n (8) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" ;;\n (9) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" \"$args8\" ;;\n esac\nfi\n\n# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules\nfunction splitJvmOpts() {\n JVM_OPTS=(\"$@\")\n}\neval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS\nJVM_OPTS[${#JVM_OPTS[*]}]=\"-Dorg.gradle.appname=$APP_BASE_NAME\"\n\nexec \"$JAVACMD\" \"${JVM_OPTS[@]}\" -classpath \"$CLASSPATH\" org.gradle.wrapper.GradleWrapperMain \"$@\"\n"
},
{
"path": "python/array/arrayaddition.py",
"content": "def add(arr1, arr2):\n\n l = max(len(arr1), len(arr2))\n result = [0 for j in range(l)]\n c = 0\n i = len(arr1) - 1\n j = len(arr2) - 1\n r = 0\n l -= 1\n \n while i >= 0 and j >= 0:\n r = arr1[i] + arr2[j] + c\n i -= 1\n j -= 1\n c = r // 10\n result[l] = r % 10\n l -= 1\n\n while i >= 0:\n r = arr1[i] + c\n i -= 1\n c = r // 10\n result[l] = r % 10\n l -= 1\n\n while j >= 0:\n r = arr1[j] + c\n j -= 1\n c = r // 10\n result[l] = r % 10\n l -= 1\n\n if c != 0:\n new_result = [0 for j in range(len(result) + 1)]\n t = len(new_result) - 1\n while t > 0:\n new_result[t] = result[t - 1]\n t -= 1\n new_result[0] = c\n return new_result\n return result\n\narr1 = [9, 9, 9, 9, 9, 9, 9]\narr2 = [1, 6, 8, 2, 6, 7]\nresult = add(arr1, arr2)\nprint(result)\n"
},
{
"path": "python/array/commonthreesortedarray.py",
"content": "# http://www.geeksforgeeks.org/find-common-elements-three-sorted-arrays/\n\ndef common_elements(input1, input2, input3):\n result = []\n i = 0\n j = 0\n k = 0\n while i < len(input1) and j < len(input2) and k < len(input3):\n if input1[i] == input2[j] and input2[j] == input3[k]:\n result.append(input1[i])\n i = i + 1\n j = j + 1\n k = k + 1\n elif input1[i] < input2[j]:\n i = i + 1\n elif input2[j] < input3[k]:\n j = j + 1\n else:\n k = k + 1\n return result\n\nif __name__ == '__main__':\n input1 = [1, 5, 10, 20, 40, 80]\n input2 = [6, 7, 20, 80, 100]\n input3 = [3, 4, 15, 20, 30, 70, 80, 120]\n\n print(common_elements(input1, input2, input3))\n"
},
{
"path": "python/array/countinversionofsize3.py",
"content": "# http://www.geeksforgeeks.org/count-inversions-of-size-three-in-a-give-array/\n\ndef find_inversions(input):\n inversion = 0\n for i in range(1, len(input) - 1):\n larger = 0\n for k in range(0, i):\n if input[k] > input[i]:\n larger = larger + 1\n smaller = 0\n for k in range(i+1, len(input)):\n if input[k] < input[i]:\n smaller = smaller + 1\n\n inversion += larger*smaller\n return inversion\n\nif __name__ == '__main__':\n input = [9, 6, 4, 5, 8]\n print(find_inversions(input))\n \n"
},
{
"path": "python/array/flip0smaximum1s.py",
"content": "# http://www.geeksforgeeks.org/find-zeroes-to-be-flipped-so-that-number-of-consecutive-1s-is-maximized/\n\ndef flip_0s_to_maximize_consecutive_1s(input, flips_allowed):\n window_start = 0\n count_zero = 0\n result = 0\n for i in range(len(input)):\n if input[i] == 1:\n result = max(result, i - window_start + 1)\n else:\n if count_zero < flips_allowed:\n count_zero = count_zero + 1\n result = max(result, i - window_start + 1)\n else:\n while True:\n if input[window_start] == 0:\n window_start = window_start + 1\n break\n window_start = window_start + 1\n return result\n \nif __name__ == '__main__':\n input = [0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1]\n print(flip_0s_to_maximize_consecutive_1s(input, 1))\n"
},
{
"path": "python/array/longestsamesumspan.py",
"content": "# http://www.geeksforgeeks.org/longest-span-sum-two-binary-arrays/\n# java code https://github.com/mission-peace/interview/blob/master/src/com/interview/array/LongestSameSumSpan.java\n\ndef longest_span(input1, input2):\n if len(input1) != len(input2):\n raise ValueError;\n\n diff = {}\n prefix1 = 0\n prefix2 = 0\n max_span = 0\n diff[0] = -1\n for i in range(len(input1)):\n prefix1 += input1[i]\n prefix2 += input2[i]\n curr_diff = prefix1 - prefix2\n if curr_diff in diff:\n max_span = max(max_span, i - diff[curr_diff])\n else:\n diff[curr_diff] = i\n return max_span\n\nif __name__ == '__main__':\n input1 = [1, 0, 0, 1, 1, 0]\n input2 = [0, 1, 1, 0, 1, 1]\n\n print(longest_span(input1, input2))\n \n \n"
},
{
"path": "python/array/maximumsumpathtwoarrays.py",
"content": "# http://www.geeksforgeeks.org/maximum-sum-path-across-two-arrays/\n\ndef max_sum(input1, input2):\n max_sum = 0\n i = 0\n j = 0\n sum1 = 0\n sum2 = 0\n while i < len(input1) and j < len(input2):\n if input1[i] == input2[j]:\n if sum1 > sum2:\n max_sum += sum1 + input1[i]\n else:\n max_sum += sum2 + input2[j]\n i = i + 1\n j = j + 1\n sum1 = 0\n sum2 = 0\n elif input1[i] < input2[j]:\n sum1 += input1[i]\n i = i + 1\n else:\n sum2 += input2[j]\n j = j + 1\n\n while i < len(input1):\n sum1 += input1[i]\n i = i + 1\n\n while j < len(input2):\n sum2 += input2[j]\n j = j + 1\n\n if sum1 > sum2:\n max_sum += sum1\n else:\n max_sum += sum2\n\n return max_sum\n\nif __name__ == '__main__':\n input1 = [2, 3, 7, 10, 12, 15, 30, 34]\n input2 = [1, 5, 7, 8, 10, 15, 16, 19]\n\n print(max_sum(input1, input2))\n \n"
},
{
"path": "python/array/maxproductsubarray.py",
"content": "# http://www.geeksforgeeks.org/maximum-product-subarray/\n\ndef max_product(input):\n max_ending = 1\n min_ending = 1\n max_so_far = 1\n for i in input:\n if i > 0:\n max_ending = max_ending * i\n min_ending = min(min_ending*i, 1)\n elif i == 0:\n max_ending = 1\n min_ending = 1\n else:\n t = max_ending\n max_ending = max(min_ending*i, 1)\n min_ending = t * i\n if max_so_far < max_ending:\n max_so_far = max_ending\n return max_so_far\n\nif __name__ == '__main__':\n input = [-6,-3,8,-9,-1,-1,3,6,9,0,3,-1]\n print(max_product(input))\n"
},
{
"path": "python/array/numberoftrianglesunsortedarray.py",
"content": "# http://www.geeksforgeeks.org/find-number-of-triangles-possible/\n\ndef number_of_triangles(input):\n input.sort()\n count = 0\n for i in range(len(input)-2):\n k = i + 2\n for j in range(i+1, len(input)):\n while k < len(input) and input[i] + input[j] > input[k]:\n k = k + 1\n count += k - j - 1\n return count\n\nif __name__ == '__main__':\n input = [15, 9, 8, 3, 4, 5, 6]\n print(number_of_triangles(input))\n \n \n \n \n"
},
{
"path": "python/array/positiveandnegativealternativelymaintainingorder.py",
"content": "# http://www.geeksforgeeks.org/rearrange-array-alternating-positive-negative-items-o1-extra-space/\n\ndef rearrange(input):\n for i in range (len(input)):\n if i%2 == 0 and input[i] >= 0:\n index_of_next_negative = find_next(input, i+1, False)\n if index_of_next_negative == -1:\n return\n else:\n right_rotate(input, i, index_of_next_negative)\n elif i % 2 != 0 and input[i] < 0:\n index_of_next_positive = find_next(input, i+1, True)\n if index_of_next_positive == -1:\n return\n else:\n right_rotate(input, i, index_of_next_positive)\n\ndef find_next(input, start, isPositive):\n for i in range(start, len(input)):\n if (isPositive and input[i] >= 0) or (not isPositive and input[i] < 0):\n return i;\n return -1\n\ndef right_rotate(input, start, end):\n t = input[end]\n for i in range(end, start -1, -1):\n input[i] = input[i-1]\n input[start] = t\n\nif __name__ == '__main__':\n input = [-5, -2, 5, 2, 4, 7, 1, 8, 0, -8];\n rearrange(input)\n print(input)\n \n"
},
{
"path": "python/array/rearrangearrayperindex.py",
"content": "# http://www.geeksforgeeks.org/rearrange-array-arrj-becomes-arri-j/\n\ndef rearrange(input):\n for i in range(len(input)):\n input[i] += 1\n\n for i in range(len(input)):\n if input[i] > 0:\n rearrange_util(input, i)\n\n for i in range(len(input)):\n input[i] = -input[i] - 1\n\ndef rearrange_util(input, start):\n i = start + 1\n v = input[start]\n while v > 0:\n t = input[v-1]\n input[v-1] = -i\n i = v\n v = t\n\nif __name__ == '__main__':\n input = [1, 2, 0, 5, 3, 4];\n rearrange(input)\n print(input)\n"
},
{
"path": "python/array/reorderarraybyindex.py",
"content": "# http://www.geeksforgeeks.org/reorder-a-array-according-to-given-indexes/\n\ndef reorder(input, index):\n if len(input) != len(index):\n raise ValueError\n for i in range(len(index)):\n while index[i] != i:\n s_index = index[index[i]]\n s_val = input[index[i]]\n\n index[index[i]] = index[i]\n input[index[i]] = input[i]\n\n index[i] = s_index\n input[i] = s_val\n\nif __name__ == '__main__':\n input = [50, 40, 70, 60, 90]\n index = [3, 0, 4, 1, 2]\n\n reorder(input, index)\n print(input)\n print(index)\n\n \n"
},
{
"path": "python/array/rotationwithmaxsum.py",
"content": "# http://www.geeksforgeeks.org/find-maximum-value-of-sum-iarri-with-only-rotations-on-given-array-allowed/\n\ndef max_sum(input):\n arr_sum = 0\n rotation_sum = 0\n for i in range(len(input)):\n arr_sum += input[i]\n rotation_sum += i*input[i]\n\n max_rotation_sum = rotation_sum\n\n for i in range(1, len(input)):\n rotation_sum += len(input)*input[i-1] - arr_sum\n max_rotation_sum = max(max_rotation_sum, rotation_sum)\n\n return max_rotation_sum\n\nif __name__ == '__main__':\n input = [10, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n print(max_sum(input))\n"
},
{
"path": "python/array/smallestintegernotrepresentedbysubsetsum.py",
"content": "# http://www.geeksforgeeks.org/find-smallest-value-represented-sum-subset-given-array/\n\ndef find_smallest_integer(input):\n result = 1\n for i in range(len(input)):\n if input[i] <= result:\n result += input[i]\n else:\n break\n return result\n\nif __name__ == '__main__':\n input = [1, 2, 3, 8]\n print(find_smallest_integer(input))\n"
},
{
"path": "python/array/tripletsumlessthantotal.py",
"content": "# http://www.geeksforgeeks.org/count-triplets-with-sum-smaller-that-a-given-value/\n\ndef find_all_triplet(input, total):\n input.sort()\n result = 0\n for i in range(len(input) - 2):\n j = i + 1\n k = len(input) - 1\n while j < k:\n if input[i] + input[j] + input[k] >= total:\n k = k - 1\n else:\n result += k - j\n j = j + 1\n return result\n\n\nif __name__ == '__main__':\n input = [5, 1, 3, 4, 7]\n print(find_all_triplet(input, 12))\n \n"
},
{
"path": "python/array/zigzagarrangement.py",
"content": "# http://www.geeksforgeeks.org/convert-array-into-zig-zag-fashion/\n\ndef rearrange(input):\n is_less = True\n for i in range(len(input)-1):\n if is_less:\n if input[i] > input[i+1]:\n swap(input, i, i+1)\n else:\n if input[i] < input[i+1]:\n swap(input, i, i+1)\n is_less = not is_less\n\ndef swap(input, i, j):\n t = input[i]\n input[i] = input[j]\n input[j] = t\n\nif __name__ == '__main__':\n input = [4, 3, 2, 6, 7, 1, 9]\n rearrange(input)\n print(input)\n \n"
},
{
"path": "python/dynamic/bitonicsequence.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nFind the length of the longest Bitonic Sequence in a given sequence of numbers. A Bitonic sequence is a sequence of\nnumbers which are increasing and then decreasing.\n\nVideo\n-----\n* https://youtu.be/TWHytKnOPaQ\n\nAnalysis\n--------\n* Runtime O(n)\n\nReference\n---------\n* http://www.geeksforgeeks.org/dynamic-programming-set-15-longest-bitonic-subsequence/\n\"\"\"\n\n\ndef longest_bitonic(sequence):\n length_of_input = len(sequence)\n increasing_sequence = [1] * length_of_input\n decreasing_sequence = [1] * length_of_input\n\n for i in range(1, length_of_input):\n for j in range(0, i):\n if sequence[i] > sequence[j]:\n increasing_sequence[i] = max(increasing_sequence[i], increasing_sequence[j] + 1)\n\n for i in range(length_of_input - 2, -1, -1):\n for j in range(length_of_input - 1, i, -1):\n if sequence[i] > sequence[j]:\n decreasing_sequence[i] = max(decreasing_sequence[i], decreasing_sequence[j] + 1)\n\n max_value = 0\n\n for i in range(len(sequence)):\n bitonic_sequence_length = increasing_sequence[i] + decreasing_sequence[i] - 1\n max_value = max(max_value, bitonic_sequence_length)\n\n return max_value\n\n\nif __name__ == '__main__':\n max_value = longest_bitonic([1, 4, 3, 7, 2, 1, 8, 11, 13, 0])\n assert 7 == max_value # 1, 4, 7, 8, 11, 13, 0\n"
},
{
"path": "python/dynamic/boxstacking.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven different dimensions and unlimited supply of boxes for each dimension, stack boxes on top of each other such that\nit has maximum height but with caveat that length and width of box on top should be strictly less than length and width\nof box under it. You can rotate boxes as you like.\n\n1) Create all rotations of boxes such that length is always greater or equal to width\n2) Sort boxes by base area in non increasing order (length * width). This is because box\n with more area will never ever go on top of box with less area.\n3) Take T[] and result[] array of same size as total boxes after all rotations are done\n4) Apply longest increasing subsequence type of algorithm to get max height.\n\nAnalysis\n--------\nIf n number of dimensions are given total boxes after rotation will be 3n.\n* Space complexity is O(n)\n* Time complexity - O(nlogn) to sort boxes. O(n^2) to apply DP on it So really O(n^2)\n\nVideo\n-----\n* https://youtu.be/9mod_xRB-O0\n\nReferences\n----------\n* http://www.geeksforgeeks.org/dynamic-programming-set-21-box-stacking-problem/\n* http://people.cs.clemson.edu/~bcdean/dp_practice/\n\"\"\"\n\nfrom collections import namedtuple\nfrom itertools import permutations\n\ndimension = namedtuple(\"Dimension\", \"height length width\")\n\n\ndef create_rotation(given_dimensions):\n \"\"\"\n A rotation is an order wherein length is greater than or equal to width. Having this constraint avoids the\n repetition of same order, but with width and length switched.\n\n For e.g (height=3, width=2, length=1) is same the same box for stacking as (height=3, width=1, length=2).\n\n :param given_dimensions: Original box dimensions\n :return: All the possible rotations of the boxes with the condition that length >= height.\n \"\"\"\n for current_dim in given_dimensions:\n for (height, length, width) in permutations((current_dim.height, current_dim.length, current_dim.width)):\n if length >= width:\n yield dimension(height, length, width)\n\n\ndef sort_by_decreasing_area(rotations):\n return sorted(rotations, key=lambda dim: dim.length * dim.width, reverse=True)\n\n\ndef can_stack(box1, box2):\n return box1.length < box2.length and box1.width < box2.width\n\n\ndef box_stack_max_height(dimensions):\n boxes = sort_by_decreasing_area([rotation for rotation in create_rotation(dimensions)])\n num_boxes = len(boxes)\n T = [rotation.height for rotation in boxes]\n R = [idx for idx in range(num_boxes)]\n\n for i in range(1, num_boxes):\n for j in range(0, i):\n if can_stack(boxes[i], boxes[j]):\n stacked_height = T[j] + boxes[i].height\n if stacked_height > T[i]:\n T[i] = stacked_height\n R[i] = j\n\n max_height = max(T)\n start_index = T.index(max_height)\n\n # Prints the dimensions which were stored in R list.\n while True:\n print boxes[start_index]\n next_index = R[start_index]\n if next_index == start_index:\n break\n start_index = next_index\n\n return max_height\n\n\nif __name__ == '__main__':\n\n d1 = dimension(3, 2, 5)\n d2 = dimension(1, 2, 4)\n\n assert 11 == box_stack_max_height([d1, d2])\n"
},
{
"path": "python/dynamic/breakword.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven a string and a dictionary, split the string in to multiple words so that each word belongs to the dictionary.\n\nVideo\n-----\n\n* https://youtu.be/WepWFGxiwRs\n\nAnalysis\n--------\n\n* word_break_recursive: Exponential\n* word_break_dp : O(n^3)\n\nSolution\n--------\n\nif input[i..j] belongs in a dictionary:\n DP[i][j] = True\nelse:\n DP[i][j] = True if DP[i][k-1] and DP[k][j] for any k between i to j.\n\nMultiple different implementations are given below.\n\"\"\"\n\n\ndef word_break_recursive(given_string, dictionary):\n \"\"\"\"Returns None if the given string cannot be broken into words, otherwise returns space separate words.\"\"\"\n\n given_string_length = len(given_string)\n if given_string_length == 0:\n return \"\"\n string = \"\"\n for i in range(given_string_length):\n string += given_string[i]\n if string in dictionary:\n r = word_break_recursive(given_string[i + 1:], dictionary)\n if r is not None:\n string += \" \" + r\n return string\n return None\n\n\ndef word_break_dp(given_string, dictionary):\n \"\"\"Returns None if the given string cannot be broken into words, otherwise returns space separated words.\"\"\"\n\n given_string_length = len(given_string)\n\n # -1 indicates the word cannot be split.\n DP = [[-1 for _ in range(given_string_length)] for _ in range(given_string_length)]\n\n for substring_length in range(1, given_string_length + 1):\n for start in range(0, given_string_length - substring_length + 1):\n end = start + substring_length - 1\n substring = given_string[start: end + 1]\n if substring in dictionary:\n DP[start][end] = start\n continue\n\n for split in range(start + 1, end + 1):\n if DP[start][split - 1] != -1 and DP[split][end] != -1:\n DP[start][end] = split\n break\n\n if DP[0][-1] == -1:\n return None\n\n words = []\n start_index = 0\n end_index = given_string_length - 1\n while start_index < given_string_length:\n split_index = DP[start_index][end_index]\n if start_index == split_index:\n words.append(given_string[start_index: end_index + 1])\n break\n else:\n words.append(given_string[start_index: split_index])\n start_index = split_index\n\n return \" \".join(words)\n\n\ndef is_word_break_possible(given_string, dictionary):\n \"\"\"Returns if any word break is possible amongst the multiple word breaks in the sentence.\"\"\"\n\n DP = dict()\n max_word_length = len(max(dictionary, key=len))\n return is_word_break_possible_recursive_helper(given_string, dictionary, 0, max_word_length, DP)\n\n\ndef is_word_break_possible_recursive_helper(given_string, dictionary, start, max_word_length, DP):\n if start == len(given_string):\n return True\n\n if start in DP:\n return DP[start]\n\n for i in range(start, start + max_word_length):\n if i < len(given_string):\n new_word = given_string[start: i + 1]\n if new_word in dictionary:\n continue\n if is_word_break_possible_recursive_helper(given_string, dictionary, i + 1, max_word_length, DP):\n DP[start] = True\n return True\n\n DP[start] = False\n return False\n\n\ndef all_possible_word_break_helper(given_string, dictionary, start, max_word_length, DP):\n \"\"\"\"Returns all possible word breaks in a given sentence.\"\"\"\n if start == len(given_string):\n return [\"\"]\n\n if start in DP:\n return DP[start]\n\n words = []\n for i in range(start, start + max_word_length):\n if i < len(given_string):\n new_word = given_string[start: i + 1]\n if new_word not in dictionary:\n continue\n sub_words = all_possible_word_break_helper(given_string, dictionary, i + 1, max_word_length, DP)\n for word in sub_words:\n extra_space = \"\" if len(word) == 0 else \" \"\n words.append(new_word + extra_space + word)\n\n DP[start] = words\n return words\n\n\ndef all_possible_word_breaks(given_string, dictionary):\n DP = dict()\n max_word_length = len(max(dictionary, key=len))\n return all_possible_word_break_helper(given_string, dictionary, 0, max_word_length, DP)\n\n\nif __name__ == '__main__':\n dictionary = {\"joy\", \"likes\", \"to\", \"play\"}\n given_string = \"joylikestoplay\"\n\n assert True == is_word_break_possible(given_string, dictionary)\n assert \"joy likes to play \" == word_break_recursive(given_string, dictionary)\n assert \"joy likes to play\" == word_break_dp(given_string, dictionary)\n\n dictionary = {\"pea\", \"nut\", \"peanut\", \"butter\"}\n given_string = \"peanutbutter\"\n assert ['pea nut butter', 'peanut butter'] == all_possible_word_breaks(given_string, dictionary)\n"
},
{
"path": "python/dynamic/coin_change_num_ways.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven a total and coins of certain denominations find number of ways total can be formed from coins assuming infinity\nsupply of coins.\n\nAnalysis\n--------\n* Runtime : O(num_of_coins * total)\n\nVideo\n-----\n* https://youtu.be/_fgjrs570YE\n\nReference\n---------\n* http://www.geeksforgeeks.org/dynamic-programming-set-7-coin-change/\n\"\"\"\n\n\ndef coin_changing_num_ways(coins, total):\n cols = total + 1 # 1 for value 0 in total\n rows = len(coins)\n T = [[1 if col == 0 else 0 for col in range(cols)] for _ in range(rows)]\n\n for i in range(rows):\n for j in range(cols):\n if (i - 1) < 0:\n continue\n if j < coins[i]:\n T[i][j] = T[i - 1][j]\n else:\n T[i][j] = T[i - 1][j] + T[i][j - coins[i]]\n\n return T[rows - 1][cols - 1]\n\n\ndef coin_changing_num_ways2(coins, total):\n cols = total + 1\n num_coins = len(coins)\n\n # Using 1-D Array instead of 2-D Array. Approach is same as coin_changing_num_ways.\n T = [1 if col == 0 else 0 for col in range(cols)]\n\n for i in range(num_coins):\n for col in range(1, cols):\n if col >= coins[i]:\n T[col] += T[col - coins[i]]\n\n return T[cols - 1]\n\n\ndef print_coin_changes_recursive(coins, total, results_stack, pos):\n if total == 0:\n for coin in results_stack:\n print \"%d \" % coin,\n print\n\n for idx in range(pos, len(coins)):\n if total >= coins[idx]:\n results_stack.append(coins[idx])\n print_coin_changes_recursive(coins, total - coins[idx], results_stack, idx)\n results_stack.pop() # Remove last inserted coin from stack to use new coin with different index.\n\n\ndef print_coin_changes(coins, total):\n print_coin_changes_recursive(coins, total, list(), 0)\n\n\nif __name__ == '__main__':\n coins = [1, 2, 3]\n total = 5\n expected = 5\n assert expected == coin_changing_num_ways(coins, total)\n assert expected == coin_changing_num_ways2(coins, total)\n print_coin_changes(coins, total)\n"
},
{
"path": "python/dynamic/coinchangingmincoins.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven coins of certain denominations with infinite supply find minimum number of coins it takes to form given total\n\nVideo\n-----\n\n* Topdown DP - https://youtu.be/Kf_M7RdHr1M\n* Bottom Up DP - https://youtu.be/Y0ZqKpToTic (Approach 1. 2D array.)\n* Bottom up DP - https://youtu.be/NJuKJ8sasGk (Same as Approach 1. Uses 1D array since 2D array is not required.)\n\nAnalysis\n--------\n\n* Time complexity - O(len(coins) * total)\n* Space complexity - O(len(coins) * total)\n\"\"\"\n\n\ndef min_coins(coins, total):\n cols = total + 1\n rows = len(coins)\n T = [[0 if col == 0 else float(\"inf\") for col in range(cols)] for _ in range(rows)]\n\n for i in range(rows):\n for j in range(1, cols):\n if j < coins[i]:\n T[i][j] = T[i - 1][j]\n else:\n T[i][j] = min(T[i - 1][j], 1 + T[i][j - coins[i]])\n\n return T[rows - 1][cols - 1]\n\n\ndef print_coins(R, coins):\n start = len(R) - 1\n\n if R[start] == -1:\n print \"No Solution Possible.\"\n return\n\n print \"Coins:\",\n while start != 0:\n coin = coins[R[start]]\n print \"%d \" % coin,\n start = start - coin\n\n\ndef min_coins2(coins, total):\n cols = total + 1\n T =[0 if idx == 0 else float(\"inf\") for idx in range(cols)]\n R = [-1 for _ in range(total + 1)]\n\n for j in range(len(coins)):\n for i in range(1, cols):\n coin = coins[j]\n if i >= coins[j]:\n if T[i] > 1 + T[i - coin]:\n T[i] = 1 + T[i - coin]\n R[i] = j\n\n print_coins(R, coins)\n return T[cols - 1]\n\n\ndef min_coins_top_down(coins, total, memo):\n if total == 0:\n return 0\n\n if total in memo:\n return memo[total]\n\n min_value = float(\"inf\")\n for i in range(len(coins)):\n coin = coins[i]\n if coin > total:\n continue\n val = min_coins_top_down(coins, total - coin, memo)\n min_value = min(min_value, val)\n\n min_value += 1\n\n memo[total] = min_value\n return min_value\n\n\nif __name__ == '__main__':\n coins = [1, 5, 6, 8]\n total = 11\n expected = 2\n assert expected == min_coins(coins, total)\n assert expected == min_coins2(coins, total)\n assert expected == min_coins_top_down(coins, total, dict())\n"
},
{
"path": "python/dynamic/count_num_A.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nImagine you have a special keyboard with the following keys:\n\nKey 1: Prints 'A' on screen\nKey 2: (Ctrl-A): Select screen\nKey 3: (Ctrl-C): Copy selection to buffer\nKey 4: (Ctrl-V): Print buffer on screen appending it\n after what has already been printed.\n\nIf you can only press the keyboard for N times (with the above four\nkeys), write a program to produce maximum numbers of A's. That is to\nsay, the input parameter is N (No. of keys that you can press), the\noutput is M (No. of As that you can produce).\n\nComplexity\n----------\n\n* Recursive Solution : Exponential > O(2^n)\n* Dynamic Programming: Quadratic O(n^2)\n\nReference\n---------\n* http://www.geeksforgeeks.org/how-to-print-maximum-number-of-a-using-given-four-keys/\n\"\"\"\n\n\ndef count_a_recursive(n_times):\n if n_times < 7:\n return n_times\n\n result = float(\"-inf\")\n\n for sub_prob in range(n_times - 3, 0, -1):\n result = max(result, (n_times - sub_prob - 1) * count_a_recursive(sub_prob))\n\n return result\n\n\ndef count_a(n_times):\n if n_times < 7:\n return n_times\n\n T = [0 for _ in range(n_times + 1)]\n\n for num in range(7):\n T[num] = num\n\n for n in range(7, n_times + 1):\n for sub_prob in range(n - 3, 0, -1):\n T[n] = max(T[n], T[sub_prob] * (n - sub_prob - 1))\n\n return T[n_times]\n\n\nif __name__ == '__main__':\n expected = 9\n assert expected == count_a_recursive(7)\n assert expected == count_a(7)\n"
},
{
"path": "python/dynamic/count_num_binary_without_consec_1.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven a positive integer N, count all the numbers from 1 to 2^N, whose binary representation does not have consecutive\n1s.\n\nThis is a simple application of fibonacci series.\n\nVideo\n-----\n\n* https://www.youtube.com/watch?v=a9-NtLIs1Kk\n\nComplexity\n----------\n\n* Runtime Complexity: O(n)\n\n\nReference\n---------\n\n* http://www.geeksforgeeks.org/count-number-binary-strings-without-consecutive-1s/\n\"\"\"\n\n\ndef consec_one(num_n):\n f1 = f2 = 1\n\n for _ in range(num_n):\n f1, f2 = f1 + f2, f1\n\n return f1\n\nif __name__ == '__main__':\n assert 13 == consec_one(5)\n"
},
{
"path": "python/dynamic/cutting_rod.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven a rod of length n inches and an array of prices that contains prices of all pieces of size smaller than n.\nDetermine the maximum value obtainable by cutting up the rod and selling the pieces.\n\nVideo\n-----\n\n* https://youtu.be/IRwVmTmN6go\n\n\nTime Complexity\n---------------\n\n1. Recursive Solution = O(2^n)\n2. Dynamic Programming Solution = O(n^2)\n\nReference\n---------\nhttp://www.geeksforgeeks.org/dynamic-programming-set-13-cutting-a-rod/\n\"\"\"\n\n\ndef max_profit_dp(prices, rod_length):\n rod_length_values = [0 for _ in range(rod_length + 1)]\n\n for length in range(1, rod_length + 1):\n\n max_value = float(\"-inf\")\n\n for cut_length in range(1, length + 1):\n max_value = max(max_value, prices[cut_length - 1] + rod_length_values[length - cut_length])\n\n rod_length_values[length] = max_value\n\n return rod_length_values[rod_length]\n\n\ndef max_profit_recursive(prices, rod_length):\n if rod_length == 0:\n return 0\n\n max_price = float('-inf')\n\n for length in range(1, rod_length + 1):\n max_price = max(max_price, prices[length - 1] + max_profit_recursive(prices, rod_length - length))\n\n return max_price\n\n\nif __name__ == '__main__':\n prices = [3,5,8,9,10,20,22,25]\n rod_length = 8\n expected_max_profit = 26\n assert expected_max_profit == max_profit_recursive(prices, rod_length)\n assert expected_max_profit == max_profit_dp(prices, rod_length)\n"
},
{
"path": "python/dynamic/dice_throw_ways.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven n dice each with m faces, numbered from 1 to m, find the number of ways to get sum X. X is the summation of values\non each face when all the dice are thrown.\n\nComplexity\n----------\n\n* Run time complexity: O(m * n * x) where m is number of faces, n is number of dice and x is given sum.\n\n\nReferences\n----------\n\n* http://www.geeksforgeeks.org/dice-throw-problem/\n\"\"\"\n\n\ndef num_ways(faces, dices, sumX):\n\n T = [[0 for _ in range(sumX + 1)] for _ in range(dices + 1)]\n\n # For a single dice\n for face_value in range(1, faces + 1):\n if face_value <= sumX:\n T[1][face_value] = 1\n\n for dice in range(2, dices + 1):\n for partial_sum in range(1, sumX + 1):\n for face_value in range(1, faces + 1):\n if face_value < partial_sum:\n T[dice][partial_sum] += T[dice - 1][partial_sum - face_value]\n\n return T[dices][sumX]\n\n\nif __name__ == '__main__':\n assert 7 == num_ways(3, 3, 6)\n"
},
{
"path": "python/dynamic/editdistance.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven two strings str1 and str2, find the minimum number of edits (edit one character to another, delete char from str1\nor delete char from str2) to change str1 to str2.\n\nVideo\n-----\n* https://youtu.be/We3YDTzNXEk\n\nAnalysis\n--------\n* DP Runtime : O(len(str1) * len(str2))\n* Recursive Solution: Exponential (O(3^(m+n-1)))\n\nReference\n---------\n* https://www.clear.rice.edu/comp130/12spring/editdist/\n\"\"\"\n\n\ndef print_edits(T, str1, str2):\n i = len(T) - 1\n j = len(T[0]) - 1\n while True:\n if i == 0 or j == 0:\n break\n if str2[i - 1] == str1[j - 1]:\n i -= 1\n j -= 1\n elif T[i][j] == T[i - 1][j - 1] + 1:\n print \"Edit %s in string1 to %s in string2.\" % (str1[j - 1], str2[i - 1])\n i -= 1\n j -= 1\n elif T[i][j] == T[i - 1][j] + 1:\n print \"Delete %s in string2.\" % str2[i - 1]\n i -= 1\n elif T[i][j] == T[i][j - 1] + 1:\n print \"Delete %s in string1.\" % str1[j - 1]\n j -= 1\n\n\ndef min_edit_distance(str1, str2):\n rows = len(str2) + 1\n cols = len(str1) + 1\n T = [[0 for _ in range(cols)] for _ in range(rows)]\n\n for j in range(cols):\n T[0][j] = j\n\n for i in range(rows):\n T[i][0] = i\n\n for i in range(1, rows):\n for j in range(1, cols):\n if str2[i - 1] == str1[j - 1]:\n T[i][j] = T[i - 1][j - 1]\n else:\n T[i][j] = 1 + min(T[i - 1][j - 1], T[i - 1][j], T[i][j - 1])\n\n print_edits(T, str1, str2)\n return T[rows - 1][cols - 1]\n\ndef min_edit_distance_recursive(str1, str2):\n i = len(str1)\n j = len(str2)\n\n if i == 0: return j\n if j == 0: return i\n\n return min(min_edit_distance_recursive(str1[:i - 1], str2) + 1,\n min_edit_distance_recursive(str1, str2[:j - 1]) + 1,\n min_edit_distance_recursive(str1[:i - 1], str2[:j - 1]) + (1 if str1[i - 1] != str2[j - 1] else 0))\n\nif __name__ == '__main__':\n str1 = \"azced\"\n str2 = \"abcdef\"\n expected = 3\n assert expected == min_edit_distance(str1, str2)\n assert expected == min_edit_distance(str2, str1)\n assert expected == min_edit_distance_recursive(str1, str2)\n"
},
{
"path": "python/dynamic/egg_drop.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven a certain number of eggs and a certain number of floors, determine the minimum number of attempts required to find\nthe egg breaking floor.\n\nAnalysis\n--------\n\n* Dynamic Programming Time Complexity: O(eggs * num_floors^2)\n* Recursive Solution: Exponential\n\nVideo\n-----\n\n* https://youtu.be/3hcaVyX00_4\n\nReference\n---------\n\n* http://www.geeksforgeeks.org/dynamic-programming-set-11-egg-dropping-puzzle/\n\n\"\"\"\n\n\ndef min_attempts_egg_drop(eggs, floors):\n num_eggs = eggs + 1\n num_floors = floors + 1\n\n T = [[floor if egg == 1 else 0 for floor in range(num_floors)] for egg in range(num_eggs)]\n\n for egg in range(2, num_eggs):\n for floor in range(1, num_floors):\n T[egg][floor] = min(1 + max(T[egg - 1][k - 1], T[egg][floor - k]) for k in range(1, floor + 1))\n\n return T[num_eggs - 1][num_floors - 1]\n\n\ndef min_attempts_egg_drop_recursive(eggs, floors):\n if eggs == 1 or floors == 0:\n return floors\n\n min_value = float(\"inf\")\n\n for floor in range(1, floors + 1):\n min_value = min(min_value,\n 1 + max(min_attempts_egg_drop_recursive(eggs - 1, floor - 1),\n min_attempts_egg_drop_recursive(eggs, floors - floor)))\n\n return min_value\n\n\nif __name__ == '__main__':\n eggs = 3\n floors = 100\n expected_attempts = 9\n\n assert expected_attempts == min_attempts_egg_drop(eggs, floors)\n\n eggs = 2\n floors = 6\n expected_attempts = 3\n assert expected_attempts == min_attempts_egg_drop_recursive(eggs, floors)\n"
},
{
"path": "python/dynamic/knapsack_01.py",
"content": "\"\"\"\nProblem Statement\n=================\n\n0/1 Knapsack Problem - Given items of certain weights/values and maximum allowed weight how to pick items to pick items\nfrom this set to maximize sum of value of items such that sum of weights is less than or equal to maximum allowed\nweight.\n\nRuntime Analysis\n----------------\nTime complexity - O(W*total items)\n\nVideo\n-----\n* Topdown DP - https://youtu.be/149WSzQ4E1g\n* Bottomup DP - https://youtu.be/8LusJS5-AGo\n\nReferences\n----------\n* http://www.geeksforgeeks.org/dynamic-programming-set-10-0-1-knapsack-problem/\n* https://en.wikipedia.org/wiki/Knapsack_problem\n\"\"\"\n\n\ndef knapsack_01(values, weights, total):\n total_items = len(weights)\n\n rows = total_items + 1\n cols = total + 1\n\n T = [[0 for _ in range(cols)] for _ in range(rows)]\n\n for i in range(1, rows):\n for j in range(1, cols):\n if j < weights[i - 1]:\n T[i][j] = T[i - 1][j]\n else:\n T[i][j] = max(T[i - 1][j], values[i - 1] + T[i - 1][j - weights[i - 1]])\n\n return T[rows - 1][cols -1]\n\n\ndef knapsack_01_recursive_util(values, weights, remaining_weight, total_items, current_item, memo):\n if current_item >= total_items or remaining_weight <= 0:\n return 0\n\n key = (total_items - current_item - 1, remaining_weight)\n\n if key in memo:\n return memo[key]\n\n if remaining_weight < weights[current_item]:\n max_value = knapsack_01_recursive_util(values, weights, remaining_weight, total_items, current_item + 1, memo)\n else:\n max_value = max(values[current_item] + knapsack_01_recursive_util(values, weights, remaining_weight - weights[current_item], total_items, current_item + 1, memo),\n knapsack_01_recursive_util(values, weights, remaining_weight, total_items, current_item + 1, memo))\n\n memo[key] = max_value\n return max_value\n\n\ndef knapsack_01_recursive(values, weights, total_weight):\n memo = dict()\n return knapsack_01_recursive_util(values, weights, total_weight, len(values), 0, memo)\n\n\nif __name__ == '__main__':\n total_weight = 7\n weights = [1, 3, 4, 5]\n values = [1, 4, 5, 7]\n expected = 9\n assert expected == knapsack_01(values, weights, total_weight)\n assert expected == knapsack_01_recursive(values, weights, total_weight)\n total_weight = 8\n weights = [2, 2, 4, 5]\n values = [2, 4, 6, 9]\n expected = 13\n assert expected == knapsack_01(values, weights, total_weight)\n assert expected == knapsack_01_recursive(values, weights, total_weight)\n"
},
{
"path": "python/dynamic/kth_ugly_number.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nUgly numbers are numbers whose only prime factors are 2, 3 or 5. The sequence 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15,\nshows the first 11 ugly numbers. By convention, 1 is included.\n\nWrite a program to find the kth ugly number.\n\nComplexity\n----------\n\n* Time Complexity O(n)\n* Space Complexity O(n)\n\nReference\n---------\n* http://www.geeksforgeeks.org/ugly-numbers/\n\"\"\"\n\n\ndef ugly_number(kth):\n ugly_factors = [1] # By convention 1 is included.\n\n factor_index = {\n 2: 0,\n 3: 0,\n 5: 0}\n\n for num in range(1, kth):\n minimal_factor = min(min(ugly_factors[factor_index[2]] * 2, ugly_factors[factor_index[3]] * 3),\n ugly_factors[factor_index[5]] * 5)\n\n ugly_factors.append(minimal_factor)\n\n for factor in [2, 3, 5]:\n if minimal_factor % factor == 0:\n factor_index[factor] += 1\n\n return ugly_factors[kth - 1]\n\nif __name__ == '__main__':\n assert 5832 == ugly_number(150)\n"
},
{
"path": "python/dynamic/longest_common_subsequence.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven two sequences A = [A1, A2, A3,..., An] and B = [B1, B2, B3,..., Bm], find the length of the longest common\nsubsequence.\n\nVideo\n-----\n\n* https://youtu.be/NnD96abizww\n\nComplexity\n----------\n\n* Recursive Solution: O(2^n) (or O(2^m) whichever of n and m is larger).\n* Dynamic Programming Solution: O(n * m)\n\nReference\n---------\n\n* https://en.wikipedia.org/wiki/Longest_common_subsequence_problem\n* http://www.geeksforgeeks.org/dynamic-programming-set-4-longest-common-subsequence/\n\"\"\"\n\n\ndef lcs_recursive_helper(sequence1, sequence2, index1, index2):\n if (index1 == len(sequence1)) or (index2 == len(sequence2)):\n return 0\n\n if sequence1[index1] == sequence2[index2]:\n return 1 + lcs_recursive_helper(sequence1, sequence2, index1 + 1, index2 + 1)\n\n return max(lcs_recursive_helper(sequence1, sequence2, index1 + 1, index2),\n lcs_recursive_helper(sequence1, sequence2, index1, index2 + 1))\n\n\ndef longest_common_subsequence_recursive(sequence1, sequence2):\n return lcs_recursive_helper(sequence1, sequence2, 0, 0)\n\n\ndef longest_common_subsequence(sequence1, sequence2):\n cols = len(sequence1) + 1 # Add 1 to represent 0 valued column for DP\n rows = len(sequence2) + 1 # Add 1 to represent 0 valued row for DP\n\n T = [[0 for _ in range(cols)] for _ in range(rows)]\n\n max_length = 0\n\n for i in range(1, rows):\n for j in range(1, cols):\n if sequence2[i - 1] == sequence1[j - 1]:\n T[i][j] = 1 + T[i - 1][j - 1]\n else:\n T[i][j] = max(T[i - 1][j], T[i][j - 1])\n\n max_length = max(max_length, T[i][j])\n\n return max_length\n\n\nif __name__ == '__main__':\n sequence1 = \"ABCDGHLQR\"\n sequence2 = \"AEDPHR\"\n expected_length = 4\n assert expected_length == longest_common_subsequence_recursive(sequence1, sequence2)\n assert expected_length == longest_common_subsequence_recursive(sequence2, sequence1)\n assert expected_length == longest_common_subsequence(sequence1, sequence2)\n assert expected_length == longest_common_subsequence(sequence2, sequence1)\n"
},
{
"path": "python/dynamic/longest_common_substring.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven two sequences A = [A1, A2, A3,..., An] and B = [B1, B2, B3,..., Bm], find the length of the longest common\nsubstring.\n\nVideo\n-----\n\n* https://youtu.be/BysNXJHzCEs\n\nComplexity\n----------\n\n* Recursive Solution: O(2^n) (or O(2^m) whichever of n and m is larger).\n* Dynamic Programming Solution: O(n * m)\n\nReference\n---------\n\n* http://en.wikipedia.org/wiki/Longest_common_substring_problem\n\"\"\"\n\n\ndef longest_common_string_recursive_helper(str1, str2, pos1, pos2, check_equal):\n if pos1 == -1 or pos2 == -1:\n return 0\n\n if check_equal:\n if str1[pos1] == str2[pos2]:\n return 1 + longest_common_string_recursive_helper(str1, str2, pos1 - 1, pos2 - 1, True)\n else:\n return 0\n\n longest = 0 # start (again) to find the longest from the current positions\n if str1[pos1] == str2[pos2]:\n longest = 1 + longest_common_string_recursive_helper(str1, str2, pos1 - 1, pos2 - 1, True)\n\n return max(longest,\n longest_common_string_recursive_helper(str1, str2, pos1, pos2 - 1, False),\n longest_common_string_recursive_helper(str1, str2, pos1 - 1, pos2, False))\n\n\ndef longest_common_substring_recursive(str1, str2):\n return longest_common_string_recursive_helper(str1, str2, len(str1) - 1, len(str2) - 1, False)\n\n\ndef longest_common_substring(str1, str2):\n cols = len(str1) + 1 # Add 1 to represent 0 valued col for DP\n rows = len(str2) + 1 # Add 1 to represent 0 valued row for DP\n\n T = [[0 for _ in range(cols)] for _ in range(rows)]\n\n max_length = 0\n\n for i in range(1, rows):\n for j in range(1, cols):\n if str2[i - 1] == str1[j - 1]:\n T[i][j] = T[i - 1][j - 1] + 1\n max_length = max(max_length, T[i][j])\n\n return max_length\n\n\nif __name__ == '__main__':\n str1 = \"abcdef\"\n str2 = \"zcdemf\"\n expected = 3\n assert expected == longest_common_substring(str1, str2)\n assert expected == longest_common_substring_recursive(str1, str2)\n str1 = \"abcdef\"\n str2 = \"cde\"\n expected = 3\n assert expected == longest_common_substring(str1, str2)\n str1 = \"cde\"\n str2 = \"zcdemf\"\n expected = 3\n assert expected == longest_common_substring(str1, str2)\n\n"
},
{
"path": "python/dynamic/longest_increasing_subsequence.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nFind a subsequence in given array in which the subsequence's elements are in sorted order, lowest to highest, and in\nwhich the subsequence is as long as possible.\n\nVideo\n-----\n* https://youtu.be/CE2b_-XfVDk\n\nSolution\n--------\n\nDynamic Programming is used to solve this question. DP equation is.::\n\n if(arr[i] > arr[j]) { T[i] = max(T[i], T[j] + 1) }\n\n* Time complexity is O(n^2).\n* Space complexity is O(n)\n\nReference\n---------\n\n* http://en.wikipedia.org/wiki/Longest_increasing_subsequence\n* http://www.geeksforgeeks.org/dynamic-programming-set-3-longest-increasing-subsequence/\n\"\"\"\n\n\ndef longest_increasing_subsequence(sequence):\n sequence_length = len(sequence)\n\n T = [1 for _ in range(sequence_length)]\n solution_indices = [i for i in range(sequence_length)]\n\n for index_i in range(1, sequence_length):\n for index_j in range(0, index_i):\n if (sequence[index_i] > sequence[index_j]) and (T[index_i] < T[index_j] + 1):\n T[index_i] = T[index_j] + 1\n solution_indices[index_i] = index_j\n\n # find the index of the max number in T\n max_value = max(T)\n max_index = T.index(max_value)\n\n # Print solution using linked values in solution_indices\n\n next_index = max_index\n\n while True:\n print sequence[next_index],\n\n old_index = next_index\n next_index = solution_indices[next_index]\n if next_index == old_index:\n break\n\n return T[max_index]\n\n\ndef longest_increasing_subsequence_recursive(sequence):\n sequence_length = len(sequence)\n longest = 0\n\n for index in range(sequence_length - 1):\n longest_so_far = longest_subsequence_recursive_helper(sequence, index + 1, sequence[index])\n if longest_so_far > longest:\n longest = longest_so_far\n\n return longest + 1\n\n\ndef longest_subsequence_recursive_helper(sequence, next_position, current_position_value):\n if next_position == len(sequence):\n return 0\n\n temp1 = 0\n if sequence[next_position] > current_position_value:\n temp1 = 1 + longest_subsequence_recursive_helper(sequence, next_position + 1, sequence[next_position])\n\n temp2 = longest_subsequence_recursive_helper(sequence, next_position + 1, current_position_value)\n\n return max(temp1, temp2)\n\n\nif __name__ == '__main__':\n sequence = [23, 10, 22, 5, 33, 8, 9, 21, 50, 41, 60, 80, 99, 22, 23, 24, 25, 26, 27]\n assert 10 == longest_increasing_subsequence(sequence)\n assert 10 == longest_increasing_subsequence_recursive(sequence)\n"
},
{
"path": "python/dynamic/longest_palindromic_subsequence.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven a string find longest palindromic subsequence in this string.\n\nComplexity\n----------\n\n* Dynamic Programming Time Complexity: O(n^2)\n* Recursive Solution Time Complexity: O(2^n)\n\nVideo\n-----\n* https://youtu.be/_nCsPn7_OgI\n\nReferences\n----------\n* http://www.geeksforgeeks.org/dynamic-programming-set-12-longest-palindromic-subsequence/\n\"\"\"\n\n\ndef longest_palindromic_subsequence(given_string):\n rows = cols = string_length = len(given_string)\n T = [[0 for _ in range(cols)] for _ in range(rows)]\n\n for row in range(rows):\n T[row][row] = 1\n\n for substring_length in range(2, string_length + 1):\n for row in range(0, string_length - substring_length + 1):\n col = row + substring_length - 1\n\n if given_string[row] == given_string[col]:\n if string_length == 2:\n T[row][col] = 2\n else:\n T[row][col] = 2 + T[row + 1][col - 1]\n else:\n T[row][col] = max(T[row + 1][col], T[row][col - 1])\n\n return T[0][-1]\n\n\ndef palindromic_subsequence_recursive_helper(given_string, start_index, length):\n if length == 0 or length == 1:\n return length\n\n if given_string[start_index] == given_string[length - start_index - 1]:\n return 2 + palindromic_subsequence_recursive_helper(given_string, start_index + 1, length - 2)\n else:\n return max(palindromic_subsequence_recursive_helper(given_string, start_index, length - 1),\n palindromic_subsequence_recursive_helper(given_string, start_index + 1, length - 1))\n\n\ndef longest_palindromic_subsequence_recursive(given_string):\n return palindromic_subsequence_recursive_helper(given_string, 0, len(given_string))\n\n\nif __name__ == '__main__':\n given_string = \"agbdba\"\n expected_result = 5\n assert expected_result == longest_palindromic_subsequence(given_string)\n assert expected_result == longest_palindromic_subsequence_recursive(given_string)\n"
},
{
"path": "python/dynamic/matrix_chain_order.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven an array p[] which represents the chain of matrices such that the ith matrix Ai is of dimension p[i-1] x p[i]. We\nneed to write a function matrix_chain_order() that should return the minimum number of multiplications needed to\nmultiply the chain.\n\nVideo\n-----\n* https://youtu.be/vgLJZMUfnsU\n\nNote\n----\n\nIn the code below we give matrices length as an array and each matrix takes 2 indices from the array.\nFor e.g. {2, 3, 4} represents two matrices (2, 3) and (3, 4) in (row, col) format.\n\n\nComplexity\n----------\n\nTime Complexity: O(n^3)\n\nReference\n---------\n\n* http://www.geeksforgeeks.org/dynamic-programming-set-8-matrix-chain-multiplication/\n\"\"\"\n\n\ndef matrix_chain_order(matrices):\n matrices_length = len(matrices)\n\n T = [[0 for _ in range(matrices_length)] for _ in range(matrices_length)]\n\n for gap in range(2, matrices_length):\n for index_i in range(0, matrices_length - gap):\n index_j = index_i + gap\n T[index_i][index_j] = 10000\n for index_k in range(index_i + 1, index_j):\n temp = T[index_i][index_k] + T[index_k][index_j] + matrices[index_i] * matrices[index_k] * matrices[index_j]\n if temp < T[index_i][index_j]:\n T[index_i][index_j] = temp\n\n return T[0][-1]\n\n\nif __name__ == '__main__':\n matrices = [4, 2, 3, 5, 3]\n assert 84 == matrix_chain_order(matrices)\n"
},
{
"path": "python/dynamic/maximum_increasing_subsequence.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven an array of n positive integers. Write a program to find the sum of maximum sum subsequence of the given array\nsuch that the integers in the subsequence are in increasing order.\n\nComplexity\n----------\n\n* Time Complexity: O(n^2)\n* Space Complexity: O(n)\n\nVideo\n-----\n\n* https://youtu.be/99ssGWhLPUE\n\nReference\n---------\n* http://www.geeksforgeeks.org/dynamic-programming-set-14-maximum-sum-increasing-subsequence/\n\"\"\"\n\n\ndef maximum_sum_subsequence(sequence):\n sequence_length = len(sequence)\n T = [sequence[i] for i in range(sequence_length)]\n\n for index_i in range(1, sequence_length):\n for index_j in range(0, index_i):\n if sequence[index_j] < sequence[index_i]:\n T[index_i] = max(T[index_i], T[index_j] + sequence[index_i])\n\n return max(T)\n\nif __name__ == '__main__':\n sequence = [1, 101, 10, 2, 3, 100, 4]\n assert 111 == maximum_sum_subsequence(sequence)\n"
},
{
"path": "python/dynamic/nth_fibonacci.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven the number n, find the nth fibanacci number.\n\nThe fibonacci series is 0, 1, 1, 2, 3 ...\n\nAnd follows the formula Fn = Fn-1 + Fn-2\n\nComplexity\n----------\n\n* Recursive Solution: O(2^n)\n* Dynamic Programming: O(n)\n\n\"\"\"\n\n\ndef fibonacci_recursive(n):\n if n == 0 or n == 1:\n return n\n\n return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)\n\n\ndef fibonacci(n):\n n1, n2 = 0, 1\n\n if n == n1 or n == n2:\n return n\n\n for i in range(2, n + 1):\n n1, n2 = n2, n1 + n2\n\n return n2\n\nif __name__ == '__main__':\n assert 610 == fibonacci_recursive(15)\n assert 610 == fibonacci(15)\n"
},
{
"path": "python/dynamic/num_bst.py",
"content": "\"\"\"\nProblem Statement\n=================\nCount number of binary search trees created for array of size n. The solution is the nth catalan number.\n\n\nComplexity\n----------\n* Dynamic Programming: O(n^2)\n* Recursive Solution: O(2^n)\n\nVideo\n-----\n\n* https://youtu.be/YDf982Lb84o\n\nReference\n---------\n* http://www.geeksforgeeks.org/program-nth-catalan-number/\n\"\"\"\n\n\ndef num_bst(num_nodes):\n T = [0 for _ in range(num_nodes + 1)]\n T[0] = 1\n T[1] = 1\n\n for node in range(2, num_nodes+1):\n for sub in range(0, node):\n T[node] += T[sub] * T[node - sub - 1]\n\n return T[num_nodes]\n\n\ndef num_bst_recursive(num_nodes):\n if num_nodes == 0 or num_nodes == 1:\n return 1\n\n result = 0\n\n for root in range(1, num_nodes + 1):\n result += num_bst_recursive(root - 1) * num_bst_recursive(num_nodes - root)\n\n return result\n\n\nif __name__ == '__main__':\n assert 5 == num_bst(3)\n assert 5 == num_bst_recursive(3)\n"
},
{
"path": "python/dynamic/num_paths_nm_matrix.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nCount the number of Paths from 1,1 to N,M in an NxM matrix.\n\nAnalysis\n--------\n\n* Dynamic Programing Solution: O(rows * cols)\n* Recursive: O(2^rows) if rows > cols else O(2^cols)\n\n\nReferences\n----------\n* http://www.geeksforgeeks.org/count-possible-paths-top-left-bottom-right-nxm-matrix/\n\n\"\"\"\n\n\ndef num_paths_matrix(rows, cols):\n T = [[1 if row == 0 or col == 0 else 0 for row in range(cols)] for col in range(rows)]\n for row in range(1, rows):\n for col in range(1, cols):\n T[row][col] = T[row - 1][col] + T[row][col - 1]\n return T[rows - 1][cols - 1]\n\n\ndef num_paths_matrix_recursive(rows, cols):\n if rows == 1 or cols == 1:\n return 1\n return num_paths_matrix(rows-1, cols) + num_paths_matrix(rows, cols - 1)\n\n\nif __name__ == '__main__':\n rows = 3\n cols = 3\n expected = 6\n assert expected == num_paths_matrix(rows, cols)\n assert expected == num_paths_matrix_recursive(rows, cols)\n"
},
{
"path": "python/dynamic/num_trees_preorder.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven the number of nodes N, in a pre-order sequence how many unique trees can be created? Number of tree is exactly\nsame as number of unique BST create with array of size n. The solution is a catalan number.\n\nComplexity\n----------\n* Dynamic Programming: O(n^2)\n* Recursive Solution: O(2^n)\n\nVideo\n-----\n* https://youtu.be/RUB5ZPfKcnY\n\"\"\"\n\n\ndef num_trees(num_nodes):\n T = [0 for _ in range(num_nodes + 1)]\n T[0] = 1\n T[1] = 1\n for n in range(2, num_nodes + 1):\n for j in range(0, n):\n T[n] += T[j] * T[n - j - 1]\n return T[num_nodes]\n\n\ndef num_trees_recursive(num_nodes):\n if num_nodes == 0 or num_nodes == 1:\n return 1\n\n result = 0\n\n for n in range(1, num_nodes + 1):\n result += num_trees_recursive(n - 1) * num_trees_recursive(num_nodes - n)\n\n return result\n\n\n\n\nif __name__ == '__main__':\n assert 5 == num_trees(3)\n assert 14 == num_trees(4)\n assert 42 == num_trees(5)\n assert 5 == num_trees_recursive(3)\n assert 14 == num_trees_recursive(4)\n assert 42 == num_trees_recursive(5)\n"
},
{
"path": "python/dynamic/optimal_bst.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven a sorted array keys[0.. n-1] of search keys and an array freq[0.. n-1] of frequency counts, where freq[i] is the\nnumber of searches to keys[i]. Construct a binary search tree of all keys such that the total cost of all the searches\nis as small as possible.\n\nVideo\n-----\n* https://youtu.be/hgA4xxlVvfQ\n\nAnalysis\n--------\n* Recursive: Exponential O(n^n)\n* Dynamic Programming: O(n^3)\n\nReference\n---------\n* http://www.geeksforgeeks.org/dynamic-programming-set-24-optimal-binary-search-tree/\n\"\"\"\n\n\ndef min_cost_bst(input_array, freq):\n size = rows = cols = len(input_array)\n T = [[0 for _ in range(cols)] for _ in range(rows)]\n\n for idx in range(rows):\n T[idx][idx] = freq[idx]\n\n for sub_tree_size in range(2, size + 1):\n for start in range(size + 1 - sub_tree_size):\n end = start + sub_tree_size - 1\n T[start][end] = float(\"inf\")\n total = sum(freq[start:end + 1])\n for k in range(start, end + 1):\n val = total + (0 if k - 1 < 0 else T[start][k - 1]) + (0 if k + 1 > end else T[k + 1][end])\n T[start][end] = min(val, T[start][end])\n\n return T[0][-1]\n\n\ndef min_cost_bst_recursive_helper(input_array, freq, low_index, high_index, level):\n if low_index > high_index:\n return 0\n min_value = float(\"inf\")\n\n for index in range(low_index, high_index + 1):\n val = (min_cost_bst_recursive_helper(input_array, freq, low_index, index - 1, level + 1) # left tree\n + level * freq[index] # value at level\n + min_cost_bst_recursive_helper(input_array, freq, index + 1, high_index, level + 1)) # right tree\n min_value = min(val, min_value)\n\n return min_value\n\n\ndef min_cost_bst_recursive(input_array, freq):\n return min_cost_bst_recursive_helper(input_array, freq, 0, len(input_array) - 1, 1)\n\n\nif __name__ == '__main__':\n input_array = [10, 12, 16, 21]\n freq = [4, 2, 6, 3]\n expected = 26\n assert expected == min_cost_bst(input_array, freq)\n assert expected == min_cost_bst_recursive(input_array, freq)\n input_array = [10, 12, 20, 35, 46]\n freq = [34, 8, 50, 21, 16]\n expected = 232\n assert expected == min_cost_bst(input_array, freq)\n assert expected == min_cost_bst_recursive(input_array, freq)\n"
},
{
"path": "python/dynamic/stockbuysellktransactions.py",
"content": "\"\"\"\"\nProblem Statement\n=================\n\nGiven certain stock values over a period of days (d days) and a number K, the number of transactions allowed, find the\nmaximum profit that be obtained with at most K transactions.\n\nVideo\n-----\n* https://youtu.be/oDhu5uGq_ic\n\nComplexity\n----------\n\n* Space Complexity O(days * transctions)\n* Time Complexity: Slow Solution O (days^2 * transactions), Faster Solution O(days * transaction)\n\"\"\"\n\n\ndef max_profit(prices, K):\n if K == 0 or prices == []:\n return 0\n\n days = len(prices)\n num_transactions = K + 1 # 0th transaction up to and including kth transaction is considered.\n\n T = [[0 for _ in range(days)] for _ in range(num_transactions)]\n\n for transaction in range(1, num_transactions):\n max_diff = - prices[0]\n for day in range(1, days):\n T[transaction][day] = max(T[transaction][day - 1], # No transaction\n prices[day] + max_diff) # price on that day with max diff\n max_diff = max(max_diff,\n T[transaction - 1][day] - prices[day]) # update max_diff\n\n print_actual_solution(T, prices)\n\n return T[-1][-1]\n\n\ndef max_profit_slow_solution(prices, K):\n if K == 0 or prices == []:\n return 0\n\n days = len(prices)\n num_transactions = K + 1\n\n T = [[0 for _ in range(len(prices))] for _ in range(num_transactions)]\n\n for transaction in range(1, num_transactions):\n for day in range(1, days):\n # This maximum value of either\n # a) No Transaction on the day. We pick the value from day - 1\n # b) Max profit made by selling on the day plus the cost of the previous transaction, considered over m days\n T[transaction][day] = max(T[transaction][day - 1],\n max([(prices[day] - prices[m] + T[transaction - 1][m]) for m in range(day)]))\n\n print_actual_solution(T, prices)\n return T[-1][-1]\n\n\ndef print_actual_solution(T, prices):\n transaction = len(T) - 1\n day = len(T[0]) - 1\n stack = []\n\n while True:\n if transaction == 0 or day == 0:\n break\n\n if T[transaction][day] == T[transaction][day - 1]: # Didn't sell\n day -= 1\n else:\n stack.append(day) # sold\n max_diff = T[transaction][day] - prices[day]\n for k in range(day - 1, -1, -1):\n if T[transaction - 1][k] - prices[k] == max_diff:\n stack.append(k) # bought\n transaction -= 1\n break\n\n for entry in range(len(stack) - 1, -1, -2):\n print(\"Buy on day {day} at price {price}\".format(day=stack[entry], price=prices[stack[transaction]]))\n print(\"Sell on day {day} at price {price}\".format(day=stack[entry], price=prices[stack[transaction - 1]]))\n\n\nif __name__ == '__main__':\n prices = [2, 5, 7, 1, 4, 3, 1, 3]\n assert 10 == max_profit(prices, 3)\n assert 10 == max_profit_slow_solution(prices, 3)\n"
},
{
"path": "python/dynamic/string_interleaving.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven three strings A, B and C. Write a function that checks whether C is an interleaving of A and B. C is said to be\ninterleaving A and B, if it contains all characters of A and B and order of all characters in individual strings is\npreserved.\n\nhttp://www.geeksforgeeks.org/check-whether-a-given-string-is-an-interleaving-of-two-other-given-strings-set-2/\n\nVideo: https://www.youtube.com/watch?v=ih2OZ9-M3OM\n\"\"\"\n\ndef is_interleaved_recursive(str1, str2, str3, pos1, pos2, pos3):\n if pos1 == len(str1) and pos2 == len(str2) and pos3 == len(str3):\n return True\n\n if pos3 == len(str3):\n return False\n\n return (((pos1 < len(str1) and str1[pos1] == str3[pos3]) and is_interleaved_recursive(str1, str2, str3, pos1 + 1, pos2, pos3 + 1)) or\n (pos2 < len(str2) and str2[pos2] == str3[pos3]) and is_interleaved_recursive(str1, str2, str3, pos1, pos2 + 1, pos3 + 1))\n\n\ndef is_interleaved(str1, str2, str3):\n if len(str3) != (len(str1) + len(str2)):\n return False\n\n cols = len(str1) + 1\n rows = len(str2) + 1\n\n T = [[False for _ in range(cols)] for _ in range(rows)]\n\n for row in range(rows):\n for col in range(cols):\n index = row + col - 1\n if row == 0 and col == 0:\n T[row][col] = True\n elif row == 0:\n if str3[index] == str1[col - 1]:\n T[row][col] = True and T[row][col - 1]\n elif col == 0:\n if str3[index] == str2[row - 1]:\n T[row][col] = True and T[row - 1][col]\n else:\n T[row][col] = ((T[row][col - 1] if str3[index] == str1[col - 1] else False) or\n (T[row - 1][col] if str3[index] == str2[row - 1] else False))\n\n return T[rows - 1][cols - 1]\n\n\nif __name__ == '__main__':\n str1 = \"XXYM\"\n str2 = \"XXZT\"\n str3 = \"XXXZXYTM\"\n\n assert True == is_interleaved(str1, str2, str3)\n assert True == is_interleaved_recursive(str1, str2, str3, 0, 0, 0)\n"
},
{
"path": "python/dynamic/sub_rectangular_maximum_sum.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nWrite a program to find maximum sum rectangle in give 2D matrix. Assume there is at least one positive number in the 2D\nmatrix.\n\nSolution:\n--------\n\n* Keep temp array with size as number of rows. Start left and right from 0 and keep adding values for each row and\n maintain them in this temp array.\n* Run Kadane's algorithm to find max sum subarray in temp. Now increment right by 1.\n* When right reaches last column reset right to 1 and left to 1.\n\nAnalysis\n--------\n* Space complexity of this algorithm is O(row)\n* Time complexity of this algorithm is O(row*col*col)\n\nVideo\n-----\n* https://youtu.be/yCQN096CwWM\n\nReferences\n----------\n* http://www.geeksforgeeks.org/dynamic-programming-set-27-max-sum-rectangle-in-a-2d-matrix/\n\"\"\"\n\nfrom collections import namedtuple\n\nResult = namedtuple(\"Result\",\"maxSum leftBound rightBound upBound lowBound\")\n\nKadanesResult = namedtuple(\"KadanesResult\",\"maxSum start end\")\n\n\ndef kadanes(temp):\n max = 0\n maxStart = -1\n maxEnd = -1\n currentStart = 0\n maxSoFar = 0\n\n for i in range(0, len(temp)):\n maxSoFar += temp[i]\n\n if maxSoFar < 0:\n maxSoFar = 0\n currentStart = i + 1\n\n if maxSoFar > max:\n maxStart = currentStart\n maxEnd = i\n max = maxSoFar\n\n return KadanesResult(max, maxStart, maxEnd)\n\n\ndef max_sub_sub_rectangle(rectangle):\n\n rows = len(rectangle)\n cols = len(rectangle[0])\n\n result = Result(float(\"-inf\"), -1, -1, -1, -1)\n\n for left in range(cols):\n temp = [0 for _ in range(rows)]\n for right in range(left, cols):\n for i in range(rows):\n temp[i] += rectangle[i][right]\n\n kadanes_result = kadanes(temp)\n if kadanes_result.maxSum > result.maxSum:\n result = Result(kadanes_result.maxSum, left, right, kadanes_result.start, kadanes_result.end)\n\n return result\n\nif __name__ == '__main__':\n rectangle = [[2, 1, -3, -4, 5],\n [0, 6, 3, 4, 1],\n [2, -2, -1, 4, -5],\n [-3, 3, 1, 0, 3]]\n\n result = max_sub_sub_rectangle(rectangle)\n assert 18 == result.maxSum\n print result\n"
},
{
"path": "python/dynamic/subset_sum.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven an array of non negative numbers and a total, is there subset of numbers in this array which adds up to given\ntotal. Another variation is given an array is it possible to split it up into 2 equal sum partitions. Partition need not\nbe equal sized. Just equal sum.\n\nVideo\n-----\n\n* https://youtu.be/s6FhG--P7z0\n\nSolution\n--------\n\n* Time complexity is O(input.size * total_sum)\n* Space complexity is O(input.size*total_sum)\n\nReference\n---------\n\n* https://en.wikipedia.org/wiki/Subset_sum_problem\n\"\"\"\n\n\ndef subset_sum(sequence, sum_value):\n cols = sum_value + 1 # Plus 1 for 0 valued col.\n rows = len(sequence) + 1 # Plus 1 for 0 valued row.\n T = [[False for _ in range(cols)] for _ in range(rows)]\n\n for row in range(rows):\n T[row][0] = True\n\n for index_i in range(1, rows):\n for index_j in range(1, cols):\n if index_j >= sequence[index_i - 1]:\n T[index_i][index_j] = T[index_i - 1][index_j] or T[index_i - 1][index_j - sequence[index_i - 1]]\n else:\n T[index_i][index_j] = T[index_i - 1][index_j]\n\n return T[rows - 1][cols - 1]\n\n\ndef partition(sequence):\n sequence_sum = sum(sequence)\n if sequence_sum % 2 != 0:\n return False\n\n expected = sequence_sum / 2\n\n return subset_sum(sequence, expected)\n\n\nif __name__ == '__main__':\n sequence = [2, 3, 7, 8]\n assert True == subset_sum(sequence, 11)\n\n sequence = [1, 3, 5, 5, 2, 1, 1, 6]\n assert True == partition(sequence)\n"
},
{
"path": "python/dynamic/symbolexpressionevaluation.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nLet there be a binary operation for 3 symbols a, b, c and result of these binary operation given in a table.\nGiven an expression of these 3 symbols and a final result, tell if this expression can be parenthesize in certain\nway to produce the final result.\n\nComplexity\n----------\n\n* Run time Complexity: O(n^3)\n* SpaceL O(n^2)\n\nWhere n is the length of the expression.\n\"\"\"\n\n\ndef evaluate_expression(expression_map, expression, result):\n expression_length = len(expression)\n T = [[set() for _ in range(expression_length)] for _ in range(len(expression))]\n\n for idx, expr in enumerate(expression):\n T[idx][idx].add(expr)\n\n # We take a sub expression of length 2 until the total expression length\n for sub_length in range(2, expression_length + 1):\n for left_index in range(0, expression_length - sub_length + 1):\n right_index = left_index + sub_length - 1\n # we split the expression at different k indices for the total sub-expression length and store the result.\n # at T[left_index][right_index]\n # Like bbc, will be treated for (b(bc) and ((bb) c) and the final result is stored in a set at T[0][2]\n for k in range(left_index, right_index):\n for expr1 in T[left_index][k]:\n for expr2 in T[k+1][right_index]:\n T[left_index][right_index].add(expression_map[(expr1, expr2)])\n\n for expr in T[0][-1]:\n if result in expr:\n return True\n\n return False\n\nif __name__ == '__main__':\n expressions = ['a', 'b', 'c']\n # expression table denotes the binary operation between two expression and its result.\n expression_table = [\n ['b', 'b', 'a'],\n ['c', 'b', 'a'],\n ['a', 'a', 'c']\n ]\n\n # For convenience, we can modify it to be more explicit and use the expression table\n\n expression_map = {\n ('a', 'a'): 'b',\n ('a', 'b'): 'b',\n ('a', 'c'): 'a',\n ('b', 'a'): 'c',\n ('b', 'b'): 'b',\n ('b', 'c'): 'a',\n ('c', 'a'): 'a',\n ('c', 'b'): 'a',\n ('c', 'c'): 'c'\n }\n\n assert True == evaluate_expression(expression_map, 'bbbbac', 'a')\n"
},
{
"path": "python/dynamic/weighted_job_scheduling_max_profit.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven set of jobs with start and end interval and profit, how to maximize profit such that jobs in subset do not\noverlap.\n\nVideo\n-----\n* https://youtu.be/cr6Ip0J9izc\n\nComplexity\n----------\n\n* Runtime Complexity: O(n^2)\n* Space Complexity: O(n)\n\nReference Link\n--------------\n* http://www.cs.princeton.edu/courses/archive/spr05/cos423/lectures/06dynamic-programming.pdf\n\"\"\"\n\n\ndef can_sequence(job1, job2):\n _, job1_finish_time = job1\n job2_start_time, _ = job2\n return job1_finish_time <= job2_start_time\n\n\ndef find_max_profit(jobs):\n sequenced_jobs = sorted(jobs.keys(), key=lambda x: x[1])\n T = [jobs[job_key] for job_key in sequenced_jobs]\n num_jobs = len(sequenced_jobs)\n\n for j in range(1, num_jobs):\n for i in range(0, j):\n if can_sequence(sequenced_jobs[i], sequenced_jobs[j]):\n T[j] = max(T[j], T[i] + jobs[sequenced_jobs[j]])\n\n return max(T)\n\n\nif __name__ == '__main__':\n jobs = {\n (1, 3): 5, # (start_time, end_time, total_cost)\n (2, 5): 6,\n (4, 6): 5,\n (6, 7): 4,\n (5, 8): 11,\n (7, 9): 2\n }\n\n assert 17 == find_max_profit(jobs)\n"
},
{
"path": "python/geometry/skylinedrawing.py",
"content": "# https://leetcode.com/problems/the-skyline-problem/\n\nclass BuildingPoint(object):\n\n def __init__(self, point, is_start, height):\n self.point = point;\n self.is_start = is_start\n self.height = height\n \n def __lt__(self, other):\n if self.point != other.point:\n return self.point < other.point\n else:\n if self.is_start:\n h1 = -self.height\n else:\n h1 = self.height\n\n if other.is_start:\n h2 = -other.height;\n else:\n h2 = other.height\n\n return h1 < h2\n \ndef get_skyline(buildings):\n\n building_points = []\n for building in buildings:\n building_points.append(BuildingPoint(building[0], True, building[2]))\n building_points.append(BuildingPoint(building[1], False, building[2]))\n\n building_points = sorted(building_points)\n\n queue = {}\n queue[0] = 1\n prev_max_height = 0\n result = []\n for building_point in building_points:\n if building_point.is_start:\n if building_point.height in queue:\n queue[building_point.height] = queue[building_point.height] + 1\n else:\n queue[building_point.height] = 1\n \n else:\n if queue[building_point.height] == 1:\n del queue[building_point.height]\n else:\n queue[building_point.height] = queue[building_point.height] - 1\n\n current_max_height = max(queue.keys())\n\n if prev_max_height != current_max_height:\n result.append([building_point.point, current_max_height])\n prev_max_height = current_max_height\n return result\n\nif __name__ == '__main__':\n buildings = [[1, 3, 4], [3, 4, 4], [2, 6, 2], [8, 11, 4], [7, 9, 3], [10, 11, 2]]\n print(get_skyline(buildings))\n \n"
},
{
"path": "python/graph/cycledirectedgraph.py",
"content": "# detect cycle in directed graph\n# https://github.com/mission-peace/interview/blob/master/src/com/interview/graph/CycleInDirectedGraph.java\n\nfrom graph import *\n\ndef has_cycle(graph):\n white = set()\n gray = set()\n black = set()\n\n for vertex in graph.all_vertex.values():\n white.add(vertex)\n\n while len(white) > 0:\n current = next(iter(white)) \n if dfs(current, white, gray, black) == True:\n return True\n\n return False \n\ndef dfs(current, white, gray, black):\n move_vertex(current, white, gray)\n for neighbor in current.adjacent_vertices:\n if neighbor in black:\n continue\n if neighbor in gray:\n return True\n if dfs(neighbor, white, gray, black) == True:\n return True\n \n move_vertex(current, gray, black)\n return False\n\ndef move_vertex(vertex, source_set, destination_set):\n source_set.remove(vertex)\n destination_set.add(vertex)\n \nif __name__ == '__main__':\n graph = Graph(True)\n graph.add_edge(1,2)\n graph.add_edge(1,3)\n graph.add_edge(2,3)\n graph.add_edge(4,1)\n graph.add_edge(4,5)\n graph.add_edge(5,6)\n graph.add_edge(6,4)\n\n print(has_cycle(graph));\n \n"
},
{
"path": "python/graph/cycleundirectedgraph.py",
"content": "# detect cycle in undirected graph\n# https://github.com/mission-peace/interview/blob/master/src/com/interview/graph/CycleUndirectedGraph.java\n\nfrom graph import *\nfrom disjointset import *\n\ndef has_cycle_dfs(graph):\n visited = set()\n for vertex in graph.all_vertex.values():\n if vertex in visited:\n continue\n flag = has_cycle_dfs_util(vertex, visited, None)\n if flag:\n return True\n return False \n\ndef has_cycle_dfs_util(vertex, visited, parent):\n visited.add(vertex)\n for adjacent in vertex.adjacent_vertices:\n if parent is not None and adjacent == parent:\n continue\n if adjacent in visited:\n return True\n has_cycle = has_cycle_dfs_util(adjacent, visited, vertex)\n if has_cycle:\n return True\n return False\n\ndef has_cycle_using_disjoint_set(graph):\n disjoint_set = DisjointSet()\n\n for vertex in graph.all_vertex.values():\n disjoint_set.make_set(vertex.id)\n\n for edge in graph.all_edges:\n parent1 = disjoint_set.find_set(edge.vertex1.id)\n parent2 = disjoint_set.find_set(edge.vertex2.id)\n if parent1 == parent2:\n return True\n disjoint_set.union(edge.vertex1.id, edge.vertex2.id)\n\n return False\n\n\nif __name__ == '__main__':\n graph = Graph(False)\n graph.add_edge(0,1)\n graph.add_edge(1,2)\n graph.add_edge(0,3)\n graph.add_edge(3,4)\n graph.add_edge(4,5)\n graph.add_edge(5,1)\n\n has_cycle1 = has_cycle_dfs(graph)\n has_cycle2 = has_cycle_using_disjoint_set(graph)\n print(str(has_cycle1) + \" \" + str(has_cycle2))\n \n"
},
{
"path": "python/graph/dijkstrashortestpath.py",
"content": "#dijkstra's algorithm\n\n# java code https://github.com/mission-peace/interview/blob/master/src/com/interview/graph/DijkstraShortestPath.java\n\nfrom priorityqueue import PriorityQueue\nfrom graph import Graph\nimport sys\n\n\ndef shortest_path(graph, sourceVertex):\n\n min_heap = PriorityQueue(True)\n distance = {}\n parent = {}\n\n for vertex in graph.all_vertex.values():\n min_heap.add_task(sys.maxsize, vertex)\n\n min_heap.change_task_priority(0, sourceVertex)\n distance[sourceVertex] = 0\n parent[sourceVertex] = None\n\n while min_heap.is_empty() is False:\n task = min_heap.peek_task()\n weight = min_heap.get_task_priority(task) \n current = min_heap.pop_task()\n distance[current] = weight\n\n for edge in current.edges:\n adjacent = get_other_vertex_for_edge(current, edge)\n if min_heap.contains_task(adjacent) is False:\n continue\n\n new_distance = distance[current] + edge.weight;\n if min_heap.get_task_priority(adjacent) > new_distance:\n min_heap.change_task_priority(new_distance, adjacent)\n parent[adjacent] = current\n \n\n return distance\n\n\ndef get_other_vertex_for_edge(vertex, edge):\n if edge.vertex1.id == vertex.id:\n return edge.vertex2\n else:\n return edge.vertex1\n\n\nif __name__ == '__main__':\n graph = Graph(False)\n graph.add_edge(1,2,5)\n graph.add_edge(2,3,2)\n graph.add_edge(1,4,9)\n graph.add_edge(1,5,3)\n graph.add_edge(5,6,2)\n graph.add_edge(6,4,2)\n graph.add_edge(3,4,3)\n \n distance = shortest_path(graph, graph.all_vertex[1])\n print(distance)\n"
},
{
"path": "python/graph/disjointset.py",
"content": "# disjoint sets\n# https://github.com/mission-peace/interview/blob/master/src/com/interview/graph/DisjointSet.java\n\nclass Node(object):\n\n def __init__(self, data, parent = None, rank = 0):\n self.data = data\n self.parent = parent\n self.rank = rank\n\n def __str__(self):\n return str(self.data)\n\n def __repr__(self):\n return self.__str__()\n\n\nclass DisjointSet(object):\n\n def __init__(self):\n self.map = {}\n\n def make_set(self, data):\n node = Node(data)\n node.parent = node\n self.map[data] = node\n\n def union(self, data1, data2):\n node1 = self.map[data1]\n node2 = self.map[data2]\n\n parent1 = self.find_set_util(node1)\n parent2 = self.find_set_util(node2)\n\n if parent1.data == parent2.data:\n return\n\n if parent1.rank >= parent2.rank:\n if parent1.rank == parent2.rank:\n parent1.rank = parent1.rank + 1\n parent2.parent = parent1\n else:\n parent1.parent = parent2\n\n def find_set(self, data):\n return self.find_set_util(self.map[data])\n\n def find_set_util(self, node):\n parent = node.parent\n if parent == node:\n return parent\n node.parent = self.find_set_util(node.parent)\n return node.parent\n\nif __name__ == '__main__':\n ds = DisjointSet()\n ds.make_set(1)\n ds.make_set(2)\n ds.make_set(3)\n ds.make_set(4)\n ds.make_set(5)\n ds.make_set(6)\n ds.make_set(7)\n\n ds.union(1,2)\n ds.union(2,3)\n ds.union(4,5)\n ds.union(6,7)\n ds.union(5,6)\n ds.union(3,7)\n\n for i in range(1,8):\n print(ds.find_set(i))\n \n \n \n \n"
},
{
"path": "python/graph/floydwarshall.py",
"content": "# floyd warshall all pair shortest path\n# java code https://github.com/mission-peace/interview/blob/master/src/com/interview/graph/FloydWarshallAllPairShortestPath.java\nimport sys\n\nINF = 1000000\n\nclass NegativeWeightCycleException(Exception):\n def __init__(self):\n pass\n\ndef all_pair_shortest_path(distance_matrix):\n\n size = len(distance_matrix)\n distance = [[0 for x in range(size)]\n for x in range (size)]\n \n path = [[0 for x in range(size)]\n for x in range (size)]\n\n for i in range(size):\n for j in range(size):\n distance[i][j] = distance_matrix[i][j]\n if distance_matrix[i][j] != INF and i != j:\n path[i][j] = i\n else:\n path[i][j] = -1\n\n\n for k in range(size):\n for i in range(size):\n for j in range(size):\n if distance[i][k] == INF or distance[k][j] == INF:\n continue\n if distance[i][j] > distance[i][k] + distance[k][j]:\n distance[i][j] = distance[i][k] + distance[k][j]\n path[i][j] = path[k][j]\n\n for i in range(size):\n if distance[i][i] < 0:\n raise NegativeWeightCycleException()\n\n print_path(path, 3, 2)\n return (distance, path)\n\ndef print_path(path, start, end):\n stack = []\n stack.append(end)\n while True:\n end = path[start][end]\n if end == -1:\n return\n stack.append(end)\n if end == start:\n break\n\n print(stack[::-1])\n\nif __name__ == '__main__':\n \n distance_matrix = [[0, 3, 6, 15],\n [INF, 0, -2, INF],\n [INF, INF, 0, 2],\n [1, INF, INF, 0]]\n\n distance, path = all_pair_shortest_path(distance_matrix)\n\n print(distance)\n #print(path)\n \n \n \n \n"
},
{
"path": "python/graph/fordfulkerson.py",
"content": "#ford fulkerson method Edomonds Karp algorithm for finding max flow\n# java code https://github.com/mission-peace/interview/blob/master/src/com/interview/graph/FordFulkerson.java\nfrom queue import Queue\nimport sys\n\ndef max_flow(capacity, source, sink):\n residual_capacity = [x[:] for x in capacity]\n augmented_paths = []\n max_flow = 0\n while True:\n found_augmented_path, parent = bfs(residual_capacity, source, sink)\n if not found_augmented_path:\n break\n augmented_path = []\n v = sink\n flow = sys.maxsize\n while not v == source:\n augmented_path.append(v)\n u = parent[v]\n if flow > residual_capacity[u][v]:\n flow = residual_capacity[u][v]\n v = u\n augmented_path.append(source)\n augmented_paths.append(augmented_path[::-1])\n max_flow += flow\n\n v = sink\n while not v == source:\n u = parent[v]\n residual_capacity[u][v] -= flow\n residual_capacity[v][u] += flow\n v = u\n\n print(\"Augmented path\")\n print(augmented_paths)\n return max_flow\n\ndef bfs(residual_capacity, source, sink):\n visited = set()\n queue = Queue()\n parent = {}\n queue.put(source)\n visited.add(source)\n found_augmented_path = False\n while not queue.empty():\n u = queue.get()\n for v in range(len(residual_capacity)):\n if v not in visited and residual_capacity[u][v] > 0:\n parent[v] = u\n visited.add(v)\n queue.put(v)\n if v == sink:\n found_augmented_path = True\n break;\n return found_augmented_path, parent \n\nif __name__ == '__main__':\n capacity = [[0, 3, 0, 3, 0, 0, 0],\n [0, 0, 4, 0, 0, 0, 0],\n [3, 0, 0, 1, 2, 0, 0],\n [0, 0, 0, 0, 2, 6, 0],\n [0, 1, 0, 0, 0, 0, 1],\n [0, 0, 0, 0, 0, 0, 9],\n [0, 0, 0, 0, 0, 0, 0]]\n\n max_val = max_flow(capacity, 0, 6)\n print(max_val)\n"
},
{
"path": "python/graph/graph.py",
"content": "#Graph class\n# Java code https://github.com/mission-peace/interview/blob/master/src/com/interview/graph/Graph.java\n\nclass Graph(object):\n\n def __init__(self, is_directed):\n self.all_edges = []\n self.all_vertex = {}\n self.is_directed = is_directed\n\n def add_edge(self, id1, id2, weight=0):\n if id1 in self.all_vertex:\n vertex1 = self.all_vertex[id1]\n else:\n vertex1 = Vertex(id1)\n self.all_vertex[id1] = vertex1\n\n if id2 in self.all_vertex:\n vertex2 = self.all_vertex[id2]\n else:\n vertex2 = Vertex(id2)\n self.all_vertex[id2] = vertex2\n\n edge = Edge(vertex1, vertex2, self.is_directed, weight)\n self.all_edges.append(edge)\n vertex1.add_adjacent_vertex(edge, vertex2)\n if self.is_directed is not True:\n vertex2.add_adjacent_vertex(edge,vertex1)\n\n \nclass Edge(object):\n \n def __init__(self, vertex1, vertex2, is_directed, weight):\n self.vertex1 = vertex1\n self.vertex2 = vertex2\n self.is_directed = is_directed\n self.weight = weight\n\n def __eq__(self, other):\n return self.vertex1.id == other.vertex1.id and self.vertex2.id == other.vertex2.id\n\n def __hash(self):\n return hash(vertex1) + hash(vertex2)\n \n def __str__(self):\n return \"Edge \" + str(self.vertex1) + \" \" + str(self.vertex2) + \" Weight-\" + str(self.weight)\n\n def __repr__(self):\n return self.__str__()\n \nclass Vertex(object):\n\n def __init__(self, id):\n self.id = id;\n self.edges = []\n self.adjacent_vertices = []\n\n def add_adjacent_vertex(self, edge, vertex):\n self.edges.append(edge)\n self.adjacent_vertices.append(vertex)\n\n def get_degree(self):\n return len(self.edges)\n\n def __eq__(self, other):\n return self.id == other.id\n\n def __hash__(self):\n return hash(self.id)\n\n def __str__(self):\n return str(\"Vertex-\" + str(self.id))\n\n def __repr__(self):\n return self.__str__();\n\n def __lt__(self, other):\n return self.id < other.id\n \n def __gt__(self, other):\n return self.id > other.id\n\nif __name__ == '__main__': \n g = Graph(False)\n g.add_edge(1,2,10)\n g.add_edge(2,3,5)\n g.add_edge(1,4,6)\n\n for edge in g.all_edges:\n print(edge)\n\n for vertex in g.all_vertex:\n print(\"Vertex \" + str(g.all_vertex[vertex]))\n for edge in g.all_vertex[vertex].edges:\n print(\"Edge \" + str(edge))\n\n"
},
{
"path": "python/graph/graphtraversal.py",
"content": "#doing BFS and DFS traversal of the graph\n# java code https://github.com/mission-peace/interview/blob/master/src/com/interview/graph/GraphTraversal.java\n\nfrom graph import *\nimport queue\n\ndef dfs_util(v, visited):\n if v in visited:\n return\n visited.add(v)\n print(v)\n for vertex in v.adjacent_vertices:\n dfs_util(vertex, visited)\n \ndef dfs(graph):\n visited = set()\n for id in graph.all_vertex:\n dfs_util(graph.all_vertex[id], visited)\n\ndef bfs(graph):\n q = queue.Queue()\n visited = set()\n for vertex in graph.all_vertex.values():\n if vertex not in visited:\n q.put(vertex)\n visited.add(vertex)\n while not q.empty():\n v = q.get();\n print(v)\n for adj in v.adjacent_vertices:\n if adj not in visited:\n q.put(adj)\n visited.add(adj)\n \n \nif __name__ == '__main__': \n g = Graph(False)\n g.add_edge(1,2,10)\n g.add_edge(2,3,5)\n g.add_edge(1,4,6)\n\n dfs(g)\n bfs(g)\n"
},
{
"path": "python/graph/kruskalmst.py",
"content": "# kruskal minimum spanning tree\n# java code https://github.com/mission-peace/interview/blob/master/src/com/interview/graph/KruskalMST.java\n\nfrom disjointset import *\nfrom graph import *\n\ndef get_key(edge):\n return edge.weight\n\ndef minimum_spanning_tree(graph):\n\n disjoint_set = DisjointSet()\n sorted_edges = sorted(graph.all_edges, key = get_key)\n print(sorted_edges)\n\n for vertex in graph.all_vertex.values():\n disjoint_set.make_set(vertex.id)\n\n result_edge = []\n\n for edge in sorted_edges:\n root1 = disjoint_set.find_set(edge.vertex1.id)\n root2 = disjoint_set.find_set(edge.vertex2.id)\n\n if root1 == root2:\n continue\n else:\n result_edge.append(edge)\n disjoint_set.union(edge.vertex1.id, edge.vertex2.id)\n\n return result_edge\n\nif __name__ == '__main__':\n graph = Graph(False)\n graph.add_edge(1,3,1)\n graph.add_edge(1,2,4)\n graph.add_edge(2,4,2)\n graph.add_edge(2,5,1)\n graph.add_edge(2,6,3)\n graph.add_edge(3,4,5)\n graph.add_edge(3,7,8)\n graph.add_edge(4,7,2)\n graph.add_edge(6,5,2)\n graph.add_edge(6,4,3)\n\n result = minimum_spanning_tree(graph)\n for edge in result:\n print(edge)\n \n"
},
{
"path": "python/graph/primmst.py",
"content": "#Prim's MST\n# Java code https://github.com/mission-peace/interview/blob/master/src/com/interview/graph/PrimMST.java\n\nfrom graph import Graph\nfrom priorityqueue import PriorityQueue\nimport sys\n\ndef minimum_spanning_tree(graph):\n\n min_heap = PriorityQueue(True)\n vertex_to_edge = {}\n result = []\n\n for vertex in graph.all_vertex.values():\n min_heap.add_task(sys.maxsize, vertex)\n \n start_vertex = next(iter((graph.all_vertex.values())))\n min_heap.change_task_priority(0, start_vertex)\n while min_heap.is_empty() is False:\n current = min_heap.pop_task()\n \n if(current in vertex_to_edge):\n spanning_tree_edge = vertex_to_edge[current]\n result.append(spanning_tree_edge)\n\n for edge in current.edges:\n adjacent = get_other_vertex_for_edge(current, edge)\n if min_heap.contains_task(adjacent) is True and min_heap.get_task_priority(adjacent) > edge.weight:\n min_heap.change_task_priority(edge.weight, adjacent)\n vertex_to_edge[adjacent] = edge\n \n return result\n\n\ndef get_other_vertex_for_edge(vertex, edge):\n if edge.vertex1.id == vertex.id:\n return edge.vertex2\n else:\n return edge.vertex1\n\nif __name__ == '__main__':\n graph = Graph(False)\n graph.add_edge(1,2,3)\n graph.add_edge(2,3,1)\n graph.add_edge(3,1,1)\n graph.add_edge(1,4,1)\n graph.add_edge(2,4,3)\n graph.add_edge(4,5,6)\n graph.add_edge(5,6,2)\n graph.add_edge(3,5,5)\n graph.add_edge(3,6,4)\n \n result = minimum_spanning_tree(graph)\n print(result) \n"
},
{
"path": "python/graph/priorityqueue.py",
"content": "# add to heapq things like removing any item and changing key value\n# implementation of priority queue to support contains, change_task_priority\n# and remove_task in log time\n\nfrom heapq import *\n\nclass PriorityQueue(object):\n \n def __init__(self, is_min_heap):\n self.pq = []\n self.entry_finder = {}\n if(is_min_heap is True):\n self.mul = 1\n else :\n self.mul = -1\n \n def contains_task(self, task):\n if task in self.entry_finder:\n return True\n else:\n return False\n\n def get_task_priority(self, task):\n if task in self.entry_finder:\n return (self.entry_finder[task])[0]\n raise ValueError(\"task does not exist\")\n \n def add_task(self, priority, task):\n if task in self.entry_finder:\n raise KeyError(\"Key already exists\")\n entry = [self.mul*priority, False, task]\n self.entry_finder[task] = entry\n heappush(self.pq, entry)\n\n def change_task_priority(self, priority, task):\n if task not in self.entry_finder:\n raise KeyError(\"Task not found\")\n self.remove_task(task)\n entry = [self.mul*priority, False, task]\n self.entry_finder[task] = entry\n heappush(self.pq, entry)\n \n def remove_task(self, task):\n entry = self.entry_finder.pop(task)\n entry[1] = True\n\n def pop_task(self):\n while self.pq:\n priority, removed, task = heappop(self.pq)\n if removed is False:\n del self.entry_finder[task]\n return task\n raise KeyError(\"pop from an empty priority queue\")\n\n def peek_task(self):\n while self.pq:\n priority, removed, task = tuple(heappop(self.pq))\n if removed is False:\n heappush(self.pq, [priority, False, task])\n return task\n raise KeyError(\"pop from an empty priority queue\")\n\n def is_empty(self):\n try:\n self.peek_task()\n return False\n except KeyError:\n return True\n\n def __str__(self):\n return str(self.entry_finder) + \" \" + str(self.pq)\n \n\nif __name__ == '__main__':\n task1 = \"Tushar\"\n task2 = \"Roy\"\n task3 = \"is\"\n task4 = \"coder\"\n\n min_pq = PriorityQueue(True)\n min_pq.add_task(1, task1)\n min_pq.add_task(3, task2)\n min_pq.add_task(6, task3)\n min_pq.add_task(7, task4)\n print(min_pq.contains_task(task3))\n print(min_pq.get_task_priority(task3))\n print(min_pq)\n while min_pq.is_empty() is False:\n print(min_pq.pop_task())\n\n max_pq = PriorityQueue(False)\n max_pq.add_task(1, task1)\n max_pq.add_task(3, task2)\n max_pq.add_task(6, task3)\n max_pq.add_task(7, task4)\n while max_pq.is_empty() is False:\n print(max_pq.pop_task())\n\n \n"
},
{
"path": "python/graph/topologicalsort.py",
"content": "#topological sort\n# java code https://github.com/mission-peace/interview/blob/master/src/com/interview/graph/TopologicalSort.java\n\nfrom graph import Graph\n\ndef top_sort(graph):\n stack = []\n visited = set()\n for vertex in graph.all_vertex.values():\n if vertex in visited:\n continue\n top_sort_util(vertex, stack, visited)\n return stack\n\ndef top_sort_util(vertex, stack, visited):\n visited.add(vertex)\n for adjacent in vertex.adjacent_vertices:\n if adjacent in visited:\n continue\n top_sort_util(adjacent, stack, visited)\n stack.append(vertex)\n\nif __name__ == '__main__':\n graph = Graph(True)\n graph.add_edge(1,3)\n graph.add_edge(1,2)\n graph.add_edge(3,4)\n graph.add_edge(5,6)\n graph.add_edge(6,3)\n graph.add_edge(3,8)\n graph.add_edge(8,11)\n\n stack = top_sort(graph)\n\n print(stack[::-1])\n\n \n \n"
},
{
"path": "python/recursion/setpairtogether.py",
"content": "# http://www.geeksforgeeks.org/minimum-number-of-swaps-required-for-arranging-pairs-adjacent-to-each-other/\n\ndef find_minimum_swaps(input, pair):\n index = {}\n for i, val in enumerate(input):\n index[val] = i\n return find_minimum_swaps_util(input, pair, index, 0)\n\ndef find_minimum_swaps_util(input, pair, index, current):\n if current == len(input):\n return 0\n\n v1 = input[current]\n v2 = input[current + 1]\n pv2 = pair[v1]\n\n if pv2 == v2:\n return find_minimum_swaps_util(input, pair, index, current + 2)\n else:\n idx1 = index.get(v1)\n idx2 = index.get(v2)\n idx3 = index.get(pair[v1])\n idx4 = index.get(pair[v2])\n\n swap(index, input, idx2, idx3)\n val1 = find_minimum_swaps_util(input, pair, index, current+2)\n swap(index, input, idx2, idx3)\n\n swap(index, input, idx1, idx4)\n val2 = find_minimum_swaps_util(input, pair, index, current+2)\n swap(index, input, idx1, idx4)\n\n return 1 + max(val1, val2)\n \n\ndef swap(index, input, i, j):\n index[input[i]] = j\n index[input[j]] = i\n t = input[i]\n input[i] = input[j]\n input[j] = t\n\nif __name__ == '__main__':\n input = [3, 5, 6, 4, 1, 2]\n pair = {}\n pair[1] = 3\n pair[3] = 1\n pair[2] = 6\n pair[6] = 2\n pair[4] = 5\n pair[5] = 4\n\n print(find_minimum_swaps(input, pair))\n \n"
},
{
"path": "python/recursion/stringpermutation.py",
"content": "# string permutation in lexicographically order with repetition of characters in the string\n\ndef permute(input):\n count_map = {}\n for ch in input:\n if ch in count_map.keys():\n count_map[ch] = count_map[ch] + 1\n else:\n count_map[ch] = 1\n\n keys = sorted(count_map)\n str = []\n count = []\n for key in keys:\n str.append(key)\n count.append(count_map[key])\n result = [0 for x in range(len(input))]\n permute_util(str, count, result, 0)\n\ndef permute_util(str, count, result, level):\n if level == len(result):\n print(result)\n return\n\n for i in range(len(str)):\n if count[i] == 0:\n continue;\n result[level] = str[i]\n count[i] -= 1\n permute_util(str, count, result, level + 1)\n count[i] += 1\n\nif __name__ == '__main__':\n input = ['B', 'C', 'A', 'A']\n permute(input)\n"
},
{
"path": "python/string/Z_Algorithm.py",
"content": "#author: Pankaj Kumar\n\n#time complexity: O(length(string) + length(pattern))\n\n#space complexity: O(length(string) + length(pattern))\n\n#Link to theory: http://www.geeksforgeeks.org/z-algorithm-linear-time-pattern-searching-algorithm/\n\ndef z_algo(arr):\n z = [0 for i in range(len(arr))]\n left , right = 0 , 0\n for k in range(1 , len(arr)):\n if k > right:\n left = k\n right = k\n while right < len(arr) and arr[right] == arr[right-left]:\n right += 1\n z[k] = right - left\n right -= 1\n else:\n k1 = k - left\n if z[k1] < right - k + 1:\n z[k] = z[k1]\n else:\n left = k\n while right < len(arr) and arr[right] == arr[right-left]:\n right += 1\n z[k] = right - left\n right -= 1\n return z\n \n \ndef makepattern(string , pattern):\n n , m = len(string) , len(pattern)\n str_arr = []\n for i in range(m):\n str_arr.append(pattern[i])\n str_arr.append('$')\n for i in range(n):\n str_arr.append(string[i])\n \n z_values = z_algo(str_arr)\n result = []\n for i in range(len(z_values)):\n if z_values[i] == m:\n result.append(i - m - 1)\n print result\n\n\n\nif __name__ == '__main__':\n string = 'abcdeabcd'\n pattern = 'abc'\n makepattern(string , pattern)\n"
},
{
"path": "python/string/knuthmorrispratt.py",
"content": "# Knuth-Morris-Pratt algorithm \n\n\n# Compute temporary array to maintain size of suffix which is same as prefix\n# Time/space complexity is O(size of pattern)\ndef compute_temporary_array(pattern):\n n = len(pattern)\n lsp = [0 for j in range(n)]\n index = 0\n i = 1\n while i < len(pattern):\n if pattern[i] == pattern[index]:\n lsp[i] = index + 1\n index += 1\n i += 1\n else:\n if index != 0:\n index = lsp[index - 1]\n else:\n lsp[i] = 0\n i += 1\n return lsp\n\n\n# KMP algorithm of pattern matching.\ndef kmp(text, pattern):\n lsp = compute_temporary_array(pattern)\n i = 0\n j = 0\n while i < len(text) and j < len(pattern):\n if text[i] == pattern[j]:\n i += 1\n j += 1\n else:\n if j != 0:\n j = lsp[j - 1]\n else:\n i += 1\n if j == len(pattern):\n return True\n else:\n return False\n\nsrc = 'abcxabcdabcdabcy'\nsub_string = 'abcdabcy'\nresult = kmp(src, sub_string)\nprint(result)\n\n\n"
},
{
"path": "python/string/rabinkarp.py",
"content": "#Rabin Karp algorithm\n# Java code https://github.com/mission-peace/interview/blob/master/src/com/interview/string/RabinKarpSearch.java\n\nprime = 101\ndef pattern_matching(text, pattern):\n m = len(pattern)\n n = len(text)\n pattern_hash = create_hash(pattern, m - 1)\n text_hash = create_hash(text, m - 1)\n\n for i in range(1, n - m + 2):\n if pattern_hash == text_hash:\n if check_equal(text[i-1:i+m-1], pattern[0:]) is True:\n return i - 1;\n if i < n - m + 1: \n text_hash = recalculate_hash(text, i-1, i+m-1, text_hash, m)\n return -1;\n \ndef check_equal(str1, str2):\n if len(str1) != len(str2):\n return False;\n i = 0\n j = 0\n for i, j in zip(str1, str2):\n if i != j:\n return False;\n return True\n \ndef create_hash(input, end):\n hash = 0\n for i in range(end + 1):\n hash = hash + ord(input[i])*pow(prime, i)\n return hash\n\ndef recalculate_hash(input, old_index, new_index, old_hash, pattern_len):\n new_hash = old_hash - ord(input[old_index])\n new_hash = new_hash/prime\n new_hash += ord(input[new_index])*pow(prime, pattern_len - 1)\n return new_hash;\n\n\nindex = pattern_matching(\"TusharRoy\", \"sharRoy\")\nprint(\"Index \", index)\nindex = pattern_matching(\"TusharRoy\", \"Roy\")\nprint(\"Index \", index)\nindex = pattern_matching(\"TusharRoy\", \"shar\")\nprint(\"Index \", index)\nindex = pattern_matching(\"TusharRoy\", \"usha\")\nprint(\"Index \", index)\nindex = pattern_matching(\"TusharRoy\", \"Tus\")\nprint(\"Index \", index)\nindex = pattern_matching(\"TusharRoy\", \"Roa\")\nprint(\"Index \", index)\n"
},
{
"path": "python/tree/binary_tree.py",
"content": "from collections import namedtuple\n\nColor = namedtuple(\"Color\", \"RED BLACK\")\n\n\nclass Node:\n def __init__(self):\n self.color = None\n self.height = None\n self.lis = None\n self.data = None\n self.size = None\n self.next = None\n self.right = None\n self.left = None\n\n @staticmethod\n def newNode(data):\n n = Node()\n n.data = data\n n.lis = -1\n n.height = 1\n n.size = 1\n n.color = Color.RED\n return n\n\n\nclass BinaryTree:\n\n def __init__(self):\n pass\n\n @staticmethod\n def add_head(data, head):\n temp_head = head\n n = Node.newNode(data)\n\n if head is None:\n head = n\n return head\n\n prev = None\n\n while head is not None:\n prev = head\n if head.data < data:\n head = head.right\n else:\n head = head.left\n\n if prev.data < data:\n prev.right = n\n else:\n prev.left = n\n\n return temp_head\n"
},
{
"path": "python/tree/construct_tree_from_inorder_preorder.py",
"content": "from binary_tree import Node\n\n\nclass ConstructTreeFromInorderPreOrder:\n def __init__(self):\n self.index = 0\n\n def _createTree(self, inorder, preorder, start, end):\n if start > end:\n return None\n i = 0\n for i in range(start, end + 1):\n if preorder[self.index] == inorder[i]:\n break\n\n node = Node.newNode(preorder[self.index])\n self.index += 1\n node.left = self._createTree(inorder, preorder, start, i - 1)\n node.right = self._createTree(inorder, preorder, i + 1, end)\n return node\n\n def createTree(self, inorder, preorder):\n return self._createTree(inorder, preorder, 0, len(inorder) - 1)\n"
},
{
"path": "python/tree/fenwick_tree.py",
"content": "#################################################################################################################################\n#Implementation of Binary Indexed Tree OR Fenwick Tree\n#Time Complexities:\n#\tConstruction of Tree: O (n.log (n))\n#\tUpdating an element: O (log (n))\n#\tPrefix Query (sum of elements 0 to i) or Range Minimum Query (sum of elements x to y): O (log (n))\n#Space Complexity: O (n)\n#################################################################################################################################\n\nclass FenTree (object):\n\tdef __init__ (self, array):\n\t\tself.array, self.tree = [0] * len (array), [0] * (len (array) + 1);\n\t\tfor i in range (len (array)):\n\t\t\tself.update (i, array [i]);\n\n\tdef get_parent (self, child):\n\t\treturn (child - (child & -child));\n\n\tdef get_next (self, index):\n\t\treturn (index + (index & -index));\n\n\tdef update (self, index, item):\n\t\tcurrent, self.array [index] = self.array [index], item;\n\t\titem -= current;\n\t\tindex += 1;\n\t\twhile (index <= len (self.array)):\n\t\t\tself.tree [index] += item;\n\t\t\tindex = self.get_next (index);\n\n\tdef prefix_sum (self, index):\n\t\tindex += 1;\n\t\ttotal = 0;\n\t\twhile (index > 0):\n\t\t\ttotal += self.tree [index];\n\t\t\tindex = self.get_parent (index);\n\t\treturn (total);\n\n\tdef range_sum (self, x, y):\n\t\treturn (self.prefix_sum (max (x, y)) - self.prefix_sum (min (x, y) - 1));\n\n\tdef describe (self):\n\t\tprint ('ARRAY =>\\t', self.array);\n\t\tprint ('Binary Indexed Tree =>\\t', self.tree);\n\nif (__name__ == '__main__'):\n\ttree = FenTree ([3,2,-1,6,5,4]);\n#\ttree = FenTree ([int (i) for i in input ('Enter the array (space-separated integers): ').split ()]);\n\ttree.describe ();\n\n\ttree.update (4, 8);\t#replaces 5 with 8 in the list given to the fenwick tree\n\ttree.describe ();\n\n\tprint (tree.range_sum (1, 5));\t#returns 2-1+6+5+4\n\tprint (tree.prefix_sum (5));\t#returns 3+2-1+6+5+4\n"
},
{
"path": "python/tree/largest_bst_in_binary_tree.py",
"content": "\"\"\" Given a binary tree, find size of largest binary search subtree in this binary tree.\n\nApproach\n--------\n\nTraverse tree in post order fashion. Left and right nodes return 4 piece of information to root which isBST, size of max\nBST, min and max in those subtree.\n\nIf both left and right subtree are BST and this node data is greater than max of left and less than min of right then it\nreturns to above level left size + right size + 1 and new min will be min of left side and new max will be max of right\nside.\n\nVideo link\n----------\n* https://youtu.be/4fiDs7CCxkc\n\nReferences\n----------\n* http://www.geeksforgeeks.org/find-the-largest-subtree-in-a-tree-that-is-also-a-bst/\n* https://leetcode.com/problems/largest-bst-subtree/\n* http://www.geeksforgeeks.org/construct-tree-from-given-inorder-and-preorder-traversal/\n\"\"\"\n\nfrom construct_tree_from_inorder_preorder import ConstructTreeFromInorderPreOrder\n\nclass MinMax:\n\n def __init__(self):\n self.min = float(\"inf\")\n self.max = float(\"-inf\")\n self.isBST = True\n self.size = 0\n\n\nclass LargestBSTBinaryTree:\n\n def largestBST(self, root):\n m = self.largest(root)\n return m.size\n\n def largest(self, root):\n\n if root is None:\n return MinMax()\n\n leftMinMax = self.largest(root.left)\n rightMinMax = self.largest(root.right)\n\n m = MinMax()\n\n if ((leftMinMax.isBST == False or rightMinMax.isBST == False)\n or (leftMinMax.max > root.data or rightMinMax.min <= root.data)):\n\n m.isBST = False\n m.size = max(leftMinMax.size, rightMinMax.size)\n return m\n\n m.isBST = True\n m.size = leftMinMax.size + rightMinMax.size + 1\n m.min = leftMinMax.min if root.left is not None else root.data\n m.max = rightMinMax.max if root.right is not None else root.data\n return m\n\n\nif __name__ == '__main__':\n lbi = LargestBSTBinaryTree()\n ctf = ConstructTreeFromInorderPreOrder()\n inorder = [-7, -6, -5, -4, -3, -2, 1, 2, 3, 16, 6, 10, 11, 12, 14]\n preorder = [3, -2, -3, -4, -5, -6, -7, 1, 2, 16, 10, 6, 12, 11, 14]\n root = ctf.createTree(inorder, preorder)\n largestBSTSize = lbi.largestBST(root)\n print \"Size of the largest BST in the Binary Tree is \", largestBSTSize\n assert 8 == lbi.largestBST(root)\n"
},
{
"path": "python/tree/max_depth_binary_tree.py",
"content": "\"\"\"\nProblem Statement\n=================\n\nGiven a binary tree, write a program to find the maximum depth at any given node.\n\nFor e.g, for this binary tree.\n\n 1\n / \\\n2 3\n / \\\n 4 5\n\nThe height at 1 is 3, and the height at 3 is 2.\n\n\"\"\"\n\nclass Node:\n def __init__(self, value):\n self.value = value\n self.left = None\n self.right = None\n\n\nn1 = Node(1)\nn2 = Node(2)\nn3 = Node(3)\nn4 = Node(4)\nn5 = Node(5)\n\n# construct the tree as given in the problem.\n\nn1.left = n2\nn1.right = n3\nn3.left = n4\nn3.right = n5\n\n\ndef find_max_depth(n):\n if n is None:\n return 0\n left_height = find_max_depth(n.left)\n right_height = find_max_depth(n.right)\n if left_height > right_height:\n result = left_height + 1\n else:\n result = right_height + 1\n return result\n\n\nif __name__ == '__main__':\n assert 3 == find_max_depth(n1)\n assert 2 == find_max_depth(n3)\n"
},
{
"path": "python/tree/morris_traversal.py",
"content": "\"\"\"Morris Traversal of a Binary Tree.\n\nVideo\n-----\n\n* https://youtu.be/wGXB9OWhPTg\n\nAnalysis\n--------\n\n* Time complexity O(n)\n* Space complexity O(1)\n\n\"\"\"\n\nfrom binary_tree import BinaryTree\n\n\nclass MorrisTraversal:\n\n def __init__(self):\n pass\n\n @staticmethod\n def find_predecessor(current):\n predecessor = current.left\n while predecessor.right != current and predecessor.right is not None:\n predecessor = predecessor.right\n return predecessor\n\n @staticmethod\n def inorder(root_node):\n current = root_node\n while current is not None:\n if current.left is None:\n print \"{data} \".format(data=current.data),\n current = current.right\n else:\n predecessor = MorrisTraversal.find_predecessor(current)\n\n if predecessor.right is None:\n predecessor.right = current\n current = current.left\n else:\n predecessor.right = None\n print \"{data} \".format(data=current.data),\n current = current.right\n\n @staticmethod\n def preorder(root_node):\n current = root_node\n while current is not None:\n if current.left is None:\n print \"{data} \".format(data=current.data),\n current = current.right\n else:\n predecessor = MorrisTraversal.find_predecessor(current)\n\n if predecessor.right is None:\n print \"{data} \".format(data=current.data),\n predecessor.right = current\n current = current.left\n else:\n predecessor.right = None\n current = current.right\n\n\nif __name__ == '__main__':\n bt = BinaryTree()\n root = None\n root = bt.add_head(10, root)\n root = bt.add_head(50, root)\n root = bt.add_head(-10, root)\n root = bt.add_head(7, root)\n root = bt.add_head(9, root)\n root = bt.add_head(-20, root)\n root = bt.add_head(30, root)\n\n mt = MorrisTraversal()\n mt.inorder(root)\n print \"\\n\",\n mt.preorder(root)\n"
},
{
"path": "python/tree/segmenttreesum.py",
"content": "def create_segment_tree(input):\n size = next_power_of_2(len(input));\n segment_tree = [0 for x in range(2*size - 1)]\n construct_tree(segment_tree, input, 0, len(input) - 1, 0)\n return segment_tree\n\ndef construct_tree(segment_tree, input, low, high, pos):\n if low == high:\n segment_tree[pos] = input[low]\n return\n\n mid = (low + high)/2\n construct_tree(segment_tree, input, low, mid, 2*pos + 1)\n construct_tree(segment_tree, input, mid + 1, high, 2*pos + 2)\n segment_tree[pos] = segment_tree[2*pos+1] + segment_tree[2*pos+2]\n\ndef sum_range_query(segment_tree, q_low, q_high, len):\n return sum_range_query_util(segment_tree, 0, len - 1, q_low, q_high, 0)\n\ndef sum_range_query_util(segment_tree, low, high, q_low, q_high, pos):\n if q_low <= low and q_high >= high:\n return segment_tree[pos]\n\n if q_high < low or q_low > high:\n return 0\n\n mid = (low + high)/2\n return sum_range_query_util(segment_tree, low, mid, q_low, q_high, 2*pos + 1)\\\n + sum_range_query_util(segment_tree, mid + 1, high, q_low, q_high, 2*pos + 2)\n\ndef update_value(input, segment_tree, new_value, index):\n diff = new_value - input[index]\n input[index] = new_value\n update_value_util(segment_tree, 0, len(input)-1, diff, index, 0)\n\ndef update_value_util(segment_tree, low, high, diff, index, pos):\n if low > index or high < index:\n return\n segment_tree[pos] += diff\n\n if low >= high:\n return\n mid = (low + high)/2\n update_value_util(segment_tree, low, mid, diff, index, 2*pos + 1)\n update_value_util(segment_tree, mid + 1, high, diff, index, 2*pos + 2)\n\n\ndef next_power_of_2(n):\n if n == 0:\n return 1\n if n & (n - 1) == 0:\n return n\n while n & (n - 1) > 0:\n n &= (n - 1)\n\n return n << 1\n\nif __name__ == '__main__':\n input = [1,3,5,7,9,11]\n segment_tree = create_segment_tree(input)\n print(segment_tree)\n print(sum_range_query(segment_tree, 2, 5, len(input)))\n print(sum_range_query(segment_tree, 1, 3, len(input)))\n update_value(input, segment_tree, 4, 3)\n print(sum_range_query(segment_tree, 2, 5, len(input)))\n print(sum_range_query(segment_tree, 1, 3, len(input)))\n\n\n"
},
{
"path": "src/com/interview/array/AdditiveNumber.java",
"content": "package com.interview.array;\n\nimport java.math.BigInteger;\n\n/**\n * Date 04/24/2016\n * @author Tushar Roy\n *\n * Additive number is a string whose digits can form additive sequence.\n * A valid additive sequence should contain at least three numbers.\n * Except for the first two numbers, each subsequent number in the sequence must be the sum of the preceding two.\n *\n * https://leetcode.com/problems/additive-number/\n */\npublic class AdditiveNumber {\n\n public boolean isAdditiveNumber(String num) {\n if (num.length() < 3) {\n return false;\n }\n for (int i = 0; i <= num.length()/2; i++) {\n if (num.charAt(0) == '0' && i > 0) {\n break;\n }\n BigInteger x1 = new BigInteger(num.substring(0, i + 1));\n //make sure remaining size is at least size of first and second integer.\n for (int j = i + 1; Math.max(i, j - (i + 1)) + 1 <= num.length() - j - 1 ; j++) {\n if (num.charAt(i + 1) == '0' && j > i + 1) {\n break;\n }\n BigInteger x2 = new BigInteger(num.substring(i + 1, j + 1));\n if (isValid(num, j + 1, x1, x2)) {\n return true;\n }\n }\n }\n return false;\n }\n\n private boolean isValid(String num, int start, BigInteger x1, BigInteger x2) {\n if (start == num.length()) {\n return true;\n }\n BigInteger x3 = x1.add(x2);\n //if num starts with x3 from offset start means x3 is found. So look for next number.\n return num.startsWith(x3.toString(), start) && isValid(num, start + x3.toString().length(), x2, x3);\n }\n}\n"
},
{
"path": "src/com/interview/array/ArrayAddition.java",
"content": "package com.interview.array;\n\npublic class ArrayAddition {\n\n public int[] add(int arr1[], int arr2[]){\n int l = Math.max(arr1.length, arr2.length);\n int[] result = new int[l];\n int c=0;\n int i = arr1.length-1;\n int j= arr2.length-1;\n int r=0;\n l--;\n while(i >=0 && j >=0){\n r = arr1[i--] + arr2[j--] + c;\n c = r/10;\n result[l--] = r%10;\n }\n while(i>=0){\n r = arr1[i--] + c;\n c = r/10;\n result[l--] = r%10;\n }\n while(j>=0){\n r = arr2[j--] + c;\n c = r/10;\n result[l--] = r%10;\n }\n if(c != 0){\n int[] newResult = new int[result.length+1];\n for(int t= newResult.length-1; t> 0; t--){\n newResult[t] = result[t-1];\n }\n newResult[0] = c;\n return newResult;\n }\n return result;\n }\n \n public static void main(String args[]){\n \n int arr1[] = {9,9,9,9,9,9,9};\n int arr2[] = {1,6,8,2,6,7};\n ArrayAddition aa = new ArrayAddition();\n int result[] = aa.add(arr1, arr2);\n for(int i=0; i < result.length; i++){\n System.out.print(\" \" + result[i]);\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/BestMeetingPoint.java",
"content": "package com.interview.array;\n\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.List;\n\n/**\n * Date 03/24/2016\n * @author Tushar Roy\n *\n * A group of two or more people wants to meet and minimize the total travel distance.\n * You are given a 2D grid of values 0 or 1, where each 1 marks the home of someone in the group.\n * The distance is calculated using Manhattan Distance, where distance(p1, p2) = |p2.x - p1.x| + |p2.y - p1.y|.\n * Find the total distance that needs to be travelled to reach this meeting point.\n *\n * Time complexity O(m*n)\n * Space complexity O(m + n)\n *\n * https://leetcode.com/problems/best-meeting-point/\n */\npublic class BestMeetingPoint {\n public int minTotalDistance(int[][] grid) {\n if (grid.length == 0 || grid[0].length == 0) {\n return 0;\n }\n List vertical = new ArrayList<>();\n List horizontal = new ArrayList<>();\n\n for (int i = 0; i < grid.length; i++) {\n for (int j = 0; j < grid[0].length; j++) {\n if (grid[i][j] == 1) {\n vertical.add(i);\n horizontal.add(j);\n }\n }\n }\n\n Collections.sort(vertical);\n Collections.sort(horizontal);\n\n int size = vertical.size()/2;\n int x = vertical.get(size);\n int y = horizontal.get(size);\n int distance = 0;\n for (int i = 0; i < grid.length; i++) {\n for (int j = 0; j < grid[0].length; j++) {\n if (grid[i][j] == 1) {\n distance += Math.abs(x - i) + Math.abs(y - j);\n }\n }\n }\n\n return distance;\n }\n\n public static void main(String args[]) {\n BestMeetingPoint bmp = new BestMeetingPoint();\n int[][] grid = {{1, 0, 0, 0, 1}, {0, 0, 0, 0, 0},{0, 0, 1, 0, 0}};\n System.out.print(bmp.minTotalDistance(grid));\n }\n}\n"
},
{
"path": "src/com/interview/array/BuySellStockProfit.java",
"content": "package com.interview.array;\n\n/**\n * Date 03/04/2016\n * @author Tushar Roy\n *\n * Best time to buy and sell stocks.\n * 1) Only 1 transaction is allowed\n * 2) Infinite number transactions are allowed\n *\n * Time complexity O(n)\n * Space complexity O(1)\n *\n * https://leetcode.com/problems/best-time-to-buy-and-sell-stock/\n * https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/\n */\npublic class BuySellStockProfit {\n\n public int oneProfit(int arr[]){\n int minPrice = arr[0];\n int maxProfit = 0;\n for(int i=1; i < arr.length; i++){\n if(arr[i] - minPrice > maxProfit){\n maxProfit = arr[i] - minPrice;\n }\n if(arr[i] < minPrice){\n minPrice = arr[i];\n }\n }\n return maxProfit;\n }\n \n public int allTimeProfit(int arr[]){\n int profit = 0;\n for(int i=1; i < arr.length;i++){\n if(arr[i-1] < arr[i]){\n profit += arr[i] - arr[i-1];\n }\n }\n return profit;\n }\n \n public static void main(String args[]){\n int arr[] = {7,10,15,5,11,2,7,9,3};\n int arr1[] = {6,4,1,3,5,7,3,1,3,4,7,9,2,5,6,0,1,2};\n BuySellStockProfit bss = new BuySellStockProfit();\n System.out.println(bss.oneProfit(arr));\n System.out.print(bss.allTimeProfit(arr1));\n \n }\n}\n"
},
{
"path": "src/com/interview/array/CheckIfArrayElementsAreConsecutive.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/check-if-array-elements-are-consecutive/\n */\npublic class CheckIfArrayElementsAreConsecutive {\n\n public boolean areConsecutive(int input[]){\n int min = Integer.MAX_VALUE;\n for(int i=0; i < input.length; i++){\n if(input[i] < min){\n min = input[i];\n }\n }\n for(int i=0; i < input.length; i++){\n if(Math.abs(input[i]) - min >= input.length){\n return false;\n }\n if(input[Math.abs(input[i]) - min] < 0){\n return false;\n }\n input[Math.abs(input[i]) - min] = -input[Math.abs(input[i]) - min];\n }\n for(int i=0; i < input.length ; i++){\n input[i] = Math.abs(input[i]);\n }\n return true;\n }\n \n public static void main(String args[]){\n int input[] = {76,78,76,77,73,74};\n CheckIfArrayElementsAreConsecutive cia = new CheckIfArrayElementsAreConsecutive();\n System.out.println(cia.areConsecutive(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/ChunkMerge.java",
"content": "package com.interview.array;\n\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\nimport java.util.PriorityQueue;\n\n/**\n * Given a list of lists. Each element in the list is sorted. Sort the \n * entire list.\n * Test cases\n * One or more lists are empty\n * All elements in one list are smaller than all elements in another list\n */\npublic class ChunkMerge {\n \n class Triplet implements Comparable{\n int pos;\n int val;\n int index;\n @Override\n public int compareTo(Triplet o) {\n if(val <= o.val){\n return -1;\n }else{\n return 1;\n }\n }\n }\n \n public List mergeUsingHeap(List> chunks){\n List result = new ArrayList();\n PriorityQueue queue = new PriorityQueue();\n //add first element of every chunk into queue\n for(int i=0; i < chunks.size(); i++){\n Triplet p = new Triplet();\n p.pos = i;\n p.val = chunks.get(i).get(0);\n p.index = 1;\n queue.add(p);\n }\n \n while(!queue.isEmpty()){\n Triplet p = queue.poll();\n result.add(p.val);\n if(p.index < chunks.get(p.pos).size()){\n p.val = chunks.get(p.pos).get(p.index);\n p.index += 1;\n queue.add(p);\n }\n }\n return result;\n }\n \n public List mergeChunksOfDifferentSize(List> chunks){\n List result = new ArrayList();\n\n int sum[] = new int[chunks.size()+1];\n sum[0] = 0;\n for(int i =1; i < sum.length;i++){\n sum[i] = sum[i-1] + chunks.get(i-1).size();\n }\n \n for(List chunk : chunks){\n for(Integer i : chunk){\n result.add(i);\n }\n }\n mergeSort(result,0,chunks.size()-1,sum);\n return result;\n }\n\n private void mergeSort(List result,int start,int end,int sum[]){\n if(start >= end){\n return;\n }\n int mid = (start + end)/2;\n mergeSort(result,start,mid,sum);\n mergeSort(result,mid+1,end,sum);\n sortedMerge(result,start,end,sum);\n }\n\n private void sortedMerge(List result,int start,int end,int sum[]){\n \n /**\n * If chunks are of equal size then\n * i = size*start to (mid+1)*size -1\n * j = (mid+1)*size to size*(end+1)\n */\n \n int mid = (start + end)/2; \n int i = sum[start];\n int j = sum[mid+1];\n List temp = new ArrayList();\n while(i < sum[mid+1] && j < sum[end+1]){\n if(result.get(i) < result.get(j)){\n temp.add(result.get(i));\n i++;\n }else{\n temp.add(result.get(j));\n j++;\n }\n }\n while(i < sum[mid+1]){\n temp.add(result.get(i));\n i++;\n }\n while(j < sum[end+1]){\n temp.add(result.get(j));\n j++;\n }\n int index = sum[start];\n for(int k : temp){\n result.set(index, k);\n index++;\n }\n }\n public static void main(String args[]){\n Integer arr1[] = {1,5,6,9,21};\n Integer arr2[] = {4,6,11,14};\n Integer arr3[] = {-1,0,7};\n Integer arr4[] = {-4,-2,11,14,18};\n Integer arr5[] = {2,6};\n Integer arr6[] = {-5,-2,1,5,7,11,14};\n Integer arr7[] = {-6,-1,0,15,17,22,24};\n \n List list1 = Arrays.asList(arr1);\n List list2 = Arrays.asList(arr2);\n List list3 = Arrays.asList(arr3);\n List list4 = Arrays.asList(arr4);\n List list5 = Arrays.asList(arr5);\n List list6 = Arrays.asList(arr6);\n List list7 = Arrays.asList(arr7);\n \n \n List> chunks = new ArrayList>();\n chunks.add(list1);\n chunks.add(list2);\n chunks.add(list3);\n chunks.add(list4);\n chunks.add(list5);\n chunks.add(list6);\n chunks.add(list7);\n \n ChunkMerge cm = new ChunkMerge();\n List result = cm.mergeChunksOfDifferentSize(chunks);\n System.out.println(result.size());\n for(Integer r : result){\n System.out.print(r + \" \");\n }\n \n result = cm.mergeUsingHeap(chunks);\n System.out.println();\n for(Integer r : result){\n System.out.print(r + \" \");\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/CommonThreeSortedArray.java",
"content": "package com.interview.array;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\n/**\n * Date 01/01/2016\n * @author Tushar Roy\n *\n * Given 3 sorted array find common elements in these 3 sorted array.\n *\n * Time complexity is O(m + n + k)\n *\n * http://www.geeksforgeeks.org/find-common-elements-three-sorted-arrays/\n */\npublic class CommonThreeSortedArray {\n\n public List commonElements(int input1[], int input2[], int input3[]) {\n int i = 0;\n int j = 0;\n int k = 0;\n List result = new ArrayList<>();\n while (i < input1.length && j < input2.length && k < input3.length) {\n if (input1[i] == input2[j] && input2[j] == input3[k]) {\n result.add(input1[i]);\n i++;\n j++;\n k++;\n } else if (input1[i] < input2[j]) {\n i++;\n } else if (input2[j] < input3[k]) {\n j++;\n } else {\n k++;\n }\n }\n return result;\n }\n\n public static void main(String args[]) {\n int input1[] = {1, 5, 10, 20, 40, 80};\n int input2[] = {6, 7, 20, 80, 100};\n int input3[] = {3, 4, 15, 20, 30, 70, 80, 120};\n\n CommonThreeSortedArray cts = new CommonThreeSortedArray();\n List result = cts.commonElements(input1, input2, input3);\n result.forEach(i -> System.out.print(i + \" \"));\n }\n}\n"
},
{
"path": "src/com/interview/array/ConvertAnArrayIntoDecreaseIncreaseFashion.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n\n/**\n * Convert an unsorted array into an array such that\n * a < b > c < d > e < f and so on\n */\npublic class ConvertAnArrayIntoDecreaseIncreaseFashion {\n\n public void convert(int arr[]){\n int k = 0;\n if(arr.length % 2 ==0){\n k = arr.length/2 ;\n }else{\n k = arr.length/2+1;\n }\n KthElementInArray kthElement = new KthElementInArray();\n kthElement.kthElement(arr, k);\n \n int high = k;\n int low = 1;\n while(low < high && high < arr.length){\n swap(arr,low,high);\n high++;\n low += 2;\n }\n \n }\n \n /**\n * Sort the array first.\n * Then swap every adjacent element to get final result\n * @param arr\n */\n public void convert1(int arr[]){\n Arrays.sort(arr);\n for(int i=1; i < arr.length; i+=2){\n if(i+1 < arr.length){\n swap(arr, i, i+1);\n }\n }\n }\n \n private void swap(int arr[],int low,int high){\n int temp = arr[low];\n arr[low] = arr[high];\n arr[high] = temp;\n }\n \n public static void main(String args[]){\n ConvertAnArrayIntoDecreaseIncreaseFashion can = new ConvertAnArrayIntoDecreaseIncreaseFashion();\n int arr[] = {0,6,9,13,10,-1,8,2,4,14,-5};\n can.convert(arr);\n for(int i=0; i < arr.length; i++){\n System.out.print(arr[i] + \" \");\n }\n System.out.println();\n int arr1[] = {0,6,9,13,10,-1,8,2,4,14,-5};\n can.convert1(arr1);\n for(int i=0; i < arr1.length; i++){\n System.out.print(arr1[i] + \" \");\n }\n }\n\n}\n"
},
{
"path": "src/com/interview/array/CountInversionOfSize3.java",
"content": "package com.interview.array;\n\n/**\n * Date 12/29/15\n * @author Tushar Roy\n *\n * Given input array find number of inversions where i < j < k and input[i] > input[j] > input[k]\n *\n * http://www.geeksforgeeks.org/count-inversions-of-size-three-in-a-give-array/\n */\npublic class CountInversionOfSize3 {\n\n /**\n * Time complexity of this method is O(n^2)\n * Space complexity is O(1)\n */\n public int findInversions(int input[]) {\n int inversion = 0;\n for (int i = 1; i < input.length - 1 ; i++) {\n int larger = 0;\n for (int k = 0; k < i; k++) {\n if (input[k] > input[i]) {\n larger++;\n }\n }\n int smaller = 0;\n for (int k = i+1; k < input.length; k++) {\n if (input[k] < input[i]) {\n smaller++;\n }\n }\n inversion += smaller*larger;\n }\n return inversion;\n }\n\n public static void main(String args[]) {\n int input[] = {9, 6, 4, 5, 8};\n CountInversionOfSize3 ci = new CountInversionOfSize3();\n System.out.print(ci.findInversions(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/CountSmallerOnRight.java",
"content": "package com.interview.array;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\n/**\n * Date 03/01/2016\n * @author Tushar Roy\n *\n * Count number of smaller elements on right side of an array for every element.\n *\n * Time complexity is O(nlogn)\n * Space complexity is O(n)\n *\n * https://leetcode.com/problems/count-of-smaller-numbers-after-self/\n */\npublic class CountSmallerOnRight {\n static class NumberIndex {\n int val;\n int index;\n NumberIndex(int val, int index) {\n this.val = val;\n this.index = index;\n }\n }\n\n public List countSmaller(int[] nums) {\n if (nums.length == 0) {\n return new ArrayList<>();\n }\n NumberIndex[] input = new NumberIndex[nums.length];\n for (int i = 0; i < nums.length; i++) {\n input[i] = new NumberIndex(nums[i], i);\n }\n\n int result[] = new int[nums.length];\n\n mergeUtil(input, result, 0, input.length - 1);\n\n List r = new ArrayList<>();\n for (int s : result) {\n r.add(s);\n }\n return r;\n }\n\n private void mergeUtil(NumberIndex[] nums, int[] result, int low, int high) {\n if (low == high) {\n return;\n }\n int mid = (low + high)/2;\n mergeUtil(nums, result, low, mid);\n mergeUtil(nums, result, mid + 1, high);\n\n int i = low;\n int j = mid + 1;\n NumberIndex[] t = new NumberIndex[high - low + 1];\n int k = 0;\n int tempResult[] = new int[high - low + 1];\n while (i <= mid && j <= high) {\n if (nums[i].val <= nums[j].val) {\n tempResult[nums[i].index - low] = j - mid - 1;\n t[k++] = nums[i++];\n } else {\n tempResult[nums[i].index - low] = j - mid;\n t[k++] = nums[j++];\n }\n }\n int i1= i;\n while (i1 <= mid) {\n tempResult[nums[i1].index - low] = j - mid - 1;\n t[k++] = nums[i1++];\n }\n\n while (j <= high) {\n t[k++] = nums[j++];\n }\n\n k = 0;\n for (i = low; i <= high; i++) {\n nums[i] = t[k];\n result[i] += tempResult[k++];\n }\n }\n\n public static void main(String args[]) {\n CountSmallerOnRight csr = new CountSmallerOnRight();\n int nums[] = {5, 2, 6, 1, 0, 3};\n List result = csr.countSmaller(nums);\n result.forEach(r -> System.out.print(r + \" \"));\n }\n}\n"
},
{
"path": "src/com/interview/array/DivideNumbersInEqualGroupWithClosestSum.java",
"content": "package com.interview.array;\n\n/**\n * This solution is incorrect. It is greedy approach which will not work\n * e.g 1,6,6,8,9,10 - Result should be 1,9,10 and 6,6,8 but it will not give this result\n * since it will greedily break 9 and 10 into different sets\n * \n * INCORRECT SOLUTION.(Still keeping the code in case I can improve it)\n * \n */\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class DivideNumbersInEqualGroupWithClosestSum {\n\n public void divide(int arr[],List list1, List list2){\n Arrays.sort(arr);\n int len = arr.length;\n int sum1 = 0;\n int sum2 = 0;\n for(int i = len-1 ; i >=0; i--){\n if((sum1 < sum2 && list1.size() < len/2) || (list2.size() >= len/2)){\n list1.add(arr[i]);\n sum1 = sum1 + arr[i];\n }else{\n list2.add(arr[i]);\n sum2 = sum2 + arr[i];\n }\n }\n }\n \n public static void main(String args[]){\n List list1 = new ArrayList();\n List list2 = new ArrayList();\n int arr[] = {15,14,13,1,3,2,};\n int arr1[] = {23, 45, 34, 12,11, 98, 99, 4, 189, 1,7,19,105, 201};\n \n DivideNumbersInEqualGroupWithClosestSum dn = new DivideNumbersInEqualGroupWithClosestSum();\n dn.divide(arr, list1, list2);\n System.out.println(list1);\n System.out.println(list2);\n \n list1.clear();\n list2.clear();\n dn.divide(arr1, list1, list2);\n System.out.println(list1);\n System.out.println(list2);\n \n }\n}\n"
},
{
"path": "src/com/interview/array/DuplicateNumberDetection.java",
"content": "package com.interview.array;\n\n/**\n * Date 03/04/2016\n * @author Tushar Roy\n *\n * Given an array of size n + 1 with elements from 1 to n. One element is duplicated mulitiple times.\n * Find that element in O(1) space. Array cannot be changed.\n *\n * Reference\n * https://leetcode.com/problems/find-the-duplicate-number/\n */\npublic class DuplicateNumberDetection {\n public int findDuplicate(int[] nums) {\n if (nums.length == 0 || nums.length == 1) {\n return -1;\n }\n\n int slow = nums[0];\n int fast = nums[nums[0]];\n while (slow != fast) {\n slow = nums[slow];\n fast = nums[nums[fast]];\n }\n fast = 0;\n while (slow != fast) {\n slow = nums[slow];\n fast = nums[fast];\n }\n\n return fast;\n }\n\n public static void main(String args[]) {\n int[] input = {2,1,3,4,3};\n DuplicateNumberDetection dd = new DuplicateNumberDetection();\n System.out.println(dd.findDuplicate(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/DuplicateWithinkIndices.java",
"content": "package com.interview.array;\n\nimport java.util.HashSet;\nimport java.util.Set;\n\n/**\n * Write a function that determines whether a array contains duplicate \n * characters within k indices of each other\n */\npublic class DuplicateWithinkIndices {\n\n public boolean duplicate(int arr[],int k){\n Set visited = new HashSet();\n for(int i=0; i < arr.length; i++){\n if(visited.contains(arr[i])){\n return true;\n }\n if(i >= k){\n visited.remove(arr[i-k]);\n }\n visited.add(arr[i]);\n }\n return false;\n }\n \n public static void main(String args[]){\n int arr[] = {1,2,3,11,2,5,6};\n DuplicateWithinkIndices dk = new DuplicateWithinkIndices();\n System.out.println(dk.duplicate(arr, 3));\n }\n}\n"
},
{
"path": "src/com/interview/array/FindElementsOccurringNByKTimesTetris.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/given-an-array-of-of-size-n-finds-all-the-elements-that-appear-more-than-nk-times/\n * The reason this algorithm works is there can never be more than k-1 elements of size\n * more than n/k\n * \n * This question does not make much sense. Why not just use a map and keep count and\n * check if occurrence is more than n/k. This is way too much effort to find elements more than\n * n by k even though it saves some space.\n */\npublic class FindElementsOccurringNByKTimesTetris {\n\n public static class Pair{\n public int element;\n public int count;\n }\n \n public void printElementsOccurringKTimes(int arr[],int k){\n Pair[] p = new Pair[k];\n for(int i=0; i < k; i++){\n p[i] = new Pair();\n }\n for(int i=0; i < arr.length; i++){\n \n int j=0;\n for(j=0; j < k; j++){\n if(p[j].element == arr[i]){\n p[j].count++;\n break;\n }\n }\n \n if(j == k){\n int l=0;\n for(l =0; l < k ; l++){\n if(p[l].count == 0){\n p[l].element = arr[i];\n p[l].count = 1;\n break;\n }\n }\n if(l == k){\n for(int t =0; t < k ; t++){\n p[t].count--;\n }\n }\n }\n }\n \n for(int i=0; i < k ; i++){\n if(p[i].count > 0){\n int count =0;\n for(int j=0; j < arr.length; j++){\n if(arr[j] == p[i].element){\n count++;\n }\n }\n if(count >= arr.length/k){\n System.out.println(p[i].element);\n }\n }\n }\n }\n \n public static void main(String args[]){\n int arr[] = {3,2,2,1,1,2,3,3,4,5,3,1};\n FindElementsOccurringNByKTimesTetris fe = new FindElementsOccurringNByKTimesTetris();\n fe.printElementsOccurringKTimes(arr, 3);\n }\n\n \n}\n"
},
{
"path": "src/com/interview/array/FirstPositiveMissing.java",
"content": "package com.interview.array;\n\n/**\n * https://leetcode.com/problems/first-missing-positive/\n */\npublic class FirstPositiveMissing {\n public int firstMissingPositive(int[] nums) {\n int startOfPositive = segregate(nums);\n for (int i = startOfPositive; i < nums.length; i++) {\n int index = Math.abs(nums[i]) + startOfPositive - 1;\n if (index < nums.length) {\n nums[index] = -Math.abs(nums[index]);\n }\n }\n for (int i = startOfPositive; i < nums.length; i++) {\n if (nums[i] > 0) {\n return i - startOfPositive + 1;\n }\n }\n return nums.length - startOfPositive + 1;\n }\n\n private int segregate(int[] nums) {\n int start = 0;\n int end = nums.length -1 ;\n while (start <= end) {\n if (nums[start] <= 0) {\n start++;\n } else if (nums[end] > 0) {\n end--;\n } else {\n swap(nums, start, end);\n }\n }\n return start;\n }\n\n private void swap(int[] nums, int start, int end) {\n int t = nums[start];\n nums[start] = nums[end];\n nums[end] = t;\n }\n}\n"
},
{
"path": "src/com/interview/array/Flip0sMaximum1s.java",
"content": "package com.interview.array;\n\n/**\n * Date 12/29/2015\n * @author Tushar Roy\n *\n * Given input array of 0s and 1s and number of flips allowed from 0 to 1, what is maximum consecutive 1s we can have\n * in array\n *\n * Time complexity - O(n)\n * Space complexity - O(1)\n *\n * http://www.geeksforgeeks.org/find-zeroes-to-be-flipped-so-that-number-of-consecutive-1s-is-maximized/\n */\npublic class Flip0sMaximum1s {\n\n public int flip0sToMaximizeConsecutive1s(int input[], int flipsAllowed) {\n\n int windowStart = 0;\n int countZero = 0;\n int result = 0;\n for (int i = 0 ; i < input.length; i++) {\n if (input[i] == 1) {\n result = Math.max(result, i - windowStart + 1);\n } else {\n if (countZero < flipsAllowed) {\n countZero++;\n result = Math.max(result, i - windowStart + 1);\n } else {\n while(true) {\n if (input[windowStart] == 0) {\n windowStart++;\n break;\n }\n windowStart++;\n }\n }\n }\n }\n return result;\n }\n\n public static void main(String args[]) {\n int input[] = {0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1};\n Flip0sMaximum1s fm = new Flip0sMaximum1s();\n System.out.print(fm.flip0sToMaximizeConsecutive1s(input, 1));\n }\n}\n"
},
{
"path": "src/com/interview/array/FourSum.java",
"content": "package com.interview.array;\n\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\n/**\n * Date 07/31/2016\n * @author Tushar Roy\n *\n * Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target?\n * Find all unique quadruplets in the array which gives the sum of target.\n *\n * Time complexity O(n^3)\n * Space complexity O(1)\n *\n * Reference\n * https://leetcode.com/problems/4sum/\n */\npublic class FourSum {\n\n public List> fourSum(int[] nums, int target) {\n if (nums.length < 4) {\n return Collections.EMPTY_LIST;\n }\n Arrays.sort(nums);\n List> result = new ArrayList<>();\n for (int i = 0; i < nums.length - 3; i++) {\n if (i != 0 && nums[i] == nums[i - 1]) {\n continue;\n }\n if(nums[i] + nums[i+1] + nums[i+2] + nums[i+3] > target) {\n break;\n }\n if(nums[i] + nums[nums.length - 3] + nums[nums.length - 2] + nums[nums.length - 1] < target) {\n continue;\n }\n for (int j = i + 1; j < nums.length - 2; j++) {\n if (j != i + 1 && nums[j] == nums[j - 1]) {\n continue;\n }\n if (nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) {\n break;\n }\n if (nums[i] + nums[j] + nums[nums.length - 1] + nums[nums.length - 1] < target) {\n continue;\n }\n int low = j + 1;\n int high = nums.length - 1;\n while (low < high) {\n if (low != j + 1 && nums[low] == nums[low - 1]) {\n low++;\n continue;\n }\n if (high != nums.length - 1 && nums[high] == nums[high + 1]) {\n high--;\n continue;\n }\n\n int sum = nums[i] + nums[j] + nums[low] + nums[high];\n if (sum == target) {\n List r = new ArrayList<>();\n r.add(nums[i]);\n r.add(nums[j]);\n r.add(nums[low]);\n r.add(nums[high]);\n result.add(r);\n low++;\n high--;\n } else if (sum < target) {\n low++;\n } else {\n high--;\n }\n }\n }\n }\n return result;\n }\n\n public static void main(String args[]) {\n int[] nums = {1, 1, 4, 5, 9, 11};\n int[] nums1 = {1, 0, -1, 0, -2, 2};\n int target = 0;\n FourSum fourSum = new FourSum();\n List> result = fourSum.fourSum(nums1, target);\n result.forEach(System.out::print);\n }\n}\n"
},
{
"path": "src/com/interview/array/GasStationCircle.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/find-a-tour-that-visits-all-stations/\n * You can solve this one using kadane wrap since it finds max contiguous sum\n * for wrapped array. That start point is a best place to start a tour.\n * Test cases\n * Check if length of both input array is same\n * Check that there exists a path after kadane wrap responds\n * Check that there is at least one positive difference before you call kadane\n */\npublic class GasStationCircle {\n\n public int startTour(int gasAvailable[],int gasRequired[]){\n int start = -1;\n int end = 0;\n int currentGas = 0;\n boolean visitedOnce = false;\n while(start != end){\n currentGas += gasAvailable[end] - gasRequired[end];\n if(start == -1){\n start = end;\n }\n if(end == gasAvailable.length-1 && visitedOnce == false){\n visitedOnce = true;\n }else if(end == gasAvailable.length-1 && visitedOnce == true){\n return -1;\n }\n if(currentGas < 0){\n start = -1;\n currentGas = 0;\n }\n end = (end + 1)%gasAvailable.length;\n }\n \n return end;\n }\n \n /**\n * If it is not guaranteed that tour exists then once you get\n * result of kadanewrap make an actual trip to see if value is positive\n * @return -1 if no solution exists otherwise returns gas station at which to start.\n */\n public int startTour1(int gasAvailable[], int gasRequired[]){\n int diff[] = new int[gasAvailable.length];\n for(int i=0; i < diff.length; i++){\n diff[i] = gasAvailable[i] - gasRequired[i];\n }\n\n boolean allNegative = true;\n for (int i = 0; i < diff.length; i++) {\n if (diff[i] >= 0) {\n allNegative = false;\n break;\n }\n }\n\n if (allNegative) {\n return -1;\n }\n\n KadaneWrapArray kwa = new KadaneWrapArray();\n Triplet t = kwa.kadaneWrap(diff);\n //make sure this solution leads to answer\n int i = t.start;\n int netGas = 0;\n do {\n netGas += diff[i];\n i = (i + 1)%diff.length;\n if (netGas < 0) {\n return -1;\n }\n } while (i != t.start);\n\n return t.start;\n }\n\n public static void main(String args[]){\n GasStationCircle gsc = new GasStationCircle();\n int[] gasAvailable = {4, 4, 6};\n int[] gasRequired = {5, 6, 1};\n System.out.println(gsc.startTour(gasAvailable, gasRequired));\n System.out.println(gsc.startTour1(gasAvailable, gasRequired));\n }\n}\n"
},
{
"path": "src/com/interview/array/GreedyTextJustification.java",
"content": "package com.interview.array;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\n/**\n * Date 03/12/2016\n * @author Tushar Roy\n *\n * Given an array of words and a length L, format the text such that each line has exactly L characters and is fully\n * (left and right) justified.\n * You should pack your words in a greedy approach; that is, pack as many words as you can in each line.\n *\n * Time complexity - O(n) where n is the number of words\n * Space complexity - O(1)\n *\n * https://leetcode.com/problems/text-justification/\n */\npublic class GreedyTextJustification {\n public List fullJustify(String[] words, int maxWidth) {\n List result = new ArrayList<>();\n for (int i = 0; i < words.length; ) {\n int total = words[i].length();\n int j = i + 1;\n StringBuffer buff = new StringBuffer();\n buff.append(words[i]);\n while(j < words.length && total + words[j].length() + 1 <= maxWidth) {\n total += words[j].length() + 1;\n j++;\n }\n int remaining = maxWidth - total;\n //since j is not word length means its not a last line. So pad accordingly.\n if (j != words.length) {\n int count = j - i - 1;\n if (count == 0) {\n padSpace(buff, remaining);\n } else {\n int q = remaining/count;\n int r = remaining % count;\n for (int k = i + 1; k < j; k++) {\n padSpace(buff, q);\n if (r > 0) {\n buff.append(\" \");\n r--;\n }\n buff.append(\" \").append(words[k]);\n }\n }\n } else { //if it is last line then left justify all the words.\n for (int k = i + 1; k < j; k++) {\n buff.append(\" \").append(words[k]);\n }\n padSpace(buff, remaining);\n }\n result.add(buff.toString());\n i = j;\n }\n return result;\n }\n\n private void padSpace(StringBuffer buff, int count) {\n for (int i = 0; i < count; i++) {\n buff.append(\" \");\n }\n }\n\n public List fullJustify1(String[] words, int maxWidth) {\n int currentLength = 0;\n int prevIndex = 0;\n List result = new ArrayList<>();\n\n for (int i = 0; i < words.length; i++) {\n //keep track of length for currentLine. For first word only use length while for remaining words use\n //lenght + 1 since there will be a space b/w them.\n currentLength += (words[i].length() + (i == prevIndex ? 0 : 1));\n\n //if currentLength exceeds maxWidth it means currentWord cannot in same line.\n if (currentLength > maxWidth) {\n //subtract current word's length from currentLength\n currentLength -= words[i].length() + 1;\n StringBuffer builder = new StringBuffer();\n\n //find number of words which will find in the line.\n int gaps = i - 1 - prevIndex;\n if (gaps > 0) {//if more than one word fits in the gap.\n //available number of spaces is below. Subtract gaps because that many spaces have been accounted\n //for in currentLength.\n int availableSpace = maxWidth - currentLength + gaps;\n\n //first remaining gaps get one extra space.\n int remaining = availableSpace % gaps;\n\n //every gap gets this much extra space.\n int atleast = availableSpace / gaps;\n for (int j = prevIndex; j <= i - 2; j++) {\n builder.append(words[j]);\n padSpace(builder, atleast);\n if (j - prevIndex < remaining) {\n padSpace(builder, 1);\n }\n }\n builder.append(words[i - 1]);\n } else { //if only one word can fit in a one line then left specify it.\n builder.append(words[i - 1]);\n padSpace(builder, maxWidth - words[i - 1].length());\n }\n result.add(builder.toString());\n prevIndex = i;\n currentLength = words[i].length();\n }\n }\n //handle the last line. Left justify the remaining words\n if (prevIndex < words.length) {\n StringBuffer builder = new StringBuffer();\n int count = 0;\n while (prevIndex < words.length) {\n builder.append(words[prevIndex]).append(\" \");\n count += words[prevIndex].length() + 1;\n prevIndex++;\n }\n count--;\n //delete extra space added by above for looop.\n builder.deleteCharAt(builder.length() - 1);\n //whatever spae is left just put it at the end.\n padSpace(builder, maxWidth - count);\n result.add(builder.toString());\n }\n return result;\n }\n\n public static void main(String args[]) {\n String[] input = {\"What\",\"must\",\"be\",\"shall\",\"be.\"};\n GreedyTextJustification gtj = new GreedyTextJustification();\n List result = gtj.fullJustify(input, 12);\n System.out.print(result);\n }\n}\n"
},
{
"path": "src/com/interview/array/GroupElementsInSizeM.java",
"content": "package com.interview.array;\n\nimport java.util.Comparator;\nimport java.util.HashMap;\nimport java.util.Map;\nimport java.util.PriorityQueue;\n\n/**\n * http://www.careercup.com/question?id=6026101998485504\n * This answer two questions.\n * Group elements in size m such that in every group only unique elements are possible.\n * It also answers question where rearrange array such that same elements are exactly m\n * distance from each other\n */\nclass Pair{\n int num;\n int count;\n Pair(int num,int count){\n this.count = count;\n this.num = num;\n }\n}\n\nclass Comparators implements Comparator{\n\n @Override\n public int compare(Pair o1, Pair o2) {\n if(o1.count <= o2.count){\n return 1;\n }else{\n return -1;\n }\n }\n \n}\n\npublic class GroupElementsInSizeM {\n\n public boolean group(int input[],int m){\n Map count = new HashMap();\n for(Integer i : input){\n int c = 1;\n if(count.containsKey(i)){\n c = count.get(i);\n c++;\n }\n count.put(i, c);\n }\n \n PriorityQueue maxHeap = new PriorityQueue(count.size(),new Comparators());\n for(Integer s : count.keySet()){\n int c = count.get(s);\n //if any count is greater than len/m then this arrangement is not possible\n if(c > Math.ceil(input.length*1.0/m)){\n return false;\n }\n maxHeap.offer(new Pair(s,c));\n }\n int current = 0;\n int start = current;\n while(maxHeap.size() > 0){\n Pair p = maxHeap.poll();\n int i =0;\n while(i < p.count){\n input[start] = p.num;\n start = start + m;\n if(start >= input.length){\n current++;\n start = current;\n }\n i++;\n }\n }\n return true;\n }\n \n public static void main(String args[]){\n int input[] = {2,1,5,1,3,5,3,3,4};\n int input1[] = {1,2,3,8,8,8,7,8};\n GroupElementsInSizeM gps = new GroupElementsInSizeM();\n boolean r = gps.group(input1, 3);\n System.out.println(r);\n for(int i=0; i < input1.length; i++){\n System.out.println(input1[i]);\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/HIndex.java",
"content": "package com.interview.array;\n\n/**\n * Given an array of citations (each citation is a non-negative integer) of a researcher,\n * write a function to compute the researcher's h-index.\n * https://leetcode.com/problems/h-index/\n */\npublic class HIndex {\n public int hIndex(int[] citations) {\n int[] count = new int[citations.length + 1];\n for (int c : citations) {\n if (c <= citations.length) {\n count[c]++;\n } else {\n count[citations.length]++;\n }\n }\n\n int sum = 0;\n int max = 0;\n for (int i = 0; i < count.length; i++) {\n sum += count[i];\n //we are trying to see if i is answer.\n //already everything before i has less than i citations.\n //so only thing to check is that p >= i where p is\n //total number of papers with i or more citations.\n int p = citations.length - sum + count[i];\n if (i <= p) {\n max = i;\n }\n }\n return max;\n }\n\n public static void main(String args[]) {\n HIndex hi = new HIndex();\n int[] input = {0, 1, 1, 1, 1, 6, 7 ,8};\n System.out.print(hi.hIndex(input));\n }\n}\n\n//0 1 2 6 6 6 6 7\n//0 1 2 3 4 5 6 7\n//0 1 1 1 3 6 7 8\n//0 1 2 3 4 5 6 7\n\n//0 1 2 5 6\n"
},
{
"path": "src/com/interview/array/IncreasingSubsequnceOfLength3WithMaxProduct.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/increasing-subsequence-of-length-three-with-maximum-product/\n * Keep two arrays which keeps max from current position to right side\n * Other array keeps max on left size which is smaller than current element\n * Once you have these two arrays from 2nd to 2nd last position keep multiplying\n * elements at 3 arrays index position to get max product\n * Test cases\n * Negative numbers\n * 0 in the input\n */\npublic class IncreasingSubsequnceOfLength3WithMaxProduct {\n\n public int maxProduct(int arr[]){\n int RGN[] = new int[arr.length];\n int LGN[] = new int[arr.length];\n RGN[arr.length-1] = arr[arr.length-1];\n int max = arr[arr.length-1];\n for(int i=arr.length-2; i>=0; i--){\n if(max < arr[i]){\n max = arr[i];\n }\n if(max > arr[i]){\n RGN[i] = max;\n }\n else{\n RGN[i] = 0;\n }\n }\n LGN[0] = 0;\n //This can be implemented using an AVL tree instead of this way which will\n //make it O(nLogn) operation insteado ofO(n2).\n for(int i=1; i < arr.length; i++){\n getLGN(arr,i,LGN);\n }\n int maxProduct = 0;\n for(int i=1; i < arr.length-1; i++){\n int product = arr[i]*LGN[i]*RGN[i];\n if(maxProduct < product){\n maxProduct = product;\n }\n }\n return maxProduct;\n }\n \n private void getLGN(int arr[],int pos,int LGN[]){\n int max = 0;\n int i =0;\n while(i < pos){\n if(arr[i] < arr[pos]){\n if(arr[i] > max){\n max = arr[i];\n }\n }\n i++;\n }\n LGN[pos] = max;\n }\n \n public static void main(String args[]){\n int arr[] = {6, 7, 8, 1, 2, 3, 9, 10};\n IncreasingSubsequnceOfLength3WithMaxProduct iss = new IncreasingSubsequnceOfLength3WithMaxProduct();\n System.out.println(iss.maxProduct(arr));\n int arr1[] = {1, 5, 10, 8, 9};\n System.out.println(iss.maxProduct(arr1));\n }\n}\n"
},
{
"path": "src/com/interview/array/IncreasingTripletSubsequence.java",
"content": "package com.interview.array;\n\n/**\n * Date 03/06/2016\n * @author Tushar Roy\n *\n * Find if there exists an increasing triplet subsequence.\n * Similar method to longest increasing subsequence in nlogn time.\n *\n * Time complexity is O(n)\n * Space complexity is O(1)\n *\n * https://leetcode.com/problems/increasing-triplet-subsequence/\n */\npublic class IncreasingTripletSubsequence {\n public boolean increasingTriplet(int[] nums) {\n int T[] = new int[3];\n int len = 0;\n for (int i = 0; i < nums.length; i++) {\n boolean found = false;\n for (int j = 0; j < len; j++) {\n if (T[j] >= nums[i]) {\n T[j] = nums[i];\n found = true;\n break;\n }\n }\n if (!found) {\n T[len++] = nums[i];\n }\n if (len == 3) {\n return true;\n }\n }\n return false;\n }\n\n public static void main(String args[]) {\n IncreasingTripletSubsequence tripletSubsequence = new IncreasingTripletSubsequence();\n int input[] = {9, 10, -2, 12, 6, 7, -1};\n System.out.print(tripletSubsequence.increasingTriplet(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/JumpGame.java",
"content": "package com.interview.array;\n\n/**\n * Date 07/31/2016\n * @author Tushar Roy\n *\n * Given an array of non-negative integers, you are initially positioned at the first index of the array.\n * Each element in the array represents your maximum jump length at that position.\n * Determine if you are able to reach the last index.\n *\n * Time complexity O(n)\n * Space complexity O(1)\n *\n * https://leetcode.com/problems/jump-game/\n *\n * Given an array of non-negative integers, you are initially positioned at the first index of the array.\n * Each element in the array represents your maximum jump length at that position.\n * Your goal is to reach the last index in the minimum number of jumps.\n *\n * Time complexity O(n)\n * Space complexity O(1)\n *\n * https://leetcode.com/problems/jump-game-ii/\n */\npublic class JumpGame {\n\n public boolean canJump(int[] nums) {\n int jump = 0;\n int i;\n for (i = 0; i < nums.length && i <= jump; i++) {\n jump = Math.max(jump, i + nums[i]);\n }\n return i == nums.length;\n }\n\n public int jump(int[] nums) {\n int current = 0;\n int max = 0;\n int count = 0;\n for (int i = 0; i < nums.length - 1; i++) {\n max = Math.max(max, i + nums[i]);\n if (current == i) {\n count++;\n current = max;\n }\n }\n return count;\n }\n\n public static void main(String args[]) {\n JumpGame jumpGame = new JumpGame();\n int[] nums = {3, 2, 3, 0, 2, 1};\n System.out.println(jumpGame.jump(nums));\n int[] nums1 = {3, 0, 2, 0, 0, 1};\n System.out.println(jumpGame.canJump(nums1));\n }\n}\n"
},
{
"path": "src/com/interview/array/KadaneWrapArray.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/maximum-contiguous-circular-sum/\n * Test cases\n * All negative\n * All positives\n * all 0s\n */\n\nclass Triplet{\n int start;\n int end;\n int sum;\n @Override\n public String toString() {\n return \"Triplet [start=\" + start + \", end=\" + end + \", sum=\" + sum\n + \"]\";\n }\n \n}\npublic class KadaneWrapArray {\n\n public Triplet kadaneWrap(int arr[]){\n Triplet straightKadane = kadane(arr);\n int sum =0;\n for(int i=0; i < arr.length; i++){\n sum += arr[i];\n arr[i] = -arr[i];\n }\n Triplet wrappedNegKadane = kadane(arr);\n for(int i=0; i < arr.length; i++){\n arr[i] = -arr[i];\n }\n if(straightKadane.sum < sum + wrappedNegKadane.sum){\n straightKadane.sum = wrappedNegKadane.sum + sum;\n straightKadane.start = wrappedNegKadane.end+1;\n straightKadane.end = wrappedNegKadane.start-1;\n }\n return straightKadane;\n }\n \n /**\n * This method assumes there is at least one positive number in the array.\n * Otherwise it will break\n * @param arr\n * @return\n */\n public Triplet kadane(int arr[]){\n int sum =0;\n int cStart = 0;\n int mStart = 0;\n int end = 0;\n int maxSum = Integer.MIN_VALUE;\n for(int i=0; i < arr.length; i++){\n sum += arr[i];\n if(sum <= 0){\n sum = 0;\n cStart = i+1;\n }else{\n if(sum > maxSum){\n maxSum = sum;\n mStart = cStart;\n end = i;\n }\n }\n }\n Triplet p = new Triplet();\n p.sum = maxSum;\n p.start = mStart;\n p.end = end;\n return p;\n }\n \n public static void main(String args[]){\n KadaneWrapArray kwa = new KadaneWrapArray();\n int input[] = {12, -2, -6, 5, 9, -7, 3};\n int input1[] = {8, -8, 9, -9, 10, -11, 12};\n System.out.println(kwa.kadaneWrap(input));\n System.out.println(kwa.kadaneWrap(input1));\n }\n}\n"
},
{
"path": "src/com/interview/array/KthElementInArray.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n/**\n * Kth largest element in an array.\n * Use quickselect of quicksort to find the solution in hopefully O(nlogn) time.\n * Test cases\n * Sorted array\n * Reverse sorted array\n */\npublic class KthElementInArray {\n \n public int kthElement(int arr[],int k){\n int low = 0;\n int high = arr.length-1;\n int pos =0;\n while(true){\n pos = quickSelect(arr,low,high);\n if(pos == (k+low)){\n return arr[pos];\n }\n if(pos > k + low){\n high = pos-1;\n }else{\n k = k - (pos - low + 1);\n low = pos+1;\n }\n }\n }\n \n private int quickSelect(int arr[],int low,int high){\n int pivot = low;\n low++;\n while(low <= high){\n if(arr[pivot] > arr[low]){\n low++;\n continue;\n }\n if(arr[pivot] <= arr[high]){\n high--;\n continue;\n }\n swap(arr,low,high);\n }\n if(arr[high] < arr[pivot]){\n swap(arr,pivot,high);\n }\n return high;\n }\n \n private void swap(int arr[],int low,int high){\n int temp = arr[low];\n arr[low] = arr[high];\n arr[high] = temp;\n }\n \n public static void main(String args[]){\n int arr[] = {6, 2, 1, 6, 8, 9, 6};\n KthElementInArray kthElement = new KthElementInArray();\n System.out.print(kthElement.kthElement(arr, arr.length/2));\n System.out.print(Arrays.toString(arr));\n }\n \n}\n"
},
{
"path": "src/com/interview/array/KthLargestInTwoSortedArray.java",
"content": "package com.interview.array;\n\n/**\n * http://stackoverflow.com/questions/4686823/given-2-sorted-arrays-of-integers-find-the-nth-largest-number-in-sublinear-time\n * http://articles.leetcode.com/2011/01/find-k-th-smallest-element-in-union-of.html\n */\npublic class KthLargestInTwoSortedArray {\n\n \n public int kthLargest1(int arr1[],int arr2[],int low1,int high1,int low2,int high2,int k){\n int len1 = high1-low1 +1;\n int len2 = high2 - low2+1;\n \n if(len1 == 0){\n return arr2[low2+k];\n }\n if(len2 ==0){\n return arr1[low1+k];\n }\n if(k == 0){\n return Math.min(arr1[low1], arr2[low2]);\n }\n \n \n int mid1 = len1*k/(len1 + len2);\n int mid2 = k - mid1 - 1;\n \n mid1 = low1+mid1;\n mid2 = low2 + mid2;\n \n if(arr1[mid1] > arr2[mid2]){\n k = k - mid2 + low2 -1;\n high1 = mid1;\n low2 = mid2 + 1;\n }else{\n k = k - mid1 + low1 -1;\n high2 = mid2;\n low1 = mid1+1;\n }\n return kthLargest(arr1, arr2, low1, high1, low2, high2, k);\n }\n\n \n \n public int kthLargest(int input1[],int input2[],int k){\n return kthLargest(input1, input2, 0, input1.length-1, 0, input2.length-1, k);\n }\n \n private int kthLargest(int input1[],int input2[],int l1, int h1, int l2,int h2,int k){\n if(l1 > h1){\n return input2[k-1];\n }\n if(l2 > h2){\n return input1[k-1];\n }\n \n if((h1 - l1 + 1) + (h2 - l2 + 1) == k){\n return Math.max(input1[h1], input2[h2]);\n }\n\n if(k == 1){\n return Math.min(input1[l1],input2[l2]);\n }\n\n //handle the situation where only one element is left\n //in either of array.\n //e.g k =2 and arr1 = 8 arr2 = 1,9,11\n //we try to find if 8 is before 9 betweenn 1 and 9\n //or before 1. In all these cases k will be either\n //1 8 or 9 \n if(l2 == h2 || l1 == h1){\n if(l2 == h2){\n if(input1[l1+k-1] < input2[l2]){\n return input1[l1+k-1];\n }else if(input1[l1+k-2] > input2[l2]){\n return input1[l1+k-2];\n }else{\n return input2[l2];\n }\n }\n if(l1 == h1){\n if(input2[l2+k-1] < input1[l1]){\n return input2[l2+k-1];\n }else if(input2[l2+k-2] > input1[l1]){\n return input2[l2+k-2];\n }else{\n return input1[l1];\n }\n }\n }\n \n \n int m1 = (h1 + l1)/2;\n int m2 = (h2 + l2)/2;\n \n int diff1 = m1 - l1+1;\n int diff2 = m2 - l2+1;\n if(diff1 + diff2 >= k){\n if(input1[m1] < input2[m2]){\n return kthLargest(input1, input2, l1, h1, l2, m2, k);\n }else{\n return kthLargest(input1, input2, l1, m1, l2, h2, k);\n }\n }else{\n if(input1[m1] < input2[m2]){\n return kthLargest(input1, input2,m1+1, h1, l2, h2, k - diff1);\n }else{\n return kthLargest(input1, input2, l1, h1, m2+1, h2, k -diff2);\n }\n }\n }\n \n public static void main(String args[]){\n KthLargestInTwoSortedArray kis = new KthLargestInTwoSortedArray();\n int input1[] = {1,4,7,11,17,21};\n int input2[] = {-4,-1,3,4,6,28,35,41,56,70};\n for(int i = 0; i < input1.length + input2.length; i++){\n System.out.println(kis.kthLargest(input1, input2, i+1));\n }\n// System.out.println(kis.kthLargest(input1, input2, 6));\n\n }\n}\n"
},
{
"path": "src/com/interview/array/LargerElementOnRight.java",
"content": "package com.interview.array;\n\nimport java.util.Deque;\nimport java.util.LinkedList;\n\n/**\n * http://www.geeksforgeeks.org/next-greater-element/\n * Find next larger element on right side of a number in array for \n * all positions in array\n * This is different than finding largest element on right side which can \n * be done by keeping max while iterating from right\n * It is also different from find next higher number on right side which can\n * be found by keeping AVL tree and finding ceiling.\n */\npublic class LargerElementOnRight {\n\n public int[] larger(int input[]){\n Deque stack = new LinkedList();\n int result[] = new int[input.length];\n for(int i=0; i < result.length; i++){\n result[i] = -1;\n }\n \n stack.offerFirst(0);\n for(int i=1; i < input.length; i++){\n while(stack.size() > 0){\n int t = stack.peekFirst();\n if(input[t] < input[i]){\n result[t] = i;\n stack.pollFirst();\n }else{\n break;\n }\n }\n stack.offerFirst(i);\n }\n return result;\n }\n \n public static void main(String args[]){\n LargerElementOnRight leo = new LargerElementOnRight();\n int input[] = {4,2,-8,6,0,-3,-1,1,9};\n int result[] = leo.larger(input);\n for(int i=0; i < result.length; i++){\n if(result[i] != -1){\n System.out.print(input[result[i]] + \" \");\n }else{\n System.out.print(\"NIL \");\n }\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/LargestMountain.java",
"content": "package com.interview.array;\n\n/**\n * https://leetcode.com/problems/longest-mountain-in-array/description/\n */\npublic class LargestMountain {\n\n public int longestMountain(int[] nums) {\n int start = 0;\n int max = 0;\n State state = State.STARTED;\n for (int i = 1; i < nums.length; i++) {\n if (nums[i] == nums[i - 1]) {\n start = i;\n state = State.STARTED;\n }\n else if (nums[i] > nums[i - 1]) {\n if (state == State.DECREASING || state == State.STARTED) {\n start = i - 1;\n state = State.INCREASING;\n }\n } else {\n if (state == State.INCREASING || state == State.DECREASING) {\n state = State.DECREASING;\n max = Math.max(max, i - start + 1);\n } else {\n start = i;\n }\n }\n }\n return max;\n }\n\n enum State {\n STARTED,\n INCREASING,\n DECREASING;\n }\n\n public static void main(String[] args) {\n LargestMountain lm = new LargestMountain();\n int[] nums = {2, 1, 4, 7, 3, 2, 5};\n System.out.println(lm.longestMountain(nums));\n }\n}\n"
},
{
"path": "src/com/interview/array/LargestSubArrayWithEqual0sAnd1s.java",
"content": "package com.interview.array;\n\nimport java.util.HashMap;\nimport java.util.Map;\n\n/**\n * http://www.geeksforgeeks.org/largest-subarray-with-equal-number-of-0s-and-1s/\n * Test cases\n * Starting with either 0 or 1\n * Maximum length of 0 1 2 or more\n * \n*/\npublic class LargestSubArrayWithEqual0sAnd1s {\n\n public int equalNumber(int arr[]){\n\n int sum[] = new int[arr.length];\n sum[0] = arr[0] == 0? -1 : 1;\n for(int i=1; i < sum.length; i++){\n sum[i] = sum[i-1] + (arr[i] == 0? -1 : 1);\n }\n \n Map pos = new HashMap();\n int maxLen = 0;\n int i = 0;\n for(int s : sum){\n if(s == 0){\n maxLen = Math.max(maxLen, i+1);\n }\n if(pos.containsKey(s)){\n maxLen = Math.max(maxLen, i-pos.get(s));\n }else{\n pos.put(s, i);\n }\n i++;\n }\n return maxLen;\n }\n \n public static void main(String args[]){\n int arr[] = {0,0,0,1,0,1,0,0,1,0,0,0};\n LargestSubArrayWithEqual0sAnd1s mse = new LargestSubArrayWithEqual0sAnd1s();\n System.out.println(mse.equalNumber(arr));\n }\n \n}\n"
},
{
"path": "src/com/interview/array/LeetCodeCandy.java",
"content": "package com.interview.array;\n\n/**\n * References\n * https://leetcode.com/problems/candy/\n */\npublic class LeetCodeCandy {\n public int candy(int[] ratings) {\n int pointOfChange = 0;\n int totalCandies = 1;\n int currentCandy = 1;\n boolean isIndependent = true;\n int maxHeight = 0;\n int diff = 0;\n for (int i = 1; i < ratings.length; i++) {\n diff = 0;\n if (ratings[i] > ratings[i-1]) {\n currentCandy += 1;\n } else if (ratings[i] == ratings[i-1]) {\n isIndependent = true;\n pointOfChange = i;\n currentCandy = 1;\n } else {\n if (currentCandy == 1) {\n if (!isIndependent) {\n if (i - pointOfChange == maxHeight - 1) {\n pointOfChange--;\n }\n }\n }\n else {\n maxHeight = currentCandy;\n currentCandy = 1;\n isIndependent = false;\n pointOfChange = i;\n }\n diff = i - pointOfChange;\n }\n totalCandies += (diff + currentCandy);\n }\n return totalCandies;\n }\n}\n"
},
{
"path": "src/com/interview/array/LongestConsecutiveSubsequence.java",
"content": "package com.interview.array;\n\nimport java.util.HashMap;\nimport java.util.Map;\n\n/**\n * Date 12/03/2016\n * @author Tushar Roy\n *\n * Find longest consecutive subsequence in unsorted array.\n *\n * Time complexity O(n)\n * Space complexity O(n)\n *\n * Reference\n * https://leetcode.com/problems/longest-consecutive-sequence/\n */\npublic class LongestConsecutiveSubsequence {\n public int longestConsecutive(int[] nums) {\n Map map = new HashMap();\n int result = 1;\n for (int i : nums) {\n if (map.containsKey(i)) {\n continue;\n }\n int left = map.containsKey(i - 1) ? map.get(i - 1) : 0;\n int right = map.containsKey(i + 1) ? map.get(i + 1) : 0;\n\n int sum = left + right + 1;\n map.put(i, sum);\n result = Math.max(sum, result);\n map.put(i - left, sum);\n map.put(i + right, sum);\n }\n return result;\n }\n\n public static void main(String args[]) {\n LongestConsecutiveSubsequence lcs = new LongestConsecutiveSubsequence();\n int[] input = {100, 4, 200, 1, 3, 2};\n System.out.println(lcs.longestConsecutive(input));\n }\n}"
},
{
"path": "src/com/interview/array/LongestIncreasingSubSequenceOlogNMethod.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n/**\n * Date 08/01/2015\n * @author Tushar Roy\n *\n * Given an array, find longest increasing subsequence in nlogn time complexity\n *\n * References\n * http://www.geeksforgeeks.org/longest-monotonically-increasing-subsequence-size-n-log-n/\n * http://www.geeksforgeeks.org/construction-of-longest-monotonically-increasing-subsequence-n-log-n/\n */\npublic class LongestIncreasingSubSequenceOlogNMethod {\n\n /**\n * Returns index in T for ceiling of s\n */\n private int ceilIndex(int input[], int T[], int end, int s){\n int start = 0;\n int middle;\n int len = end;\n while(start <= end){\n middle = (start + end)/2;\n if(middle < len && input[T[middle]] < s && s <= input[T[middle+1]]){\n return middle+1;\n }else if(input[T[middle]] < s){\n start = middle+1;\n }else{\n end = middle-1;\n }\n }\n return -1;\n }\n \n public int longestIncreasingSubSequence(int input[]){\n int T[] = new int[input.length];\n int R[] = new int[input.length];\n for(int i=0; i < R.length ; i++) {\n R[i] = -1;\n }\n T[0] = 0;\n int len = 0;\n for(int i=1; i < input.length; i++){\n if(input[T[0]] > input[i]){ //if input[i] is less than 0th value of T then replace it there.\n T[0] = i;\n }else if(input[T[len]] < input[i]){ //if input[i] is greater than last value of T then append it in T\n len++;\n T[len] = i;\n R[T[len]] = T[len-1];\n }else{ //do a binary search to find ceiling of input[i] and put it there.\n int index = ceilIndex(input, T, len,input[i]);\n T[index] = i;\n R[T[index]] = T[index-1];\n }\n }\n\n //this prints increasing subsequence in reverse order.\n System.out.print(\"Longest increasing subsequence \");\n int index = T[len];\n while(index != -1) {\n System.out.print(input[index] + \" \");\n index = R[index];\n }\n\n System.out.println();\n return len+1;\n }\n \n public static void main(String args[]){\n //int input[] = {2,5,3,1,2,10,6,7,8};\n int input[] = {3, 4, -1, 5, 8, 2, 3, 12, 7, 9, 10};\n LongestIncreasingSubSequenceOlogNMethod lis = new LongestIncreasingSubSequenceOlogNMethod();\n System.out.println(\"Maximum length \" + lis.longestIncreasingSubSequence(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/LongestSameSumSpan.java",
"content": "package com.interview.array;\n\nimport java.util.HashMap;\nimport java.util.Map;\n\n/**\n * Date 12/29/2015\n * @author Tushar Roy\n *\n * Give two arrays of same size consisting of 0s and 1s find span (i, j) such that\n * sum of input1[i..j] = sum of input2[i..j]\n *\n * Time complexity O(n)\n * Space complexity O(n)\n *\n * http://www.geeksforgeeks.org/longest-span-sum-two-binary-arrays/\n */\npublic class LongestSameSumSpan {\n\n public int longestSpan(int input1[], int input2[]) {\n if (input1.length != input2.length) {\n throw new IllegalArgumentException(\"Not same length input\");\n }\n Map diff = new HashMap<>();\n int prefix1 = 0, prefix2 = 0;\n int maxSpan = 0;\n diff.put(0, -1);\n for (int i = 0; i < input1.length ; i++) {\n prefix1 += input1[i];\n prefix2 += input2[i];\n int currDiff = prefix1 - prefix2;\n if (diff.containsKey(currDiff)) {\n maxSpan = Math.max(maxSpan, i - diff.get(currDiff));\n } else {\n diff.put(currDiff, i);\n }\n }\n return maxSpan;\n }\n\n public static void main(String args[]) {\n int input1[] = {1, 0, 0, 1, 1, 0};\n int input2[] = {0, 1, 1, 0, 1, 1};\n LongestSameSumSpan lsss = new LongestSameSumSpan();\n System.out.print(lsss.longestSpan(input1, input2));\n }\n\n}\n"
},
{
"path": "src/com/interview/array/LongestSubstringWithAtMost2Char.java",
"content": "package com.interview.array;\n\n/**\n * Longest Substring with At Most Two Distinct Characters\n * https://leetcode.com/problems/longest-substring-with-at-most-two-distinct-characters/\n */\npublic class LongestSubstringWithAtMost2Char {\n public int lengthOfLongestSubstringTwoDistinct(String s) {\n int count1 = 0;\n int count2 = 0;\n char c1 = 0;\n char c2 = 0;\n int start = 0;\n int current = 0;\n int max = 0;\n for (char ch: s.toCharArray()) {\n if (ch == c1 || ch == c2) {\n if (ch == c1) {\n count1++;\n } else {\n count2++;\n }\n } else {\n if (count1 != 0 && count2 != 0) {\n while (start < current) {\n if (s.charAt(start) == c1) {\n count1--;\n } else if (s.charAt(start) == c2) {\n count2--;\n }\n start++;\n if (count1 == 0 || count2 == 0) {\n break;\n }\n }\n }\n if (count1 == 0) {\n c1 = ch;\n count1 = 1;\n } else {\n c2 = ch;\n count2 = 1;\n }\n }\n max = Math.max(max, current - start + 1);\n current++;\n }\n return max;\n }\n\n public static void main(String args[]) {\n LongestSubstringWithAtMost2Char lc = new LongestSubstringWithAtMost2Char();\n System.out.print(lc.lengthOfLongestSubstringTwoDistinct(\"eceba\"));\n }\n}"
},
{
"path": "src/com/interview/array/MaxNumberFromTwoArray.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\nimport java.util.Deque;\nimport java.util.LinkedList;\n\n/**\n * Date 03/01/2016\n * @author Tushar Roy\n *\n * Given two arrays of length m and n with digits 0-9 representing two numbers.\n * Create the maximum number of length k <= m + n from digits of the two\n *\n * e.g\n * nums1 = [3, 4, 6, 5]\n * nums2 = [9, 1, 2, 5, 8, 3]\n * k = 5\n * return [9, 8, 6, 5, 3]\n * \n * https://leetcode.com/problems/create-maximum-number/\n */\npublic class MaxNumberFromTwoArray {\n public int[] maxNumber(int[] nums1, int[] nums2, int k) {\n int[] max = new int[k];\n for (int i = 0; i <= k; i++) {\n if (nums1.length < i || nums2.length < k - i) {\n continue;\n }\n int[] a = merge(findLargest1(nums1, i), findLargest1(nums2, k - i));\n if (isGreater(a, max, 0, 0)) {\n max = a;\n }\n }\n return max;\n }\n\n private int[] merge(int[] a1, int[] a2) {\n int[] result = new int[a1.length + a2.length];\n int i = 0;\n int j = 0;\n int k = 0;\n while (i < a1.length || j < a2.length) {\n if (i == a1.length) {\n result[k++] = a2[j++];\n } else if (j == a2.length) {\n result[k++] = a1[i++];\n } else if (a1[i] > a2[j]) {\n result[k++] = a1[i++];\n } else if (a1[i] < a2[j]) {\n result[k++] = a2[j++];\n } else {\n if (isGreater(a1, a2, i, j)) {\n result[k++] = a1[i++];\n } else {\n result[k++] = a2[j++];\n }\n }\n }\n return result;\n }\n\n private boolean isGreater(int[] a, int[] b, int i, int j) {\n while (i < a.length && j < b.length) {\n if (a[i] > b[j]) {\n return true;\n } else if (a[i] < b[j]) {\n return false;\n }\n i++;\n j++;\n }\n return j == b.length;\n }\n\n private int[] findLargest1(int[] nums, int k) {\n if (k == 0) {\n return new int[0];\n }\n int[] result = new int[k];\n int index = 0;\n for (int i = 0; i < nums.length; i++) {\n while (index > 0 && index + (nums.length - i - 1) >= k && result[index - 1] < nums[i]) {\n index--;\n }\n if (index < k) {\n result[index++] = nums[i];\n }\n }\n return result;\n }\n\n public static void main(String args[]) {\n MaxNumberFromTwoArray max = new MaxNumberFromTwoArray();\n int[] input1 = {9,1,2,5,8,3};\n int[] input2 = {3,4,6,5};\n\n int[] input3 = {2,5,6,4,4,0};\n int[] input4 = {7,3,8,0,6,5,7,6,2};\n int[] result = max.maxNumber(input3, input4, 15);\n System.out.print(Arrays.toString(result));\n }\n}"
},
{
"path": "src/com/interview/array/MaxProductSubarray.java",
"content": "package com.interview.array;\n\n/**\n * Date 04/`7/2016\n * @author Tushar Roy\n *\n * Find the contiguous subarray within an array (containing at least one number) which has the largest product.\n *\n * Time complexity is O(n)\n * Space complexity is O(1)\n *\n * http://www.geeksforgeeks.org/maximum-product-subarray/\n * https://leetcode.com/problems/maximum-product-subarray/\n */\npublic class MaxProductSubarray {\n\n public int maxProduct(int[] nums) {\n //neg maintains the multiplication which is negative since last 0\n //pos maintains the multiplication which is positive since last 0\n int neg = 1;\n int pos = 1;\n int maxProduct = nums[0];\n for (int i = 0; i < nums.length; i++) {\n if (nums[i] == 0) {\n neg = 1;\n pos = 1;\n maxProduct = Math.max(maxProduct, 0);\n } else if (nums[i] < 0) {\n int temp = pos;\n if (neg < 0) {\n pos = neg * nums[i];\n maxProduct = Math.max(pos, maxProduct);\n } else {\n pos = 1;\n }\n neg = temp * nums[i];\n } else {\n if (neg < 0) {\n neg *= nums[i];\n }\n pos *= nums[i];\n maxProduct = Math.max(pos, maxProduct);\n }\n }\n return maxProduct;\n }\n \n public static void main(String args[]){\n MaxProductSubarray mps = new MaxProductSubarray();\n int input[] = {-6, -3, 8, -9, -1, -1, 3, 6, 9, 0, 3, -1};\n System.out.println(mps.maxProduct(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/MaxRepeatingNumber.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/find-the-maximum-repeating-number-in-ok-time/\n * Given an array of size n, the array contains numbers in range from 0 to k-1 \n * where k is a positive integer and k <= n.\n * Find the maximum repeating number in this array\n */\npublic class MaxRepeatingNumber {\n\n public int maxRepeatingNumber(int arr[], int k){\n int len = k;\n for(int i=0; i < arr.length; i++){\n arr[arr[i]%len] += len;\n }\n int maxRepeating = 0;\n int maxRepeatingIndex =0;\n for(int i=0; i < len; i++){\n if(maxRepeating < arr[i]){\n maxRepeating = arr[i];\n maxRepeatingIndex = i;\n }\n }\n for(int i=0; i < len; i++){\n arr[i] = arr[i] % len;\n }\n return maxRepeatingIndex;\n }\n \n public static void main(String args[]){\n MaxRepeatingNumber mrn = new MaxRepeatingNumber();\n int arr[] = {2,2,1,3,1,2,0,3,0,0,0,4,5,4,4,4,4};\n System.out.println(mrn.maxRepeatingNumber(arr, 6));\n }\n}\n"
},
{
"path": "src/com/interview/array/MaximumGap.java",
"content": "package com.interview.array;\n\n/**\n * Date 03/12/2016\n * @author Tushar Roy\n *\n * Given an unsorted array find maximum gap between consecutive element in sorted array.\n *\n * Time complexity O(n)\n * Space complexity O(n)\n *\n * Reference\n * https://leetcode.com/problems/maximum-gap/\n */\npublic class MaximumGap {\n\n class Bucket {\n int low ;\n int high;\n boolean isSet = false;\n void update(int val) {\n if (!isSet) {\n low = val;\n high = val;\n isSet = true;\n } else {\n low = Math.min(low, val);\n high = Math.max(high, val);\n }\n }\n }\n\n public int maximumGap(int[] input) {\n if (input == null || input.length < 2) {\n return 0;\n }\n int min = Integer.MAX_VALUE;\n int max = Integer.MIN_VALUE;\n\n for (int i = 0; i < input.length; i++) {\n min = Math.min(min, input[i]);\n max = Math.max(max, input[i]);\n }\n\n int gap = (int) Math.ceil((double) (max - min) / (input.length - 1));\n\n Bucket[] buckets = new Bucket[input.length - 1];\n\n for (int i = 0; i < buckets.length; i++) {\n buckets[i] = new Bucket();\n }\n\n for (int i = 0; i < input.length; i++) {\n if (input[i] == max || input[i] == min) {\n continue;\n }\n buckets[(input[i] - min) / gap].update(input[i]);\n }\n\n int prev = min;\n int maxGap = 0;\n for (int i = 0; i < buckets.length; i++) {\n if (!buckets[i].isSet) {\n continue;\n }\n maxGap = Math.max(maxGap, buckets[i].low - prev);\n prev = buckets[i].high;\n }\n\n return Math.max(maxGap, max - prev);\n }\n\n public static void main(String args[]) {\n int[] input = {4, 3, 13, 2, 9, 7};\n MaximumGap mg = new MaximumGap();\n System.out.println(mg.maximumGap(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/MaximumIminusJSuchThatAiGTAj.java",
"content": "package com.interview.array;\n\nimport java.util.Iterator;\nimport java.util.LinkedList;\n\n/**\n * http://www.geeksforgeeks.org/given-an-array-arr-find-the-maximum-j-i-such-that-arrj-arri/\n */\npublic class MaximumIminusJSuchThatAiGTAj {\n\n class Node{\n int index;\n int size;\n }\n \n public int maximumGeeks(int input[]){\n int lhs[] = new int[input.length];\n int rhs[] = new int[input.length];\n lhs[0] = 0;\n for(int i=1; i < lhs.length; i++){\n if(input[lhs[i-1]] < input[i]){\n lhs[i] = lhs[i-1];\n }else{\n lhs[i] = i;\n }\n }\n rhs[input.length-1] = input.length-1;\n for(int i=input.length-2; i >= 0; i--){\n if(input[rhs[i+1]] > input[i]){\n rhs[i] = rhs[i+1];\n }else{\n rhs[i] = i;\n }\n }\n \n int i=0;\n int j=0;\n int max = 0;\n for(;j < input.length;){\n if(input[lhs[i]] < input[rhs[j]]){\n max = Math.max(max, j-i);\n j++;\n }else{\n i++;\n }\n }\n return max;\n }\n \n public static void main(String args[]){\n MaximumIminusJSuchThatAiGTAj mj = new MaximumIminusJSuchThatAiGTAj();\n int input[] = {11,14,13,1,4,13,1,10};\n System.out.println(mj.maximumGeeks(input));\n }\n\n}\n"
},
{
"path": "src/com/interview/array/MaximumMinimumArrangement.java",
"content": "package com.interview.array;\n\n/**\n * Date 04/16/2016\n * @author Tushar Roy\n *\n * Given a sorted array of positive integers, rearrange the array alternately i.e first element should be maximum value,\n * second minimum value, third second max, fourth second min and so on.\n *\n * Time complexity O(n)\n * Space complexity O(1)\n *\n * http://www.geeksforgeeks.org/rearrange-array-maximum-minimum-form/\n */\npublic class MaximumMinimumArrangement {\n\n public void rearrange(int[] input) {\n for (int i = 0; i < input.length; i++) {\n int t = input[i];\n if (t < 0) {\n continue;\n }\n int i1 = i;\n while (true) {\n int j = i1 < input.length/2 ? 2 * i1 + 1 : (input.length - 1 - i1) * 2;\n if (j == i1) {\n break;\n }\n if (input[j] < 0) {\n break;\n }\n int t1 = input[j];\n input[j] = -t;\n t = t1;\n i1 = j;\n }\n }\n\n for (int i = 0; i < input.length; i++) {\n input[i] = Math.abs(input[i]);\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/MaximumOfSubarrayOfSizeK.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/maximum-of-all-subarrays-of-size-k/\n * Test cases\n * input containg neg and pos values\n * val of k is neg 0 or pos\n * val of k is larger than size of input\n * val of k is same as size of input\n */\nimport java.util.Deque;\nimport java.util.LinkedList;\n\npublic class MaximumOfSubarrayOfSizeK {\n\n public int[] maxSubArray(int input[], int k) {\n Deque queue = new LinkedList();\n int max[] = new int[input.length - k + 1];\n int maxVal = Integer.MIN_VALUE;\n //first find max of first k values and make it 0th element of max array\n for (int i = 0; i < k; i++) {\n if(maxVal < input[i]){\n maxVal = input[i];\n }\n if (queue.isEmpty()) {\n queue.offerLast(i);\n } else {\n while (!queue.isEmpty() && input[queue.peekLast()] <= input[i]) {\n queue.pollLast();\n }\n queue.offerLast(i);\n }\n \n }\n max[0] = maxVal;\n int index=1;\n //continue from k till end of the input array\n for (int i = k; i < input.length; i++) {\n //if index of peek is k distance from i then its no value to us.\n //throw it away\n if (i - k + 1 > queue.peekFirst()) {\n queue.pollFirst();\n }\n while (!queue.isEmpty() && input[queue.peekLast()] <= input[i]) {\n queue.pollLast();\n }\n queue.offerLast(i);\n //Only reason first element survived was because it was biggest element.\n //make it the max value for this k\n max[index] = input[queue.peekFirst()];\n index++;\n }\n return max;\n }\n \n public static void main(String args[]){\n int input[] = {8, 5, 10, 7, 9, 4, 15, 12, 90, 13};\n MaximumOfSubarrayOfSizeK msa = new MaximumOfSubarrayOfSizeK();\n int max[] = msa.maxSubArray(input, 4);\n for(int i : max){\n System.out.print(i + \" \");\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/MaximumSumPathTwoArrays.java",
"content": "package com.interview.array;\n\n/**\n * Date 12/31/2015\n * @author Tushar Roy\n *\n * Given two sorted arrays such the arrays may have some common elements. Find the sum of the maximum sum\n * path to reach from beginning of any array to end of any of the two arrays. We can switch from one array\n * to another array only at common elements.\n *\n * Time complexity is O(n + m)\n * Space complexity is O(1)\n *\n * http://www.geeksforgeeks.org/maximum-sum-path-across-two-arrays/\n */\npublic class MaximumSumPathTwoArrays {\n\n public int maxSum(int input1[], int input2[]) {\n int maxSum = 0;\n int i = 0, j = 0;\n int sum1 = 0;\n int sum2 = 0;\n while (i < input1.length && j < input2.length) {\n if (input1[i] == input2[j]) {\n if (sum1 > sum2) {\n maxSum += sum1 + input1[i];\n } else {\n maxSum += sum2 + input2[j];\n }\n i++;\n j++;\n sum1 = 0;\n sum2 = 0;\n } else if (input1[i] < input2[j]) {\n sum1 += input1[i++];\n } else {\n sum2 += input2[j++];\n }\n }\n while(i < input1.length) {\n sum1 += input1[i++];\n }\n while(j < input2.length) {\n sum2 += input2[j++];\n }\n\n if (sum1 > sum2) {\n maxSum += sum1;\n } else {\n maxSum += sum2;\n }\n return maxSum;\n }\n\n public static void main(String args[]) {\n int input1[] = {2, 3, 7, 10, 12, 15, 30, 34};\n int input2[] = {1, 5, 7, 8, 10, 15, 16, 19};\n\n MaximumSumPathTwoArrays msp = new MaximumSumPathTwoArrays();\n System.out.println(msp.maxSum(input1, input2));\n }\n}\n"
},
{
"path": "src/com/interview/array/MaximumSumThreeNonOverlappingSubarray.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\nimport java.util.Deque;\nimport java.util.LinkedList;\nimport java.util.List;\n\n/**\n *https://leetcode.com/problems/maximum-sum-of-3-non-overlapping-subarrays/description/\n */\npublic class MaximumSumThreeNonOverlappingSubarray {\n\n public int[] maxSumOfThreeSubarrays(int[] nums, int k) {\n int sum = 0;\n int[] sumArray = new int[nums.length - k + 1];\n for (int i = 0; i < nums.length; i++) {\n if (i < k) {\n sum += nums[i];\n } else {\n sumArray[i - k] = sum;\n sum += nums[i];\n sum -= nums[i - k];\n }\n }\n sumArray[sumArray.length - 1] = sum;\n\n int[][] dp = new int[4][sumArray.length + 1];\n\n for (int i = 1; i <= 3; i++) {\n for (int j = 1; j <= sumArray.length; j++) {\n if (j >= k) {\n if (dp[i][j - 1] >= sumArray[j - 1] + dp[i - 1][j - k]) {\n dp[i][j] = dp[i][j - 1];\n } else {\n dp[i][j] = sumArray[j - 1] + dp[i - 1][j - k];\n }\n } else {\n if (dp[i][j - 1] >= sumArray[j - 1]) {\n dp[i][j] = dp[i][j - 1];\n } else {\n dp[i][j] = sumArray[j - 1];\n }\n }\n }\n }\n int[] output = new int[3];\n int j = dp[0].length - 1;\n for (int i = 3; i > 0;) {\n if (dp[i][j] == dp[i][j - 1]) {\n j--;\n } else {\n output[i - 1] = j - 1;\n i--;\n j = j - k;\n }\n }\n return output;\n }\n\n public static void main(String[] args) {\n MaximumSumThreeNonOverlappingSubarray mss = new MaximumSumThreeNonOverlappingSubarray();\n int[] input = {3, 2, 2, 1, 1, 0, 5};\n int[] input1 = {1, 2, 1, 2, 6, 7, 5, 1};\n int[] output = mss.maxSumOfThreeSubarrays(input1, 2);\n for (int i : output) {\n System.out.println(i);\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/MeetingRooms.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\nimport java.util.PriorityQueue;\n\n/**\n * Date 05/01/2016\n * @author Tushar Roy\n *\n * Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],...] (si < ei),\n * find the minimum number of conference rooms required.\n *\n * Both methods have time comlexity of nlogn\n * Method 1 has space complexity of O(1)\n * \n * https://leetcode.com/problems/meeting-rooms-ii/\n */\npublic class MeetingRooms {\n\n public static class Interval {\n int start;\n int end;\n Interval() { start = 0; end = 0; }\n Interval(int s, int e) { start = s; end = e; }\n }\n\n public int minMeetingRooms1(Interval[] intervals) {\n int[] start = new int[intervals.length];\n int[] end = new int[intervals.length];\n\n for (int i = 0; i < intervals.length; i++) {\n start[i] = intervals[i].start;\n end[i] = intervals[i].end;\n }\n\n Arrays.sort(start);\n Arrays.sort(end);\n\n int j = 0;\n int rooms = 0;\n for (int i = 0; i < start.length; i++) {\n if (start[i] < end[j]) {\n rooms++;\n } else {\n j++;\n }\n }\n return rooms;\n }\n\n public int minMeetingRooms(Interval[] intervals) {\n if (intervals.length == 0) {\n return 0;\n }\n Arrays.sort(intervals, (a, b) -> a.start - b.start);\n PriorityQueue pq = new PriorityQueue<>((a, b) -> a.end - b.end);\n pq.offer(intervals[0]);\n int rooms = 1;\n for (int i = 1; i < intervals.length; i++) {\n Interval it = pq.poll();\n if (it.end <= intervals[i].start) {\n it = new Interval(it.start, intervals[i].end);\n } else {\n rooms++;\n pq.offer(intervals[i]);\n }\n pq.offer(it);\n }\n return rooms;\n }\n}\n"
},
{
"path": "src/com/interview/array/MinimumDistanceBetweenTwoNumbers.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/find-the-minimum-distance-between-two-numbers/\n */\npublic class MinimumDistanceBetweenTwoNumbers {\n\n public int minDistance(int input[],int x, int y){\n int prev = -1;\n int prevFound = -1;\n int min = 10000;\n for(int i=0; i < input.length; i++){\n if(input[i] == x){\n if(prevFound == -1){\n prevFound = x;\n prev = i;\n }else if(prevFound == x){\n prev = i;\n }else{\n min = min > i - prev ? i -prev : min;\n prev = i;\n prevFound = x;\n }\n }else if(input[i] == y){\n if(prevFound == -1){\n prevFound = y;\n prev = i;\n }else if(prevFound == y){\n prev =i;\n }else{\n min = min > i - prev ? i -prev : min;\n prevFound = y;\n prev = i;\n }\n }\n }\n return min;\n }\n \n public static void main(String args[]){\n MinimumDistanceBetweenTwoNumbers mdb = new MinimumDistanceBetweenTwoNumbers();\n int input[] = {6,4,1,5,6,9,10,4,6,6};\n System.out.println(mdb.minDistance(input, 5, 6));\n }\n}\n"
},
{
"path": "src/com/interview/array/MinimumNumberFromSequence.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n/**\n * Date 02/26/2016\n * @author Tushar Roy\n *\n * Time complexity : O(n^2)\n * Space complexity : O(n)\n *\n * Reference\n * http://www.geeksforgeeks.org/form-minimum-number-from-given-sequence/\n */\npublic class MinimumNumberFromSequence {\n\n public int[] find(char[] input) {\n int[] output = new int[input.length + 1];\n output[0] = 1;\n int low = 0;\n int start = 0;\n for (int i = 0; i < input.length; i++) {\n if (input[i] == 'D') {\n output[i + 1] = output[i] - 1;\n if (output[i+1] == low) {\n for (int j = start; j <= i + 1; j++) {\n output[j] = output[j] + 1;\n }\n }\n } else {\n low = output[start];\n output[i + 1] = low + 1;\n start = i + 1;\n }\n }\n return output;\n }\n\n public static void main(String args[]) {\n MinimumNumberFromSequence ms = new MinimumNumberFromSequence();\n int output[] = ms.find(\"DDIDDIID\".toCharArray());\n System.out.println(Arrays.toString(output));\n\n output = ms.find(\"IIDDD\".toCharArray());\n System.out.println(Arrays.toString(output));\n\n output = ms.find(\"DIDI\".toCharArray());\n System.out.println(Arrays.toString(output));\n\n }\n}\n"
},
{
"path": "src/com/interview/array/MinimumSortedWhichSortsEntireArray.java",
"content": "package com.interview.array;\n\n/**\n *http://www.geeksforgeeks.org/minimum-length-unsorted-subarray-sorting-which-makes-the-complete-array-sorted/\n */\npublic class MinimumSortedWhichSortsEntireArray {\n\n public int minLength(int arr[]){\n int i=0;\n while(i < arr.length -1 && arr[i] < arr[i+1]){\n i++;\n }\n if(i == arr.length-1){\n return 0;\n }\n int j = arr.length-1;\n while(j > 0 && arr[j] > arr[j-1]){\n j--;\n }\n \n int max = Integer.MIN_VALUE;\n int min = Integer.MAX_VALUE;\n for(int k = i; k <= j; k++){\n if(max < arr[k]){\n max = arr[k];\n }\n if(min > arr[k]){\n min = arr[k];\n }\n }\n int x = i-1;\n while(x >=0){\n if(min > arr[x]){\n break;\n }\n x--;\n }\n \n int y = j +1;\n while(y < arr.length){\n if(max < arr[y]){\n break;\n }\n y++;\n }\n return y -x -2 + 1;\n }\n \n public static void main(String args[]){\n int arr[] = {4,5,10,21,18,23,7,8,19,34,38};\n int arr1[] = {4,5,6,12,11,15};\n int arr2[] = {4,5,6,10,11,15};\n MinimumSortedWhichSortsEntireArray msw = new MinimumSortedWhichSortsEntireArray();\n System.out.println(msw.minLength(arr1));\n }\n \n}\n"
},
{
"path": "src/com/interview/array/MissingRanges.java",
"content": "package com.interview.array;\n\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.List;\n\n/**\n * Given a sorted integer array where the range of elements are in the inclusive range [lower, upper], return its missing ranges.\n * For example, given [0, 1, 3, 50, 75], lower = 0 and upper = 99, return [\"2\", \"4->49\", \"51->74\", \"76->99\"].\n *\n * Time complexity O(n)\n *\n * https://leetcode.com/problems/missing-ranges/\n */\npublic class MissingRanges {\n public List findMissingRanges(int[] nums, int lower, int upper) {\n if (nums.length == 0) {\n return Collections.singletonList(makeRange(lower, upper));\n }\n List result = new ArrayList<>();\n if (lower < nums[0]) {\n result.add(makeRange(lower, nums[0] - 1));\n }\n for (int i = 0; i < nums.length - 1; i++) {\n if (nums[i] == nums[i + 1]) {\n continue;\n }\n if ((nums[i] + 1) != nums[i + 1]) {\n result.add(makeRange(nums[i] + 1, nums[i + 1] - 1));\n }\n }\n if (nums[nums.length - 1] < upper) {\n result.add(makeRange(nums[nums.length - 1] + 1, upper));\n }\n return result;\n }\n\n private String makeRange(int a, int b) {\n if (a == b) {\n return String.valueOf(a);\n } else {\n return a + \"->\" + b;\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/MoveAllZerosToEnd.java",
"content": "package com.interview.array;\n\npublic class MoveAllZerosToEnd {\n\n public void moveZeros(int arr[]){\n int slow =0;\n int fast =0;\n while(fast < arr.length){\n if(arr[fast] == 0){\n fast++;\n continue;\n }\n arr[slow] = arr[fast];\n slow++;\n fast++;\n }\n while(slow < arr.length){\n arr[slow++] = 0;\n }\n }\n \n public static void main(String args[]){\n MoveAllZerosToEnd maz = new MoveAllZerosToEnd();\n int arr[] = {0,0,1,2,0,5,6,7,0};\n maz.moveZeros(arr);\n for(int i=0; i < arr.length; i++){\n System.out.print(arr[i]);\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/MultiplyAllFieldsExceptOwnPosition.java",
"content": "package com.interview.array;\n\n/**\n * https://leetcode.com/problems/product-of-array-except-self/\n */\npublic class MultiplyAllFieldsExceptOwnPosition {\n\n public int[] multiply(int nums[]) {\n if (nums.length == 0) {\n return new int[0];\n }\n int[] output = new int[nums.length];\n output[0] = 1;\n for (int i = 1; i < nums.length; i++) {\n output[i] = output[i - 1] * nums[i - 1];\n }\n\n int mult = 1;\n for (int i = nums.length - 1; i >= 0; i--) {\n output[i] *= mult;\n mult *= nums[i];\n }\n return output;\n }\n}\n"
},
{
"path": "src/com/interview/array/NthElementOfCountNumberSequence.java",
"content": "package com.interview.array;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\n/**\n * Date 07/20/2015\n * @author Tushar Roy\n *\n * Given a sequence like\n * 1 11 21 1211 111221 312211\n * Print nth element of this sequence.\n */\npublic class NthElementOfCountNumberSequence {\n\n public List nthElement(int n) {\n int i = 1;\n List current = new ArrayList<>();\n current.add(1);\n List result = new ArrayList<>();\n while(i < n) {\n int count = 1;\n int index = 0;\n for(int j = 1; j < current.size(); j++) {\n if(current.get(index) == current.get(j)) {\n count++;\n } else {\n result.add(count);\n result.add(current.get(index));\n count = 1;\n index = j;\n }\n }\n result.add(count);\n result.add(current.get(index));\n current = result;\n result = new ArrayList<>();\n i++;\n }\n return current;\n }\n\n public static void main(String args[]) {\n NthElementOfCountNumberSequence nes = new NthElementOfCountNumberSequence();\n for(int i = 1 ; i <= 10; i++) {\n List result = nes.nthElement(i);\n result.forEach(System.out::print);\n System.out.println();\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/NumberOfTrianglesInUnsortedArray.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n/**\n * http://www.geeksforgeeks.org/find-number-of-triangles-possible/\n */\npublic class NumberOfTrianglesInUnsortedArray {\n\n public int numberOfTriangles(int input[]){\n Arrays.sort(input);\n \n int count = 0;\n for(int i=0; i < input.length-2; i++){\n int k = i+2;\n for(int j=i+1; j < input.length; j++){\n while(k < input.length && input[i] + input[j] > input[k]){\n k++;\n }\n count += k - j -1;\n }\n }\n return count;\n \n }\n \n public static void main(String args[]){\n int input[] = {3, 4, 5, 6, 8, 9, 15};\n NumberOfTrianglesInUnsortedArray not = new NumberOfTrianglesInUnsortedArray();\n System.out.println(not.numberOfTriangles(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/PositiveAndNegativeNumberAlternatively.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/rearrange-positive-and-negative-numbers-publish/\n */\npublic class PositiveAndNegativeNumberAlternatively {\n\n public void arrange(int arr[]){\n int startOfPos = segregate(arr);\n \n int startOfNeg = 1;\n while(startOfNeg < startOfPos && startOfPos < arr.length){\n swap(arr,startOfNeg,startOfPos);\n startOfNeg+=2;\n startOfPos++;\n }\n }\n \n private int segregate(int arr[]){\n int low =0;\n int high = arr.length-1;\n while(low < high){\n if(arr[low] < 0){\n low++;\n }else if(arr[high] >= 0){\n high--;\n }else{\n swap(arr,low,high);\n }\n }\n return low;\n }\n \n private void swap(int arr[],int i,int j){\n int t = arr[i];\n arr[i] = arr[j];\n arr[j] = t;\n }\n \n public static void main(String args[]){\n int arr[] = {-1,-2,-3,-4,-5,1,2,3,4,5};\n PositiveAndNegativeNumberAlternatively pan = new PositiveAndNegativeNumberAlternatively();\n pan.arrange(arr);\n for(int i=0; i < arr.length; i++){\n System.out.print(arr[i]+ \" \");\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/PositiveAndNegativeNumberAlternativelyMaintainingOrder.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n/**\n * Date 12/31/2015\n * @author Tushar Roy\n *\n * Given an array of positive and negative integers arrange them alternatively maintaining initial order.\n * If there are more +ve or -ve integer then push them to the end together.\n *\n * Time complexity is O(n)\n * Space complexity is O(1)\n *\n * http://www.geeksforgeeks.org/rearrange-array-alternating-positive-negative-items-o1-extra-space/\n */\npublic class PositiveAndNegativeNumberAlternativelyMaintainingOrder {\n\n public void rearrange(int input[]) {\n\n for (int i = 0; i < input.length; i++) {\n if (i % 2 == 0 && input[i] >= 0) {\n int indexOfNextNegative = findNext(input, i + 1, false);\n if (indexOfNextNegative == -1) {\n return;\n } else {\n rightRotate(input, i, indexOfNextNegative);\n }\n } else if (i % 2 != 0 && input[i] < 0) {\n int indexOfNextPositive = findNext(input, i + 1, true);\n if (indexOfNextPositive == -1) {\n return;\n } else {\n rightRotate(input, i, indexOfNextPositive);\n }\n }\n }\n }\n\n private int findNext(int input[], int start, boolean isPositive) {\n for (int i = start; i < input.length; i++) {\n if ((isPositive && input[i] >= 0) || (!isPositive && input[i] < 0)) {\n return i;\n }\n }\n return -1;\n }\n\n private void rightRotate(int input[], int start, int end) {\n int t = input[end];\n for (int i = end; i > start; i--) {\n input[i] = input[i - 1];\n }\n input[start] = t;\n }\n\n public static void main(String args[]) {\n int input[] = {-5, -2, 5, 2, 4, 7, 1, 8, 0, -8};\n PositiveAndNegativeNumberAlternativelyMaintainingOrder pss = new PositiveAndNegativeNumberAlternativelyMaintainingOrder();\n pss.rearrange(input);\n Arrays.stream(input).forEach(i -> System.out.print(i + \" \"));\n }\n}\n"
},
{
"path": "src/com/interview/array/RearrangeArrayPerIndex.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n/**\n * Date 12/30/2015\n *\n * Given an array of size n where elements are in range 0 to n-1. Rearrange elements of array\n * such that if arr[i] = j then arr[j] becomes i.\n *\n * Time complexity O(n)\n * Space complexity O(1)\n *\n * http://www.geeksforgeeks.org/rearrange-array-arrj-becomes-arri-j/\n */\npublic class RearrangeArrayPerIndex {\n\n public void rearrange(int input[]) {\n\n for (int i = 0; i < input.length; i++) {\n input[i]++;\n }\n\n for (int i = 0; i < input.length; i++) {\n if (input[i] > 0) {\n rearrangeUtil(input, i);\n }\n }\n\n for (int i = 0; i < input.length; i++) {\n input[i] = -input[i] - 1;\n }\n }\n\n private void rearrangeUtil(int input[], int start) {\n int i = start + 1;\n int v = input[start];\n while (v > 0) {\n int t = input[v - 1];\n input[v - 1] = -i;\n i = v;\n v = t;\n }\n }\n\n public static void main(String args[]) {\n RearrangeArrayPerIndex rai = new RearrangeArrayPerIndex();\n int input[] = {1, 2, 0, 5, 3, 4};\n rai.rearrange(input);\n Arrays.stream(input).forEach(i -> System.out.print(i + \" \"));\n }\n\n}\n"
},
{
"path": "src/com/interview/array/RearrangeSuchThatArriBecomesArrArri.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/rearrange-given-array-place/\n */\npublic class RearrangeSuchThatArriBecomesArrArri {\n\n public void rearrange(int arr[]){\n for(int i=0; i < arr.length; i++){\n int temp;\n if(arr[arr[i]] > arr.length-1){\n temp = arr[arr[i]]/arr.length-1;\n }else{\n temp = arr[arr[i]];\n }\n arr[i] = temp + arr.length*(arr[i]+1);\n }\n \n for(int i=0; i < arr.length;i++){\n arr[i] = arr[i] % arr.length;\n }\n }\n \n public static void main(String args[]){\n int arr[] = {4,2,0,1,3};\n RearrangeSuchThatArriBecomesArrArri rss = new RearrangeSuchThatArriBecomesArrArri();\n rss.rearrange(arr);\n for(int i=0; i < arr.length; i++){\n System.out.print(arr[i]);\n }\n }\n}\n\n"
},
{
"path": "src/com/interview/array/ReorderArrayByIndex.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n/**\n * Date 12/29/2015\n * @author Tushar Roy\n *\n * Given two arrays one with values and other with index where values should be positioned. Move values to correct\n * position\n *\n * Time complexity - O(n)\n * Space complexity - O(1)\n *\n * http://www.geeksforgeeks.org/reorder-a-array-according-to-given-indexes/\n */\npublic class ReorderArrayByIndex {\n public void reorder(int input[], int index[]) {\n if(index.length != input.length) {\n throw new IllegalArgumentException();\n }\n for (int i = 0 ; i < index.length; i++) {\n while (index[i] != i) {\n int sIndex = index[index[i]];\n int sVal = input[index[i]];\n\n index[index[i]] = index[i];\n input[index[i]] = input[i];\n\n index[i] = sIndex;\n input[i] = sVal;\n }\n }\n }\n\n public static void main(String args[]) {\n int input[] = {50, 40, 70, 60, 90};\n int index[] = {3, 0, 4, 1, 2};\n ReorderArrayByIndex reorderArrayByIndex = new ReorderArrayByIndex();\n reorderArrayByIndex.reorder(input, index);\n Arrays.stream(input).forEach(i -> System.out.print(i + \" \"));\n System.out.println();\n Arrays.stream(index).forEach(i -> System.out.print(i + \" \"));\n }\n}\n"
},
{
"path": "src/com/interview/array/RepeatingAndMissingNumber.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/find-a-repeating-and-a-missing-number/\n */\npublic class RepeatingAndMissingNumber {\n\n class Pair{\n int repeating;\n int missing;\n public String toString(){\n return repeating + \" \" + missing;\n }\n }\n \n public Pair findNumbers(int input[]){\n Pair p = new Pair();\n for(int i=0; i < input.length; i++){\n if(input[Math.abs(input[i])-1] < 0){\n p.repeating = Math.abs(input[i]);\n }else{\n input[Math.abs(input[i])-1] = -input[Math.abs(input[i])-1];\n }\n }\n \n for(int i=0; i < input.length; i++){\n if(input[i] < 0){\n input[i] = -input[i];\n }else{\n p.missing = i + 1;\n }\n }\n return p;\n }\n \n public static void main(String args[]){\n RepeatingAndMissingNumber rmn = new RepeatingAndMissingNumber();\n int input[] = {3,1,2,4,6,8,2,7};\n System.out.println(rmn.findNumbers(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/RotationWithMaxSum.java",
"content": "package com.interview.array;\n\n/**\n * Date 12/30/2015\n * @author Tushar Roy\n *\n * Given an input array find which rotation will give max sum of i * arr[i]\n *\n * Time complexity - O(n)\n * Space complexity - O(1)\n *\n * http://www.geeksforgeeks.org/find-maximum-value-of-sum-iarri-with-only-rotations-on-given-array-allowed/\n */\npublic class RotationWithMaxSum {\n int maxSum(int input[]) {\n int arrSum = 0;\n int rotationSum = 0;\n for (int i =0; i < input.length; i++) {\n arrSum += input[i];\n rotationSum += i*input[i];\n }\n\n int maxRotationSum = rotationSum;\n\n for (int i = 1; i < input.length; i++) {\n rotationSum += input.length*input[i - 1] - arrSum;\n maxRotationSum = Math.max(maxRotationSum, rotationSum);\n }\n return maxRotationSum;\n }\n\n public static void main(String args[]) {\n int input[] = {10, 1, 2, 3, 4, 5, 6, 7, 8, 9};\n RotationWithMaxSum rms = new RotationWithMaxSum();\n System.out.print(rms.maxSum(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/SelfCrossing.java",
"content": "package com.interview.array;\n\n/**\n * Created by tushar_v_roy on 3/10/16.\n */\npublic class SelfCrossing {\n\n public boolean isSelfCrossing(int[] x) {\n if (x.length < 4) {\n return false;\n }\n int v1 = -x[0];\n int v2 = -x[1];\n\n int i = 2;\n while (i < x.length) {\n if (i % 2 == 0) {\n if (i % 4 == 0) {\n v1 -= x[i];\n } else {\n v1 += x[i];\n }\n } else {\n if ((i + 1) % 4 == 0) {\n v2 += x[i];\n } else {\n v2 -= x[i];\n }\n }\n if (i % 2 != 0) {\n if ((v1 >= 0 && v2 <= 0) || (v1 <= 0 && v2 >= 0)) {\n return true;\n }\n }\n i++;\n }\n return false;\n }\n\n public static void main(String args[]) {\n SelfCrossing sc = new SelfCrossing();\n int input[] = {3, 3, 4, 2, 2};\n System.out.print(sc.isSelfCrossing(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/ShortestPalindrome.java",
"content": "package com.interview.array;\n\n/**\n * Date 03/04/2016\n * @author Tushar Roy\n *\n * How to append minimum numbers of characters in front of string to make it a palindrome.\n *\n * Idea is to create a new string which is original ttring + $ + reverse of original string\n * Get value of suffix which is also prefix using KMP.\n * This part of string is good. Rest needs to be copied in the front.\n *\n * Time complexity is O(n)\n * Space complexity is O(n)\n *\n * https://leetcode.com/problems/shortest-palindrome/\n */\npublic class ShortestPalindrome {\n public String shortestPalindrome(String s) {\n char[] input = createInput(s);\n int val = kmp(input);\n\n StringBuffer sb = new StringBuffer();\n int remaining = s.length() - val;\n int i = s.length() - 1;\n while (remaining > 0) {\n sb.append(s.charAt(i));\n i--;\n remaining--;\n }\n sb.append(s);\n return sb.toString();\n\n }\n\n private int kmp(char[] input) {\n int T[] = new int[input.length];\n\n int j = 1;\n int i = 0;\n\n T[0] = 0;\n\n while (j < input.length) {\n if (input[i] == input[j]) {\n T[j] = i + 1;\n i++;\n } else {\n while (i != 0) {\n i = T[i-1];\n if (input[j] == input[i]) {\n T[j] = i + 1;\n i++;\n break;\n }\n }\n }\n j++;\n }\n return T[input.length - 1];\n }\n\n private char[] createInput(String s) {\n char[] input = new char[2*s.length() + 1];\n int index = 0;\n for (char ch: s.toCharArray()) {\n input[index++] = ch;\n }\n input[index++] = '$';\n\n for (int i = s.length() - 1; i >= 0; i--) {\n input[index++] = s.charAt(i);\n }\n return input;\n }\n\n public static void main(String args[]) {\n ShortestPalindrome sp = new ShortestPalindrome();\n System.out.print(sp.shortestPalindrome(\"aacecaaa\"));\n }\n }\n"
},
{
"path": "src/com/interview/array/SmallestIntegerNotRepresentedBySubsetSum.java",
"content": "package com.interview.array;\n\n/**\n * Date 12/31/2015\n * @author Tushar Roy\n *\n * Given array in non decreasing order find smallest integer which cannot be represented by\n * subset sum of these integers.\n *\n * Time complexity is O(n)\n *\n * http://www.geeksforgeeks.org/find-smallest-value-represented-sum-subset-given-array/\n */\npublic class SmallestIntegerNotRepresentedBySubsetSum {\n\n public int findSmallestInteger(int input[]) {\n int result = 1;\n for (int i = 0; i < input.length; i++) {\n if (input[i] <= result) {\n result += input[i];\n } else {\n break;\n }\n }\n return result;\n }\n\n /**\n * Leetcode variation https://leetcode.com/problems/patching-array/\n */\n public int minPatches(int[] nums, int n) {\n int patch = 0;\n long t = 1;\n int i = 0;\n while(t <= n) {\n if (i == nums.length || t < nums[i]) {\n patch++;\n t += t;\n } else {\n t = nums[i] + t;\n i++;\n }\n }\n return patch;\n }\n\n\n public static void main(String args[]) {\n int input[] = {1, 2, 3, 8};\n SmallestIntegerNotRepresentedBySubsetSum ss = new SmallestIntegerNotRepresentedBySubsetSum();\n System.out.println(ss.findSmallestInteger(input));\n\n int input1[] = {};\n System.out.println(ss.minPatches(input1, 7));\n }\n}\n"
},
{
"path": "src/com/interview/array/SmallestSubarrayWithAtleastKSum.java",
"content": "package com.interview.array;\n\n/**\n * https://leetcode.com/problems/shortest-subarray-with-sum-at-least-k/description/\n */\npublic class SmallestSubarrayWithAtleastKSum {\n\n public int shortestSubarray(int[] A, int K) {\n int[] skip = new int[A.length];\n\n int sum = 0;\n int start = A.length - 1;\n skip[A.length - 1] = 1;\n for (int i = A.length - 1; i > 0; i--) {\n skip[i - 1] = 1;\n sum += A[i];\n if (sum <= 0) {\n skip[i - 1] = start - i + 1;\n } else {\n start = i;\n sum = 0;\n }\n }\n\n start = 0;\n int end = 0;\n sum = 0;\n int min = Integer.MAX_VALUE;\n while (end < A.length) {\n sum += A[end++];\n while (start <= end && sum >= K) {\n min = Math.min(end - start, min);\n for (int j = start; j < start + skip[start]; j++) {\n sum -= A[j];\n }\n start = start + skip[start];\n }\n if (sum <= 0) {\n start = end;\n sum = 0;\n }\n }\n\n return min == Integer.MAX_VALUE ? -1 : min;\n }\n\n public static void main(String[] args) {\n int[] input = {1, 3, -1, -4, -2, 3, 4, -5, -1, 8};\n SmallestSubarrayWithAtleastKSum ss = new SmallestSubarrayWithAtleastKSum();\n ss.shortestSubarray(input, 8);\n }\n}\n"
},
{
"path": "src/com/interview/array/SortedArrayTransformation.java",
"content": "package com.interview.array;\n\n/**\n * Date 10/08/2016\n * @author Tushar Roy\n *\n * Given a sorted array of integers nums and integer values a, b and c.\n * Apply a function of the form f(x) = ax2 + bx + c to each element x in the array.\n *\n * Time complexity O(n)\n *\n * https://leetcode.com/problems/sort-transformed-array/\n */\npublic class SortedArrayTransformation {\n public int[] sortTransformedArray(int[] nums, int a, int b, int c) {\n int start = 0;\n int end = nums.length - 1;\n int[] result = new int[nums.length];\n int index = (a >= 0 ? nums.length - 1 : 0);\n while (start <= end) {\n int x = apply(nums[start], a, b, c);\n int y = apply(nums[end], a, b, c);\n boolean condition = (a >= 0 ? x >= y : x <= y);\n if (condition) {\n result[index] = x;\n start++;\n } else {\n result[index] = y;\n end--;\n }\n index = index + (a >= 0 ? -1 : 1);\n }\n return result;\n }\n\n private int apply(int x, int a, int b, int c) {\n return a*x*x + b * x + c;\n }\n}\n"
},
{
"path": "src/com/interview/array/StableMarriageProblem.java",
"content": "package com.interview.array;\n\npublic class StableMarriageProblem {\n\n private boolean checkIfNewIsBetter(int priority[][], int bride,\n int currentGroom, int suitor) {\n for (int groom : priority[bride]) {\n if (currentGroom == groom) {\n return false;\n }\n if (suitor == groom) {\n return true;\n }\n }\n return false;\n }\n\n public int[] findPair(int[][] priority) {\n int pair = priority[0].length;\n int groomToBride[] = new int[pair];\n int brideToGroom[] = new int[pair];\n for(int i=0; i < groomToBride.length; i++){\n groomToBride[i] = -1;\n }\n for(int i=0; i < brideToGroom.length; i++){\n brideToGroom[i] = -1;\n }\n int groom ;\n int remaingGrooms = pair;\n while (remaingGrooms > 0) {\n groom = -1;\n for (int hasBride : groomToBride) {\n if (hasBride != -1) {\n continue;\n }\n groom++;\n for (int bride : priority[groom]) {\n if (brideToGroom[bride-pair] == -1) {\n groomToBride[groom] = bride;\n brideToGroom[bride-pair] = groom;\n remaingGrooms--;\n break;\n } else {\n boolean flag = checkIfNewIsBetter(priority, bride,\n brideToGroom[bride-pair], groom);\n if (flag) {\n int currentGroom = brideToGroom[bride-pair];\n brideToGroom[bride-pair] = groom;\n groomToBride[groom] = bride;\n groomToBride[currentGroom] = -1;\n }\n }\n }\n }\n }\n return groomToBride;\n }\n \n public static void main(String args[]){\n int priority[][] = {{5,4,7,6},\n {4,5,6,7},\n {5,4,6,7},\n {5,4,7,6},\n {0,1,2,3},\n {0,1,3,2},\n {0,3,1,2},\n {0,1,2,3}};\n StableMarriageProblem smp = new StableMarriageProblem();\n int[] result = smp.findPair(priority);\n for(int i=0; i < result.length; i++){\n System.out.println(i + \" \" + result[i]);\n }\n }\n}\n"
},
{
"path": "src/com/interview/array/SubarrayWithGivenSum.java",
"content": "package com.interview.array;\n\n/**\n * http://www.geeksforgeeks.org/find-subarray-with-given-sum/\n */\npublic class SubarrayWithGivenSum {\n\n class Pair{\n int start;\n int end;\n \n public String toString(){\n return start + \" \" + end;\n }\n }\n public Pair findSubArray(int input[],int sum){\n int currentSum = 0;\n Pair p = new Pair();\n p.start = 0;\n for(int i=0; i < input.length; i++){\n currentSum += input[i];\n p.end = i;\n if(currentSum == sum){\n return p;\n }else if(currentSum > sum){\n int s = p.start;\n while(currentSum > sum){\n currentSum -= input[s];\n s++;\n }\n p.start = s;\n if(currentSum == sum){\n return p;\n }\n }\n }\n return null;\n }\n \n public static void main(String args[]){\n SubarrayWithGivenSum sgs = new SubarrayWithGivenSum();\n int input[] = {6,3,9,11,1,3,5};\n System.out.println(sgs.findSubArray(input,15));\n }\n}\n"
},
{
"path": "src/com/interview/array/SummaryRanges.java",
"content": "package com.interview.array;\n\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.List;\n\n/**\n * Date 10/19/2016\n * @author Tushar Roy\n *\n * Given a sorted integer array without duplicates, return the summary of its ranges.\n * For example, given [0,1,2,4,5,7], return [\"0->2\",\"4->5\",\"7\"].\n *\n * Solution -\n * Just check if num[i] + 1 != num[i + 1]. If its not equal means you need to add previous range to result\n * and start a new range.\n * \n * Time complexity O(n)\n *\n * https://leetcode.com/problems/summary-ranges/\n */\npublic class SummaryRanges {\n public List summaryRanges(int[] nums) {\n if (nums.length == 0) {\n return Collections.EMPTY_LIST;\n }\n if (nums.length == 1) {\n return Collections.singletonList(String.valueOf(nums[0]));\n }\n int start = 0;\n List result = new ArrayList<>();\n for (int i = 0; i < nums.length - 1; i++) {\n if ((nums[i] + 1) != nums[i + 1]) {\n result.add(makeRange(nums[start], nums[i]));\n start = i + 1;\n }\n }\n if ((nums[nums.length - 2] + 1) != nums[nums.length - 1]) {\n start = nums.length - 1;\n }\n result.add(makeRange(nums[start], nums[nums.length - 1]));\n return result;\n }\n\n private String makeRange(int a, int b) {\n if (a == b) {\n return String.valueOf(a);\n }\n return a + \"->\" + b;\n }\n}\n"
},
{
"path": "src/com/interview/array/ThreeSumSmallerThanTarget.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n/**\n * Given an array of n integers nums and a target, find the number of index triplets i, j, k\n * with 0 <= i < j < k < n that satisfy the condition nums[i] + nums[j] + nums[k] < target.\n *\n * https://leetcode.com/problems/3sum-smaller/\n */\npublic class ThreeSumSmallerThanTarget {\n public int threeSumSmaller(int[] nums, int target) {\n if (nums.length < 3) {\n return 0;\n }\n Arrays.sort(nums);\n int count = 0;\n for (int i = 0; i < nums.length; i++) {\n int j = i + 1;\n int k = nums.length - 1;\n while (j < k) {\n if (nums[i] + nums[j] + nums[k] >= target) {\n k--;\n } else {\n count += k - j;\n j++;\n }\n }\n }\n return count;\n }\n}\n"
},
{
"path": "src/com/interview/array/TrappingWater.java",
"content": "package com.interview.array;\n/**\n * References\n * https://oj.leetcode.com/problems/trapping-rain-water/\n * https://leetcode.com/problems/trapping-rain-water/\n */\npublic class TrappingWater {\n\n public int trap(int[] height) {\n if(height == null || height.length == 0) {\n return 0;\n }\n int len = height.length;\n int left[] = new int[len];\n int right[] = new int[len];\n left[0] = height[0];\n right[len-1] = height[len -1];\n for (int i = 1; i < len; i++) {\n left[i] = Math.max(height[i], left[i-1]);\n right[len - i - 1] = Math.max(height[len- i - 1], right[len-i]);\n }\n\n int maxWaterTrapped = 0;\n for (int i = 1; i < len - 1; i++) {\n int min = Math.min(left[i], right[i]);\n if (height[i] < min) {\n maxWaterTrapped += min - height[i];\n }\n }\n return maxWaterTrapped;\n }\n\n public static void main(String args[]){\n int input[] = {0,1,0,2,1,0,1,3,2,1,2,1};\n TrappingWater tw = new TrappingWater();\n System.out.println(tw.trap(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/TripletInArray.java",
"content": "package com.interview.array;\n\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\n/**\n * http://www.geeksforgeeks.org/find-a-triplet-that-sum-to-a-given-value/\n */\npublic class TripletInArray {\n\n class Triplet {\n int a;\n int b;\n int c;\n\n public String toString() {\n return a + \" \" + b + \" \" + c;\n }\n }\n\n public Triplet findTriplet(int input[], int sum) {\n Arrays.sort(input);\n for (int i = 0; i < input.length - 2; i++) {\n\n int start = i + 1;\n int end = input.length - 1;\n int new_sum = sum - input[i];\n while (start < end) {\n if (new_sum == input[start] + input[end]) {\n Triplet t = new Triplet();\n t.a = input[i];\n t.b = input[start];\n t.c = input[end];\n return t;\n }\n if (new_sum > input[start] + input[end]) {\n start++;\n } else {\n end--;\n }\n }\n }\n return null;\n }\n\n /**\n * https://leetcode.com/problems/3sum/\n */\n public List> threeSum(int[] nums) {\n Arrays.sort(nums);\n List> result = new ArrayList<>();\n for (int i = 0; i < nums.length - 2; i++) {\n if (i != 0 && nums[i] == nums[i-1]) {\n continue;\n }\n int start = i + 1;\n int end = nums.length - 1;\n while (start < end) {\n if (nums[i] + nums[start] + nums[end] == 0) {\n List r = new ArrayList<>();\n r.add(nums[i]);\n r.add(nums[start]);\n r.add(nums[end]);\n result.add(r);\n start++;\n end--;\n while(start < nums.length && nums[start] == nums[start - 1]) {\n start++;\n }\n while(end >= 0 && nums[end] == nums[end+1]) {\n end--;\n }\n } else if (nums[i] + nums[start] + nums[end] < 0) {\n start++;\n } else {\n end--;\n }\n }\n }\n return result;\n }\n\n public static void main(String args[]){\n TripletInArray tip = new TripletInArray();\n int input[] = {1,2,6,9,11,18,26,28};\n int sum = 22;\n System.out.println(tip.findTriplet(input, sum));\n }\n}\n"
},
{
"path": "src/com/interview/array/TripletSumLessThanTotal.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n/**\n * Date 12/29/2015\n * @author Tushar Roy\n *\n * Given array with unique numbers and a total, find all triplets whose sum is less than total\n *\n * http://www.geeksforgeeks.org/count-triplets-with-sum-smaller-that-a-given-value/\n */\npublic class TripletSumLessThanTotal {\n\n public int findAllTriplets(int input[], int total) {\n Arrays.sort(input);\n int result = 0;\n for (int i = 0; i < input.length - 2; i++) {\n int j = i + 1;\n int k = input.length - 1;\n\n while (j < k) {\n if (input[i] + input[j] + input[k] >= total) {\n k--;\n } else {\n result += k - j;\n j++;\n }\n }\n }\n return result;\n }\n\n public static void main(String args[]) {\n int input[] = {5, 1, 3, 4, 7};\n TripletSumLessThanTotal tt = new TripletSumLessThanTotal();\n System.out.print(tt.findAllTriplets(input, 12));\n }\n}\n"
},
{
"path": "src/com/interview/array/TugOfWar.java",
"content": "package com.interview.array;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\n/*\n * http://www.geeksforgeeks.org/tug-of-war/\n */\npublic class TugOfWar {\n\n private int minFoundSoFar = 1000000;\n public int findMind(int arr[]){\n int total = 0;\n for(int i=0; i < arr.length; i++){\n total += arr[i];\n }\n List result = new ArrayList<>();\n combinationUtil(arr,arr.length/2,0,0,total,0,result);\n return minFoundSoFar;\n }\n\n private void combinationUtil(int arr[],int k, int start,int sum, int total,int pos, List result){\n if(pos == k){\n if(Math.abs(sum - total/2) < minFoundSoFar) {\n minFoundSoFar = Math.abs(sum - total/2);\n System.out.println(result);\n }\n return;\n }\n for(int i=start; i < arr.length; i++){\n sum += arr[i];\n result.add(arr[i]);\n combinationUtil(arr,k,i+1,sum,total,pos+1,result);\n result.remove(result.size()-1);\n sum -= arr[i];\n }\n }\n\n public static void main(String args[]){\n TugOfWar tow = new TugOfWar();\n int arr[] = {23, 45, 34, 12,11, 98, 99, 4, 189, 1,7,19,105, 201};\n int min = tow.findMind(arr);\n System.out.print(min);\n }\n}\n"
},
{
"path": "src/com/interview/array/WaterContainer.java",
"content": "package com.interview.array;\n\n/**\n * Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate (i, ai).\n * n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines,\n * which together with x-axis forms a container, such that the container contains the most water.\n *\n * https://leetcode.com/problems/container-with-most-water/\n */\npublic class WaterContainer {\n public int maxArea(int[] height) {\n int i = 0;\n int j = height.length - 1;\n int maxArea = 0;\n while (i < j) {\n if (height[i] < height[j]) {\n maxArea = Math.max(maxArea, (height[i]) * (j - i));\n i++;\n } else {\n maxArea = Math.max(maxArea, height[j] * (j - i));\n j--;\n }\n }\n return maxArea;\n }\n}\n"
},
{
"path": "src/com/interview/array/WiggleSort.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n/**\n * Date 03/23/2016\n * @author Tushar Roy\n *\n * Convert an unsorted array into an array of form num[0] < num[1] > nums[2] < num[3]....\n * \n * Time complexity O(n) - This depends on KthElementInArray time\n * Space complexity O(1)\n *\n * https://leetcode.com/problems/wiggle-sort/\n * https://leetcode.com/problems/wiggle-sort-ii/\n */\npublic class WiggleSort {\n\n //looking for nums[0] < nums[1] > nums[2] < nums[3] and so on.\n public void wiggleSort2(int[] arr) {\n if (arr.length == 0) {\n return;\n }\n int k = arr.length/2;\n KthElementInArray kthElementInArray = new KthElementInArray();\n kthElementInArray.kthElement(arr, k);\n\n int mid = arr[k];\n int n = arr.length;\n int i = 0, j = 0;\n k = n - 1;\n while (j <= k) {\n if (arr[next(j, n)] > mid) {\n swap(arr, next(i++, n), next(j++, n));\n }\n else if (arr[next(j, n)] < mid) {\n swap(arr, next(j, n), next(k--, n));\n }\n else {\n j++;\n }\n }\n }\n\n //in this version we are looking for nums[0] <= nums[1] >= nums[2] <= nums[3] and so on.\n public void wiggleSort1(int[] nums) {\n boolean flag = true;\n for (int i = 0; i < nums.length - 1; i++) {\n if (flag) {\n if (nums[i] > nums[i + 1]) {\n swap(nums, i, i + 1);\n }\n } else {\n if (nums[i] < nums[i + 1]) {\n swap(nums, i, i + 1);\n }\n }\n flag = !flag;\n }\n }\n\n private int next(int index, int n) {\n return (2*index + 1) % (n | 1);\n }\n\n private void swap(int arr[],int low,int high){\n int temp = arr[low];\n arr[low] = arr[high];\n arr[high] = temp;\n }\n\n public static void main(String args[]) {\n WiggleSort ws = new WiggleSort();\n int input[] = {6, 2, 1, 6, 8, 9, 6};\n ws.wiggleSort2(input);\n System.out.print(Arrays.toString(input));\n }\n}\n"
},
{
"path": "src/com/interview/array/ZigZagArrangement.java",
"content": "package com.interview.array;\n\nimport java.util.Arrays;\n\n/**\n * Date 12/30/2015\n * @author Tushar Roy\n *\n * Given an array of unique elements rearrange the array to be a < b > c < d > e form\n *\n * Time complexity - O(n)\n * Space complexity - O(1)\n *\n * http://www.geeksforgeeks.org/convert-array-into-zig-zag-fashion/\n */\npublic class ZigZagArrangement {\n\n public void rearrange(int input[]) {\n boolean isLess = true;\n for (int i = 0; i < input.length - 1; i++) {\n if(isLess) {\n if (input[i] > input[i+1]) {\n swap(input, i, i+1);\n }\n } else {\n if (input[i] < input[i+1]) {\n swap(input, i, i+1);\n }\n }\n isLess = !isLess;\n }\n }\n\n private void swap(int input[], int i, int j) {\n int t = input[i];\n input[i] = input[j];\n input[j] = t;\n }\n\n public static void main(String args[]) {\n int input[] = {4, 3, 2, 6, 7, 1, 9};\n ZigZagArrangement zza = new ZigZagArrangement();\n zza.rearrange(input);\n Arrays.stream(input).forEach(i -> System.out.print(i + \" \"));\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/ArithmeticProgressionSearch.java",
"content": "package com.interview.binarysearch;\n\n/**\n * http://www.careercup.com/question?id=4798365246160896\n */\npublic class ArithmeticProgressionSearch {\n\n public int search(int input[]){\n int low =0;\n int high = input.length-1;\n int ap = (input[high] - input[low])/(input.length);\n int middle = -1;\n while(low <= high){\n middle = (low + high)/2;\n if(input[middle] == input[0] + (middle)*ap){\n low = middle+1;\n }else if((input[middle] > input[0] + (middle)*ap) && \n input[middle-1] == input[0] + (middle-1)*ap){\n return input[0] + (middle)*ap;\n }else{\n high = middle-1;\n }\n }\n return -1;\n }\n public static void main(String args[]){\n int input[] = {1,7,10,13,16,19,22};\n ArithmeticProgressionSearch aps = new ArithmeticProgressionSearch();\n System.out.println(aps.search(input));\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/BinarySearch.java",
"content": "package com.interview.binarysearch;\n\n/**\n * Regular binary search\n */\npublic class BinarySearch {\n\n public int search(final int input[], int search) {\n int low = 0;\n int high = input.length - 1;\n int mid;\n while (low <= high) {\n mid = low + ((high - low) / 2);\n if (input[mid] == search) {\n return mid;\n } else if (input[mid] < search) {\n low = mid + 1;\n } else {\n high = mid - 1;\n }\n }\n return -1;\n }\n\n public static void main(String args[]) {\n BinarySearch bSearch = new BinarySearch();\n final int arr1[] = {1, 2, 4, 5, 7, 8};\n System.out.println(bSearch.search(arr1, -1));\n System.out.println(bSearch.search(arr1, 1));\n System.out.println(bSearch.search(arr1, 8));\n System.out.println(bSearch.search(arr1, 2));\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/CircularBinarySearch.java",
"content": "package com.interview.binarysearch;\n\n/**\n * http://www.careercup.com/question?id=4877486110277632\n * Given a circle with N defined points and a point M outside the circle, \n * find the point that is closest to M among the set of N. O(LogN)\n * Test cases\n * 1) smallest element at center\n * 2) smallest element at left/right end\n * 3) largest element at center\n * 4) smallest element at left side\n * 5) smallest element at right side\n */\npublic class CircularBinarySearch {\n\n //if mid is greater than both ends than result is low of two ends else move in direction\n //where either mid-1 or mid+1 is less\n public int search(int arr[]) {\n int low = 0;\n int high = arr.length - 1;\n int mid = 0;\n while (low < high) {\n mid = (low + high) / 2;\n //if middle is less than both mid-1 and mid+1 then mid is the answer\n if((low == mid || arr[mid] < arr[mid-1])&& arr[mid] < arr[mid+1]){\n return arr[mid];\n }\n if ((arr[mid] >= arr[low] && arr[mid] >= arr[high])){\n if(arr[low] < arr[high]){\n high = mid-1;\n }else{\n low = mid+1;\n }\n }else{\n if(arr[mid-1] < arr[mid+1]){\n high = mid-1;\n }else{\n low = mid+1;\n }\n }\n }\n return arr[low];\n }\n\n public static void main(String args[]) {\n CircularBinarySearch cbs = new CircularBinarySearch();\n int arr[] = { 7, 10, 8, 5, 2, 3, 5 };\n System.out.print(cbs.search(arr));\n\n int arr1[] = { 5, 8, 10, 7, 5, 3, 2 };\n System.out.print(cbs.search(arr1));\n\n int arr2[] = { 3, 5, 7, 10, 8, 5, 2 };\n System.out.print(cbs.search(arr2));\n\n int arr3[] = { 8, 5, 2, 3, 5, 7, 10 };\n System.out.print(cbs.search(arr3));\n\n int arr4[] = { 5, 3, 2, 5, 8, 10, 7 };\n System.out.print(cbs.search(arr4));\n\n int arr5[] = {100,20,10,5,2,8,11,16,19};\n System.out.print(cbs.search(arr5));\n\n int arr6[] = {200,2,10,15,20,80,110,160,190};\n System.out.print(cbs.search(arr6));\n\n int arr7[] = {5,10,20,50,200,800,1100,1600,1900,2};\n System.out.print(cbs.search(arr7));\n\n int arr8[] = {2,5,10,20,50,200,800,1100,1600,1900};\n System.out.print(cbs.search(arr8));\n \n int arr9[] = {3,1,8,5,4};\n System.out.print(cbs.search(arr9));\n \n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/CountNDistinctPairsWithDifferenceK.java",
"content": "package com.interview.binarysearch;\n\nimport java.util.Arrays;\n\n/**\n * http://www.geeksforgeeks.org/count-pairs-difference-equal-k/\n */\npublic class CountNDistinctPairsWithDifferenceK {\n\n public int count(int arr[],int k){\n Arrays.sort(arr);\n int count = 0;\n for(int i=0; i < arr.length; i++){\n boolean result = binarySearch(arr, i+1, arr.length-1, arr[i] + k);\n if(result){\n count++;\n }\n }\n return count;\n }\n \n private boolean binarySearch(int arr[],int start,int end,int num){\n if(start > end){\n return false;\n }\n int mid = (start + end)/2;\n if(arr[mid] == num){\n return true;\n }\n else if(arr[mid] > num){\n return binarySearch(arr,start,mid-1,num);\n }else{\n return binarySearch(arr,mid+1,end,num);\n }\n }\n \n public static void main(String args[]){\n CountNDistinctPairsWithDifferenceK cn = new CountNDistinctPairsWithDifferenceK();\n int arr[] = {1,2,3,4,5,7,9};\n System.out.print(cn.count(arr, 3));\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/FirstOccurrenceOfNumberInSortedArray.java",
"content": "package com.interview.binarysearch;\n\n/**\n * http://www.geeksforgeeks.org/check-for-majority-element-in-a-sorted-array/\n */\npublic class FirstOccurrenceOfNumberInSortedArray {\n\n public int firstOccurrence(int input[], int x){\n int low = 0;\n int high = input.length-1;\n \n while(low <= high){\n int middle = (low + high)/2;\n if(input[middle] == x && (middle == 0 || input[middle-1] < x)){\n return middle;\n }else if(input[middle] < x){\n low = middle+1;\n }else{\n high = middle-1;\n }\n }\n return -1;\n }\n \n public static void main(String args[]){\n FirstOccurrenceOfNumberInSortedArray fos = new FirstOccurrenceOfNumberInSortedArray();\n int input[] = {1,2,2,2,2,2,5,7,7};\n System.out.println(fos.firstOccurrence(input, 6));\n }\n \n}\n"
},
{
"path": "src/com/interview/binarysearch/FloorAndCeilingSortedArray.java",
"content": "package com.interview.binarysearch;\n\n/**\n * http://www.geeksforgeeks.org/search-floor-and-ceil-in-a-sorted-array/\n */\npublic class FloorAndCeilingSortedArray {\n\n public int floor(int input[], int x){\n int low = 0;\n int high = input.length-1;\n while(low <= high){\n int middle = (low + high)/2;\n if(input[middle] == x || (input[middle] < x && (middle == input.length-1 || input[middle+1] > x))){\n return middle;\n }else if(input[middle] < x){\n low = middle+1;\n }else{\n high = middle-1;\n }\n }\n return -1;\n }\n\n public int ceiling(int input[], int x){\n int low = 0;\n int high = input.length-1;\n while(low <= high){\n int middle = (low + high)/2;\n if(input[middle] == x || (input[middle] > x && (middle == 0 || input[middle-1] < x))){\n return middle;\n }else if(input[middle] < x){\n low = middle+1;\n }else{\n high = middle-1;\n }\n }\n return -1;\n }\n \n public static void main(String args[]){\n int input[] = {1,2,5,6,11,15};\n FloorAndCeilingSortedArray foc = new FloorAndCeilingSortedArray();\n System.out.println(foc.floor(input, 15));\n System.out.println(foc.ceiling(input, 2));\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/MedianOfTwoSortedArray.java",
"content": "package com.interview.binarysearch;\n\n/**\n * http://www.geeksforgeeks.org/median-of-two-sorted-arrays/\n */\npublic class MedianOfTwoSortedArray {\n\n public double median(int arr1[],int arr2[]){\n int low1 = 0;\n int high1 = arr1.length-1;\n \n int low2 = 0;\n int high2 = arr2.length-1;\n\n while(true){\n \n if(high1 == low1){\n return (arr1[low1] + arr2[low2])/2;\n }\n \n if(high1 - low1 == 1){\n return (double)(Math.max(arr1[low1], arr2[low2]) + Math.min(arr1[high1], arr2[high2]))/2;\n }\n \n double med1 = getMedian(arr1,low1,high1);\n double med2 = getMedian(arr2,low1,high2);\n if(med1 <= med2){\n if((high1-low1 + 1) % 2 == 0){\n low1 = (high1+low1)/2;\n high2 = (high2+low2)/2 + 1;\n }else{\n low1 = (low1+high1)/2;\n high2 = (low2+high2)/2;\n }\n }\n else{\n if((high1-low1 + 1) % 2 == 0){\n low2 = (high2+low2)/2;\n high1 = (high1+low1)/2 + 1;\n }else{\n low2 = (low2+high2)/2;\n high1 = (low1+high1)/2;\n }\n }\n }\n }\n \n private double getMedian(int arr[],int low,int high){\n int len = high - low+1;\n if(len % 2 == 0){\n return (arr[low + len/2] + arr[low+ len/2-1])/2;\n }else{\n return arr[low+len/2];\n }\n }\n \n public static void main(String args[]){\n int arr1[] = {1,2,3,4,6};\n int arr2[] = {-1,5,6,7,8};\n MedianOfTwoSortedArray mts = new MedianOfTwoSortedArray();\n System.out.println(mts.median(arr1, arr2));\n }\n \n}\n"
},
{
"path": "src/com/interview/binarysearch/MedianOfTwoSortedArrayOfDifferentLength.java",
"content": "package com.interview.binarysearch;\n\n/**\n * There are two sorted arrays nums1 and nums2 of size m and n respectively.\n * Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).\n *\n * Solution\n * Take minimum size of two array. Possible number of partitions are from 0 to m in m size array.\n * Try every cut in binary search way. When you cut first array at i then you cut second array at (m + n + 1)/2 - i\n * Now try to find the i where a[i-1] <= b[j] and b[j-1] <= a[i]. So this i is partition around which lies the median.\n *\n * Time complexity is O(log(min(x,y))\n * Space complexity is O(1)\n *\n * https://leetcode.com/problems/median-of-two-sorted-arrays/\n * https://discuss.leetcode.com/topic/4996/share-my-o-log-min-m-n-solution-with-explanation/4\n */\npublic class MedianOfTwoSortedArrayOfDifferentLength {\n\n public double findMedianSortedArrays(int input1[], int input2[]) {\n //if input1 length is greater than switch them so that input1 is smaller than input2.\n if (input1.length > input2.length) {\n return findMedianSortedArrays(input2, input1);\n }\n int x = input1.length;\n int y = input2.length;\n\n int low = 0;\n int high = x;\n while (low <= high) {\n int partitionX = (low + high)/2;\n int partitionY = (x + y + 1)/2 - partitionX;\n\n //if partitionX is 0 it means nothing is there on left side. Use -INF for maxLeftX\n //if partitionX is length of input then there is nothing on right side. Use +INF for minRightX\n int maxLeftX = (partitionX == 0) ? Integer.MIN_VALUE : input1[partitionX - 1];\n int minRightX = (partitionX == x) ? Integer.MAX_VALUE : input1[partitionX];\n\n int maxLeftY = (partitionY == 0) ? Integer.MIN_VALUE : input2[partitionY - 1];\n int minRightY = (partitionY == y) ? Integer.MAX_VALUE : input2[partitionY];\n\n if (maxLeftX <= minRightY && maxLeftY <= minRightX) {\n //We have partitioned array at correct place\n // Now get max of left elements and min of right elements to get the median in case of even length combined array size\n // or get max of left for odd length combined array size.\n if ((x + y) % 2 == 0) {\n return ((double)Math.max(maxLeftX, maxLeftY) + Math.min(minRightX, minRightY))/2;\n } else {\n return (double)Math.max(maxLeftX, maxLeftY);\n }\n } else if (maxLeftX > minRightY) { //we are too far on right side for partitionX. Go on left side.\n high = partitionX - 1;\n } else { //we are too far on left side for partitionX. Go on right side.\n low = partitionX + 1;\n }\n }\n\n //Only we we can come here is if input arrays were not sorted. Throw in that scenario.\n throw new IllegalArgumentException();\n }\n\n public static void main(String[] args) {\n int[] x = {1, 3, 8, 9, 15};\n int[] y = {7, 11, 19, 21, 18, 25};\n\n MedianOfTwoSortedArrayOfDifferentLength mm = new MedianOfTwoSortedArrayOfDifferentLength();\n mm.findMedianSortedArrays(x, y);\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/MinimumInSortedRotatedArray.java",
"content": "package com.interview.binarysearch;\n\n/**\n * https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/\n */\npublic class MinimumInSortedRotatedArray {\n public int findMin(int[] nums) {\n int low = 0;\n int high = nums.length - 1;\n while (low < high) {\n int middle = (low + high)/2;\n if ((middle == 0 && nums[middle] < nums[middle + 1]) || (middle > 0 && nums[middle] < nums[middle - 1])) {\n return nums[middle];\n }\n else if (nums[middle] > nums[high]) {\n low = middle + 1;\n } else {\n high = middle - 1;\n }\n }\n return nums[low];\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/MissingNumberInConsecutiveNumbers.java",
"content": "package com.interview.binarysearch;\n\n/**\n * Find missing number in consecutive numbers.\n */\npublic class MissingNumberInConsecutiveNumbers {\n\n public Integer findMissing(int arr[]){\n \n int lowNum = arr[0];\n int low = 0;\n int high = arr.length -1;\n int middle = (low + high)/2;\n while(low <= high){\n middle = (low + high)/2;\n if(arr[middle] == (middle+1 + lowNum) && middle-1 >=0 && arr[middle-1] == (middle + lowNum-1)){\n return middle + lowNum;\n }\n else if((middle + lowNum) == arr[middle]){\n low = middle+1;\n }else {\n high = middle-1;\n }\n }\n return null;\n }\n \n public static void main(String args[]){\n int arr[] = {3,4,5,6,7,8,9,10,11,12};\n int arr1[] = {-5,-4,-3,-1,0,1,2,3};\n MissingNumberInConsecutiveNumbers mn = new MissingNumberInConsecutiveNumbers();\n System.out.println(mn.findMissing(arr1));\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/MonotonicallyIncreasingFunctionBecomesPositive.java",
"content": "package com.interview.binarysearch;\n\n/**\n * http://www.geeksforgeeks.org/find-the-point-where-a-function-becomes-negative/\n */\npublic class MonotonicallyIncreasingFunctionBecomesPositive {\n\n private int f(int x){\n return x*x - 10*x - 20;\n }\n \n public int findPoint(){\n int i=1;\n while(f(i) <=0 ){\n i = i*2;\n }\n return binarySearch(i/2,i);\n }\n \n private int binarySearch(int start,int end){\n int mid = (start+end)/2;\n while(start < end){\n mid = (start+end)/2;\n if(f(mid) >0 && f(mid-1) <=0){\n return mid;\n }\n if(f(mid) <=0 && f(mid+1)>0){\n return mid+1;\n }\n if(f(mid) <= 0){\n start = mid+1;\n }else{\n end = mid-1;\n }\n }\n return mid;\n }\n \n public static void main(String args[]){\n MonotonicallyIncreasingFunctionBecomesPositive mif = new MonotonicallyIncreasingFunctionBecomesPositive();\n System.out.print(mif.findPoint());\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/NumberOfPairWithXPowerYGreaterThanYPowerX.java",
"content": "package com.interview.binarysearch;\n\nimport java.util.Arrays;\nimport java.util.HashMap;\nimport java.util.Map;\n\n/**\n * http://www.geeksforgeeks.org/find-number-pairs-xy-yx/\n */\npublic class NumberOfPairWithXPowerYGreaterThanYPowerX {\n\n public int countPairs(int X[],int Y[]){\n Map hardCoded = new HashMap();\n for(int i=0; i < Y.length; i++){\n if(Y[i] < 4){\n Integer count = hardCoded.get(Y[i]);\n if(count != null){\n hardCoded.put(Y[i], count++);\n }else{\n hardCoded.put(Y[i], 1);\n }\n }\n }\n Arrays.sort(Y);\n int countPairs = 0;\n for(int i=0 ; i < X.length; i++){\n countPairs += count(X[i],Y,hardCoded);\n }\n return countPairs;\n }\n \n private int count(int x, int Y[],Map hardCount){\n \n if(x == 0){\n return 0;\n }\n if(x == 1){\n return upperBound(0,Y);\n }\n int result = Y.length - upperBound(x,Y);\n result += (hardCount.containsKey(1) ? hardCount.get(1) : 0 ) + (hardCount.containsKey(0) ? hardCount.get(0) : 0);\n \n if(x == 2){\n result -= (hardCount.containsKey(3) ? hardCount.get(3) : 0);\n }\n if(x == 3){\n result += (hardCount.containsKey(2) ? hardCount.get(2) : 0);\n }\n return result;\n }\n \n private int upperBound(int x, int arr[]){\n int low = 0;\n int high = arr.length-1;\n while(low <= high){\n int mid = (low+high)/2;\n if(arr[mid] > x && (mid-1 < 0 || arr[mid-1] <= x)){\n return mid;\n }else if(arr[mid] > x){\n high = mid-1;\n }else{\n low = mid+1;\n }\n }\n return -1;\n \n }\n \n public static void main(String args[]){\n NumberOfPairWithXPowerYGreaterThanYPowerX nop = new NumberOfPairWithXPowerYGreaterThanYPowerX();\n int X[] = {7,9,5,8,9,11,0,1,1,3};\n int Y[] = {6,8,9,11,14,5,1,0,2,3,9};\n System.out.println(nop.countPairs(X, Y));\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/PeakElement.java",
"content": "package com.interview.binarysearch;\n\n/**\n * @author Tushar Roy\n * Date 01/17/2107\n * A peak element is an element that is greater than its neighbors. Find index of peak element in the array.\n *\n * Space complexity is O(1)\n * Time complexity is O(n)\n *\n * https://leetcode.com/problems/find-peak-element/\n */\npublic class PeakElement {\n\n public int findPeakElement(int[] nums) {\n int low = 0;\n int high = nums.length - 1;\n int middle = 0;\n while (low <= high) {\n middle = (low + high)/2;\n int before = Integer.MIN_VALUE;\n if (middle > 0) {\n before = nums[middle - 1];\n }\n int after = Integer.MIN_VALUE;\n if (middle < nums.length - 1) {\n after = nums[middle + 1];\n }\n if (nums[middle] > before && nums[middle] > after) {\n return middle;\n } else if (before > after) {\n high = middle - 1;\n } else {\n low = middle + 1;\n }\n }\n return middle;\n }\n\n public static void main(String args[]){\n int arr[] = {10,5,15,2,23,90,67};\n PeakElement pe = new PeakElement();\n System.out.println(pe.findPeakElement(arr));\n int arr1[] = {10,20,30,40,50};\n System.out.println(pe.findPeakElement(arr1));\n int arr2[] = {100,90,80,70,60};\n System.out.println(pe.findPeakElement(arr2));\n \n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/SearchForRange.java",
"content": "package com.interview.binarysearch;\n\n/**\n * Date 07/31/2016\n * @author Tushar Roy\n *\n * Given a sorted array of integers, find the starting and ending position of a given target value.\n *\n * Time complexity O(logn)\n * Space complexity O(1)\n * \n * https://leetcode.com/problems/search-for-a-range/\n */\npublic class SearchForRange {\n public int[] searchRange(int[] nums, int target) {\n int first = firstOccurence(nums, target);\n if (first == -1) {\n return new int[]{-1, -1};\n }\n int last = lastOccurence(nums, target);\n return new int[]{first, last};\n }\n\n private int firstOccurence(int[] nums, int target) {\n int low = 0;\n int high = nums.length - 1;\n while (low <= high) {\n int mid = low + (high - low)/2;\n if (nums[mid] == target && (mid == 0 || nums[mid - 1] < target)) {\n return mid;\n } else if (nums[mid] >= target) {\n high = mid - 1;\n } else {\n low = mid + 1;\n }\n }\n return -1;\n }\n\n private int lastOccurence(int[] nums, int target) {\n int low = 0;\n int high = nums.length - 1;\n while (low <= high) {\n int mid = low + (high - low)/2;\n if (nums[mid] == target && (mid == nums.length - 1 || nums[mid + 1] > target)) {\n return mid;\n } else if (nums[mid] <= target) {\n low = mid + 1;\n } else {\n high = mid - 1;\n }\n }\n return -1;\n }\n\n public static void main(String args[]) {\n SearchForRange searchForRange = new SearchForRange();\n int[] nums = {0, 1, 1, 3, 6, 9, 11};\n int[] r = searchForRange.searchRange(nums, 11);\n System.out.println(r[0] + \" \" + r[1]);\n r = searchForRange.searchRange(nums, 0);\n System.out.println(r[0] + \" \" + r[1]);\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/SearchInsertPosition.java",
"content": "package com.interview.binarysearch;\n\n/**\n * https://leetcode.com/problems/search-insert-position/\n */\npublic class SearchInsertPosition {\n public int searchInsert(int[] nums, int target) {\n int low = 0;\n int high = nums.length - 1;\n while (low <= high) {\n int middle = (low + high)/2;\n if (nums[middle] == target) {\n return middle;\n }\n if (nums[middle] < target && (middle == nums.length - 1 || nums[middle + 1] > target)) {\n return middle + 1;\n }\n if (nums[middle] < target) {\n low = middle + 1;\n } else {\n high = middle - 1;\n }\n }\n return 0;\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/SortedAndRotatedArraySearch.java",
"content": "package com.interview.binarysearch;\n\n/**\n * @author Tushar Roy\n * Date 01/22/17\n *\n * Search in sorted and rotated array. In one version duplicate is not allowed and\n * in another version duplicate is allowed.\n *\n * Time complexity with no duplicate - O(logn)\n * Time complexity with duplicates - O(n)\n *\n * https://leetcode.com/problems/search-in-rotated-sorted-array/\n * https://leetcode.com/problems/search-in-rotated-sorted-array-ii/\n */\npublic class SortedAndRotatedArraySearch {\n\n /**\n * Duplicates are not allowed in arr.\n */\n public int search(int arr[],int search){\n int low =0;\n int high = arr.length-1;\n while(low <= high){\n int mid = (low + high)/2;\n if(arr[mid] == search){\n return mid;\n }\n \n if(arr[mid] < arr[high]){\n if(arr[mid] < search && search <= arr[high]){\n low = mid+1;\n }else{\n high = mid-1;\n }\n }else{\n if(search >= arr[low] && search < arr[mid]){\n high = mid-1;\n }else{\n low = mid+1;\n }\n }\n }\n return -1;\n }\n\n /**\n * Duplicates are allowed in arr.\n */\n public boolean searchWithDuplicates(int[] arr, int search) {\n int low =0;\n int high = arr.length-1;\n while(low <= high){\n int mid = (low + high)/2;\n if(arr[mid] == search) {\n return true;\n }\n //if low is same as mid then increment low.\n if (arr[mid] == arr[low]) {\n low++;\n } else if (arr[mid] == arr[high]) { //if high is same as mid then decrement high.\n high--;\n } else if (arr[mid] < arr[high]) {\n if(arr[mid] < search && search <= arr[high]) {\n low = mid + 1;\n } else {\n high = mid - 1;\n }\n } else {\n if(search >= arr[low] && search < arr[mid]) {\n high = mid - 1;\n } else {\n low = mid + 1;\n }\n }\n }\n return false;\n }\n \n public static void main(String args[]){\n SortedAndRotatedArraySearch ras = new SortedAndRotatedArraySearch();\n int arr1[] = {1,2,5,6,7,8,11,21};\n System.out.print(ras.search(arr1, 1));\n System.out.print(ras.search(arr1, 5));\n System.out.print(ras.search(arr1, 22));\n System.out.println();\n \n int arr2[] = {18,21,1,2,5,6,7,8,10,15};\n System.out.print(ras.search(arr2, 1));\n System.out.print(ras.search(arr2, 5));\n System.out.print(ras.search(arr2, 10));\n System.out.print(ras.search(arr2, 14));\n System.out.println();\n\n int arr3[] = {7,8,15,17,18,21,1,2,5,6};\n System.out.print(ras.search(arr3, 1));\n System.out.print(ras.search(arr3, 5));\n System.out.print(ras.search(arr3, 10));\n System.out.print(ras.search(arr3, 7));\n System.out.print(ras.search(arr3, 6));\n System.out.print(ras.search(arr3, 16));\n }\n}\n"
},
{
"path": "src/com/interview/binarysearch/SquareRootOfNumber.java",
"content": "package com.interview.binarysearch;\n\n/**\n *\n * https://leetcode.com/problems/sqrtx/\n */\npublic class SquareRootOfNumber {\n public int mySqrt(int x) {\n if (x == 0)\n return 0;\n int left = 1, right = x;\n while (true) {\n int mid = left + (right - left)/2;\n if (mid > x/mid) {\n right = mid - 1;\n } else {\n if (mid + 1 > x/(mid + 1))\n return mid;\n left = mid + 1;\n }\n }\n }\n}\n"
},
{
"path": "src/com/interview/bits/AddTwoNumberInBinaryRepresentation.java",
"content": "package com.interview.bits;\n\n/**\n * http://www.geeksforgeeks.org/add-two-bit-strings/\n * http://www.geeksforgeeks.org/binary-representation-of-a-given-number/\n * http://www.geeksforgeeks.org/add-two-numbers-without-using-arithmetic-operators/\n */\npublic class AddTwoNumberInBinaryRepresentation {\n\n public int add(char[] num1,char[] num2){\n int index1 = num1.length -1;\n int index2 = num2.length -1;\n int carry = 0;\n int result = 0;\n int index = 0;\n while(index1 >= 0 && index2 >= 0){\n int r1 = num1[index1] - '0';\n int r2 = num2[index2] - '0';\n result = result | (r1^r2^carry)<= 0){\n int r1 = num1[index1] - '0';\n result = result | (r1^carry)<= 0){\n int r2 = num1[index2] - '0';\n result = result | (r2^carry)<>>1){\n if((num & i) > 0){\n System.out.print(\"1\");\n }else{\n System.out.print(\"0\");\n }\n }\n }\n \n public static void main(String args[]){\n AddTwoNumberInBinaryRepresentation anp = new AddTwoNumberInBinaryRepresentation();\n char num1[] = \"1010001110\".toCharArray();\n char num2[] = \"10011\".toCharArray();\n int result = anp.add(num1, num2);\n System.out.println(anp.addTwoNumbersWithoutArithmeticOperator(296, 5662));\n System.out.println(anp.addTwoNumbersWithoutArithmeticOperatorFaster(296, 5662));\n anp.printResult(result);\n }\n \n}\n"
},
{
"path": "src/com/interview/bits/BitRotation.java",
"content": "package com.interview.bits;\n\n/*\n * http://www.geeksforgeeks.org/rotate-bits-of-an-integer/\n */\npublic class BitRotation {\n\n public byte rotateLeft(byte num, int d){\n return (byte)((num << d) | (num >>> (8-d)));\n }\n \n public static void main(String args[]){\n BitRotation br = new BitRotation();\n System.out.println(br.rotateLeft((byte)28, 2));\n }\n}\n"
},
{
"path": "src/com/interview/bits/ByteAsStorage.java",
"content": "package com.interview.bits;\n\npublic class ByteAsStorage {\n\n void useByteAsBoolean(boolean[] visited){\n byte[] bytes = new byte[(int)(Math.ceil(visited.length*1.0/8))];\n for(int i=0; i < visited.length; i++){\n int row = i/8;\n int col = i%8;\n if(visited[i]){\n bytes[row] = (byte)(bytes[row] | (byte)(1<= 1){\n System.out.print(\"True\");\n }else{\n System.out.print(\"False\");\n }\n }\n }\n public static void main(String args[]){\n boolean visited[] = {true,false,true,true,false};\n ByteAsStorage bas = new ByteAsStorage();\n bas.useByteAsBoolean(visited);\n }\n}\n"
},
{
"path": "src/com/interview/bits/CountBits.java",
"content": "package com.interview.bits;\n\n/**\n * http://www.geeksforgeeks.org/count-set-bits-in-an-integer/\n */\npublic class CountBits {\n\n public CountBits(){\n preCalculate();\n }\n public int countBits(int num){\n int count=0;\n while(num > 0){\n num &= num-1;\n count++;\n }\n return count;\n }\n \n private int count[] = new int[256];\n \n void preCalculate(){\n for(int i=0; i < 256; i++){\n count[i] = countBits(i);\n }\n }\n \n public int countBitsFaster(int num){\n //get 8 bits at a time and check count from count array\n int total = 0;\n int mask = (1<<8) - 1;\n for(int i=0 ; i < 4; i++){\n total += count[num & mask];\n num = num>>>8;\n }\n return total;\n }\n \n //http://bits.stephan-brumme.com/countBits.html\n public int countBitsEvenFaster(int x){\n // count bits of each 2-bit chunk\n x = x - ((x >> 1) & 0x55555555);\n // count bits of each 4-bit chunk\n x = (x & 0x33333333) + ((x >> 2) & 0x33333333);\n // count bits of each 8-bit chunk\n x = x + (x >> 4);\n // mask out junk\n x &= 0xF0F0F0F;\n // add all four 8-bit chunks\n return (x * 0x01010101) >> 24;\n }\n\n public static void main(String args[]){\n CountBits cb = new CountBits();\n System.out.println(cb.countBits(3636363));\n System.out.println(cb.countBitsFaster(3636363));\n System.out.println(cb.countBitsEvenFaster(3636363));\n }\n}\n"
},
{
"path": "src/com/interview/bits/CountingBitsTillNum.java",
"content": "package com.interview.bits;\n\n/**\n * Date 04/03/2016\n * @author Tushar Roy\n *\n * Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num calculate\n * the number of 1's in their binary representation and return them as an array.\n *\n * Time complexity O(n)\n * Space complexity O(n)\n *\n * https://leetcode.com/problems/counting-bits/\n */\npublic class CountingBitsTillNum {\n public int[] countBits(int num) {\n if (num == 0) {\n return new int[1];\n }\n int[] count = new int[num + 1];\n count[0] = 0;\n int n = 1;\n int start = n;\n while (start <= num) {\n start = n;\n count[start++] = 1;\n int end = n<<1;\n while (start < end && start <= num) {\n count[start] = 1 + count[start - n];\n start++;\n }\n n = n<<1;\n }\n return count;\n }\n}\n"
},
{
"path": "src/com/interview/bits/DrawHorizontalLine.java",
"content": "package com.interview.bits;\n\n/**\n * Exercise 5.8 150qs \n */\npublic class DrawHorizontalLine {\n\n public void draw(byte[] screen, int width, int x1, int x2,int y){\n int pos1 = y*width + x1;\n int pos2 = y*width + x2;\n \n int start = pos1;\n while(start <= pos2){\n int row = start/8;\n int col = start%8;\n \n screen[row] = (byte)(screen[row] | 1<>i; \n }\n result = result | (sum%3)< grayCode(int n) {\n List result = new LinkedList<>();\n for (int i = 0; i < 1<>1);\n }\n return result;\n }\n\n public static void main(String args[]) {\n GrayCode gc = new GrayCode();\n System.out.println(gc.grayCode(4));\n }\n}\n"
},
{
"path": "src/com/interview/bits/InsertMintoNiTojBits.java",
"content": "package com.interview.bits;\n\n/**\n * Exercise 5.1 150 qs\n */\npublic class InsertMintoNiTojBits {\n \n public int insert(int M,int N, int i, int j){\n int mask = 1<<(j+1) -1;\n mask = mask< b.length() - a.length());\n\n int[] masks = new int[words.length]; // alphabet masks\n\n for(int i = 0; i < masks.length; i++){\n for(char c: words[i].toCharArray()){\n masks[i] |= 1 << (c - 'a');\n }\n }\n\n for(int i = 0; i < masks.length; i++){\n if(words[i].length() * words[i].length() <= max) {\n break; //prunning\n }\n for(int j = i + 1; j < masks.length; j++){\n if((masks[i] & masks[j]) == 0){\n max = Math.max(max, words[i].length() * words[j].length());\n break; //prunning\n }\n }\n }\n\n return max;\n }\n}\n"
},
{
"path": "src/com/interview/bits/MissingNumbers.java",
"content": "package com.interview.bits;\n\nclass Pair{\n int x;\n int y;\n}\n\n/**\n * http://www.geeksforgeeks.org/find-the-two-repeating-elements-in-a-given-array/\n * http://www.geeksforgeeks.org/find-a-repeating-and-a-missing-number/\n */\npublic class MissingNumbers {\n\n public Pair findMissingAndRepeated(int arr[], int n){\n int xor = 0;\n for(int i=0; i < arr.length; i++){\n xor = xor ^ arr[i];\n }\n \n for(int i=1; i <= n; i++){\n xor = xor ^ i;\n }\n \n xor = xor & ~(xor-1);\n int set1 = 0;\n int set2 = 0;\n for(int i=0; i < arr.length; i++){\n if((arr[i] & xor) > 0){\n set1 ^= arr[i];\n }else{\n set2 ^= arr[i];\n }\n }\n Pair p = new Pair();\n for(int i=1; i <= n; i++){\n if((i & xor) > 0){\n set1 ^= i;\n }else{\n set2 ^= i;\n }\n }\n p.x = set1;\n p.y = set2;\n return p;\n }\n \n public Pair findTwoMissingNumber(int arr[], int n){\n int xor = 0;\n for(int i=0; i < arr.length; i++){\n xor = xor ^ arr[i];\n }\n \n for(int i=1; i <= n; i++){\n xor = xor ^ i;\n }\n \n xor = xor & ~(xor-1);\n int set1 = 0;\n int set2 = 0;\n for(int i=0; i < arr.length; i++){\n if((arr[i] & xor) > 0){\n set1 ^= arr[i];\n }else{\n set2 ^= arr[i];\n }\n }\n Pair p = new Pair();\n for(int i=1; i <= n; i++){\n if((i & xor) > 0){\n set1 ^= i;\n }else{\n set2 ^= i;\n }\n }\n p.x = set1;\n p.y = set2;\n return p;\n }\n \n public static void main(String args[]){\n MissingNumbers mn = new MissingNumbers();\n int arr[] = {1,2,3,5,5};\n Pair p = mn.findMissingAndRepeated(arr, 5);\n System.out.println(p.x + \" \" + p.y);\n int arr1[] = {1,5,3,6};\n p = mn.findMissingAndRepeated(arr1, 6);\n System.out.println(p.x + \" \" + p.y);\n }\n}\n"
},
{
"path": "src/com/interview/bits/NextHigherAndNextLowerWithSameNumberBits.java",
"content": "package com.interview.bits;\n\n/**\n * Exercise 5.3 150 qs\n */\npublic class NextHigherAndNextLowerWithSameNumberBits {\n\n public int nextHigher(int n){\n int i = 1;\n int first1 = 0;\n //go till you find first 1\n while((n & i) == 0){\n i = i << 1;\n first1++;\n }\n //count number of 1s before first 0\n int count1s = 0;\n while((n & i) > 0){\n i = i <<1;\n count1s++;\n }\n count1s--;\n //change this first 0 after 1 to 1\n n = n^i;\n n = n ^ (i>>1);\n int mask = ~(1<<(first1 + count1s) -1);\n n = mask & n;\n n = n | ((1< 0){\n i = i << 1;\n first0++;\n }\n int count0s = 0;\n while((n & i) == 0){\n i = i <<1;\n count0s++;\n }\n count0s--;\n //change this first 0 after 1 to 1\n n = n^i;\n n = n ^ (i>>1);\n int mask = (1< 0 && (num & (num-1)) == 0){\n return num;\n }\n while((num & (num-1)) > 0){\n num = num & (num-1);\n }\n return num<<1;\n }\n public static void main(String args[]){\n NextPowerOf2 np = new NextPowerOf2();\n System.out.println(np.nextPowerOf2(4));\n }\n}\n"
},
{
"path": "src/com/interview/bits/NumberOccuringOddTimes.java",
"content": "package com.interview.bits;\n\n/**\n * http://www.geeksforgeeks.org/find-the-number-occurring-odd-number-of-times/\n * http://www.geeksforgeeks.org/find-two-non-repeating-elements-in-an-array-of-repeating-elements/\n */\npublic class NumberOccuringOddTimes {\n\n public int oneNumberOccuringOddTimes(int arr[]){\n int r = 0;\n for(int i=0; i < arr.length; i++){\n r = r^arr[i];\n }\n return r;\n }\n \n class Pair{\n int a;\n int b;\n \n }\n \n public Pair twoNumbersOccuringOddTimes(int arr[]){\n int r = 0;\n for(int i=0; i < arr.length; i++){\n r = r^arr[i];\n }\n \n r = r & ~(r-1);\n int r1 = 0;\n int r2 = 0;\n for(int i=0; i < arr.length; i++){\n if((r&arr[i]) == 0){\n r1 = r1^arr[i];\n }else{\n r2 = r2^arr[i];\n }\n }\n Pair p = new Pair();\n p.a = r1;\n p.b = r2;\n return p;\n }\n \n public static void main(String args[]){\n NumberOccuringOddTimes noot = new NumberOccuringOddTimes();\n int arr[] = {1,2,9,9,2,1,9,7,2,1,9,1};\n Pair p = noot.twoNumbersOccuringOddTimes(arr);\n System.out.print(p.a + \" \" + p.b);\n }\n}\n\n"
},
{
"path": "src/com/interview/bits/NumberOfBitsFlipToConvertNToM.java",
"content": "package com.interview.bits;\n\n/**\n * Exercise 5.5 150 qs\n */\npublic class NumberOfBitsFlipToConvertNToM {\n\n public int number(int m, int n){\n int r = n^m;\n int count = 0;\n while(r != 0){\n r = r & (r-1);\n count++;\n }\n return count;\n }\n public static void main(String args[]){\n NumberOfBitsFlipToConvertNToM nb = new NumberOfBitsFlipToConvertNToM();\n System.out.println(nb.number(31, 14));\n }\n}\n"
},
{
"path": "src/com/interview/bits/RealNumberToBinary.java",
"content": "package com.interview.bits;\n\n/**\n * Exercise 5.2 150 qs\n */\npublic class RealNumberToBinary {\n\n public void print(double num){\n if(num > 1 || num < 0){\n System.out.println(\"ERROR\");\n return;\n }\n \n StringBuilder stringBuilder = new StringBuilder();\n stringBuilder.append(\"0.\");\n while(num > 0){\n num = num*2;\n int r = (int)num ;\n stringBuilder.append(r);\n num = num -r;\n if(stringBuilder.length() > 32){\n System.out.println(\"ERROR\");\n return;\n }\n }\n System.out.println(stringBuilder);\n }\n public static void main(String args[]){\n RealNumberToBinary rnb = new RealNumberToBinary();\n rnb.print(0.8125);\n rnb.print(0.72);\n }\n}\n"
},
{
"path": "src/com/interview/bits/RepeatedDnaSequence.java",
"content": "package com.interview.bits;\n\nimport java.util.*;\n\n/**\n * Date 03/08/2016\n * @author Tushar Roy\n *\n * Find repeated sequence of length 10 in string consisting of A,C,G,T\n *\n * Time complexity is O(n)\n * Space complexity is O(n)\n *\n * https://leetcode.com/problems/repeated-dna-sequences/\n */\npublic class RepeatedDnaSequence {\n private static final int mask = 0xFFFFF;\n private static final int mask1 = 3;\n\n\n public List findRepeatedDnaSequences(String s) {\n\n if (s.length() < 10) {\n return Collections.emptyList();\n }\n\n Set set = new HashSet<>();\n int val = 0;\n for (int i = 0; i < 10; i++) {\n val = add(val, s.charAt(i));\n }\n set.add(val);\n List result = new ArrayList<>();\n createString(val);\n\n Set repeatSet = new HashSet<>();\n\n for (int i = 10; i < s.length(); i++) {\n val = add(val, s.charAt(i));\n if (set.contains(val) && !repeatSet.contains(val)) {\n result.add(createString(val));\n repeatSet.add(val);\n } else {\n set.add(val);\n }\n }\n\n return result;\n }\n\n private String createString(int input) {\n StringBuffer sb = new StringBuffer();\n for (int i = 9; i >= 0; i--) {\n sb.append(getChar(input>>(i*2) & mask1));\n }\n return sb.toString();\n }\n\n private int add(int input, char ch) {\n int val = getVal(ch);\n input = input<<2;\n input = input & mask;\n return input | val;\n }\n\n private int getVal(char ch) {\n switch(ch) {\n case 'A':\n return 0;\n case 'C':\n return 1;\n case 'G':\n return 2;\n case 'T':\n return 3;\n default:\n throw new IllegalArgumentException();\n }\n }\n\n private char getChar(int val) {\n switch (val) {\n case 0:\n return 'A';\n case 1:\n return 'C';\n case 2:\n return 'G';\n case 3:\n return 'T';\n default:\n throw new IllegalArgumentException();\n }\n }\n\n public static void main(String args[]) {\n RepeatedDnaSequence rds = new RepeatedDnaSequence();\n List result = rds.findRepeatedDnaSequences(\"AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT\");\n System.out.print(result);\n }\n}\n"
},
{
"path": "src/com/interview/bits/ReverseBits.java",
"content": "package com.interview.bits;\n\n/**\n * http://www.geeksforgeeks.org/write-an-efficient-c-program-to-reverse-bits-of-a-number/\n */\npublic class ReverseBits {\n\n public int reverse(int num){\n //assuming int is 32 bits.\n int result = 0;\n int r1 = 1;\n for(int i=31; i >= 0; i--,r1<<=1){\n if((num & 1<> and <<\n while((k & (k-1))!= 0){\n result += n;\n k--;\n }\n \n while(k > 1){\n n = n<<1;\n k = k>>1;\n }\n return result + n;\n }\n \n public int fastSquare(int n){\n return fastSquareRec(n, n);\n }\n /**\n * Start with 9,9. Then take 1 and keep left shifting 1 till you find number\n * less than 9 but power of 2. Then shift 9 by that many powers and repeat\n * the process with whatever is left between that number and 9.\n */\n private int fastSquareRec(int n, int leftToMultiply){\n if(leftToMultiply <= 0){\n return 0;\n }\n int k = 1; \n int count=0;\n while(k <= leftToMultiply){\n k = k<<1;\n count++;\n }\n k = k>>1;\n count--;\n return (n<> 1 & mask2);\n }\n \n public static void main(String args[]){\n SwapOddEvenBits soe = new SwapOddEvenBits();\n System.out.println(soe.swap(697));\n }\n}\n"
},
{
"path": "src/com/interview/bits/SwapTwoBits.java",
"content": "package com.interview.bits;\n\n/**\n * http://www.careercup.com/question?id=17542662\n */\npublic class SwapTwoBits {\n\n public int swap(int num,int i, int j){\n int t1 = (num & 1<>i ^ (num & 1<>j) != 0){\n num ^= 1< 1001 -> 101 -> 11\n * 1010 -> 110 -> 101 -> 11\n * \n * No matter which route you take it leads to same result so just looking at swaps you can say\n * which player will win\n * \n */\npublic class WinnerWithBeautifulNumber {\n\n public int winner(int n){\n int sum = 0;\n int i =1;\n int result = 0;\n while( i <= n){\n i = i*2;\n }\n i = i/2;\n while(i > 0){\n if((n & i) != 0){\n sum++;\n }else{\n result += sum;\n }\n i = i/2;\n }\n if(result % 2 == 0){\n return 2;\n }else{\n return 1;\n }\n }\n \n public static void main(String args[]){\n WinnerWithBeautifulNumber wwb = new WinnerWithBeautifulNumber();\n System.out.println(wwb.winner(37));\n System.out.println(wwb.winner(10));\n }\n}\n"
},
{
"path": "src/com/interview/dynamic/BitonicSequence.java",
"content": "package com.interview.dynamic;\n\n/**\n * http://www.geeksforgeeks.org/dynamic-programming-set-15-longest-bitonic-subsequence/\n */\npublic class BitonicSequence {\n\n public int longestSequence(int arr[]){\n int lis[] = new int[arr.length];\n int lds[] = new int[arr.length];\n for(int i=0; i < arr.length; i++){\n lis[i] = 1;\n lds[i] = 1;\n }\n for(int i=1 ; i < arr.length; i++){\n for(int j=0; j < i ; j++){\n if(arr[i] > arr[j]){\n lis[i] = Math.max(lis[i], lis[j] + 1);\n }\n }\n }\n \n for(int i = arr.length-2; i >=0 ; i--){\n for(int j = arr.length-1; j > i; j--){\n if(arr[i] > arr[j]){\n lds[i] = Math.max(lds[i], lds[j] + 1);\n }\n }\n }\n int max = 0;\n for(int i=0; i < arr.length; i++){\n if(max < lis[i] + lds[i]-1){\n max = lis[i] + lds[i] -1;\n }\n }\n return max;\n }\n \n public static void main(String args[]){\n BitonicSequence bs = new BitonicSequence();\n int[] arr = {1,4,3,7,2,1,8,11,13,0};\n int r = bs.longestSequence(arr);\n System.out.print(r);\n \n }\n}\n"
},
{
"path": "src/com/interview/dynamic/BoxStacking.java",
"content": "package com.interview.dynamic;\n\nimport java.util.Arrays;\n\n/**\n * Date 05/09/2015\n * @author tusroy\n * \n * Given different dimensions and unlimited supply of boxes for each dimension, stack boxes\n * on top of each other such that it has maximum height but with caveat that length and width\n * of box on top should be strictly less than length and width of box under it. You can\n * rotate boxes as you like.\n * \n * 1) Create all rotations of boxes such that length is always greater or equal to width\n * 2) Sort boxes by base area in non increasing order (length * width). This is because box\n * with more area will never ever go on top of box with less area.\n * 3) Take T[] and result[] array of same size as total boxes after all rotations are done\n * 4) Apply longest increasing subsequence type of algorithm to get max height.\n * \n * If n number of dimensions are given total boxes after rotation will be 3n.\n * So space complexity is O(n)\n * Time complexity - O(nlogn) to sort boxes. O(n^2) to apply DP on it So really O(n^2)\n *\n * References\n * http://www.geeksforgeeks.org/dynamic-programming-set-21-box-stacking-problem/\n * http://people.cs.clemson.edu/~bcdean/dp_practice/\n */\npublic class BoxStacking {\n\n public int maxHeight(Dimension[] input) {\n //get all rotations of box dimension.\n //e.g if dimension is 1,2,3 rotations will be 2,1,3 3,2,1 3,1,2 . Here length is always greater\n //or equal to width and we can do that without loss of generality.\n Dimension[] allRotationInput = new Dimension[input.length * 3];\n createAllRotation(input, allRotationInput);\n \n //sort these boxes in non increasing order by their base area.(length X width)\n Arrays.sort(allRotationInput);\n\n //apply longest increasing subsequence kind of algorithm on these sorted boxes.\n int T[] = new int[allRotationInput.length];\n int result[] = new int[allRotationInput.length];\n\n for (int i = 0; i < T.length; i++) {\n T[i] = allRotationInput[i].height;\n result[i] = i;\n }\n\n for (int i = 1; i < T.length; i++) {\n for (int j = 0; j < i; j++) {\n if (allRotationInput[i].length < allRotationInput[j].length\n && allRotationInput[i].width < allRotationInput[j].width) {\n if( T[j] + allRotationInput[i].height > T[i]){\n T[i] = T[j] + allRotationInput[i].height;\n result[i] = j;\n }\n }\n }\n }\n \n //find max in T[] and that will be our max height.\n //Result can also be found using result[] array.\n int max = Integer.MIN_VALUE;\n for(int i=0; i < T.length; i++){\n if(T[i] > max){\n max = T[i];\n }\n }\n \n return max;\n }\n\n //create all rotations of boxes, always keeping length greater or equal to width\n private void createAllRotation(Dimension[] input,\n Dimension[] allRotationInput) {\n int index = 0;\n for (int i = 0; i < input.length; i++) {\n allRotationInput[index++] = Dimension.createDimension(\n input[i].height, input[i].length, input[i].width);\n allRotationInput[index++] = Dimension.createDimension(\n input[i].length, input[i].height, input[i].width);\n allRotationInput[index++] = Dimension.createDimension(\n input[i].width, input[i].length, input[i].height);\n\n }\n }\n\n public static void main(String args[]) {\n BoxStacking bs = new BoxStacking();\n Dimension input[] = { new Dimension(3, 2, 5), new Dimension(1, 2, 4) };\n int maxHeight = bs.maxHeight(input);\n System.out.println(\"Max height is \" + maxHeight);\n assert 11 == maxHeight;\n }\n}\n\n/**\n * Utility class to hold dimensions\n * @author tusroy\n *\n */\nclass Dimension implements Comparable {\n int height;\n int length;\n int width;\n\n Dimension(int height, int length, int width) {\n this.height = height;\n this.length = length;\n this.width = width;\n }\n\n Dimension() {\n }\n\n static Dimension createDimension(int height, int side1, int side2) {\n Dimension d = new Dimension();\n d.height = height;\n if (side1 >= side2) {\n d.length = side1;\n d.width = side2;\n } else {\n d.length = side2;\n d.width = side1;\n }\n return d;\n }\n\n /**\n * Sorts by base area(length X width)\n */\n @Override\n public int compareTo(Dimension d) {\n if (this.length * this.width >= d.length * d.width) {\n return -1;\n } else {\n return 1;\n }\n }\n\n @Override\n public String toString() {\n return \"Dimension [height=\" + height + \", length=\" + length\n + \", width=\" + width + \"]\";\n }\n}\n"
},
{
"path": "src/com/interview/dynamic/BreakMultipleWordsWithNoSpaceIntoSpace.java",
"content": "package com.interview.dynamic;\n\nimport java.util.*;\n\n/**\n * Date 08/01/2014\n * @author tusroy\n * \n * Given a string and a dictionary, split this string into multiple words such that\n * each word belongs in dictionary.\n * \n * e.g peanutbutter -> pea nut butter\n * e.g Iliketoplay -> I like to play\n * \n * Solution \n * DP solution to this problem\n * if( input[i...j] belongs in dictionary) T[i][j] = i\n * else{\n * T[i][j] = k if T[i][k-1] != -1 && T[k][j] != -1\n * \n * Test cases\n * 1) Empty string\n * 2) String where entire string is in dictionary\n * 3) String which cannot be split into words which are in dictionary\n * 3) String which can be split into words which are in dictionary \n *\n */\npublic class BreakMultipleWordsWithNoSpaceIntoSpace {\n\n \n /**\n * Recursive and slow version of breaking word problem.\n * If no words can be formed it returns null\n */\n public String breakWord(char[] str,int low,Set dictionary){\n StringBuffer buff = new StringBuffer();\n for(int i= low; i < str.length; i++){\n buff.append(str[i]);\n if(dictionary.contains(buff.toString())){\n String result = breakWord(str, i+1, dictionary);\n if(result != null){\n return buff.toString() + \" \" + result;\n }\n }\n }\n if(dictionary.contains(buff.toString())){\n return buff.toString();\n }\n return null;\n }\n \n /**\n * Dynamic programming version for breaking word problem.\n * It returns null string if string cannot be broken into multipe words\n * such that each word is in dictionary.\n * Gives preference to longer words over splits\n * e.g peanutbutter with dict{pea nut butter peanut} it would result in\n * peanut butter instead of pea nut butter.\n */\n public String breakWordDP(String word, Set dict){\n int T[][] = new int[word.length()][word.length()];\n \n for(int i=0; i < T.length; i++){\n for(int j=0; j < T[i].length ; j++){\n T[i][j] = -1; //-1 indicates string between i to j cannot be split\n }\n }\n \n //fill up the matrix in bottom up manner\n for(int l = 1; l <= word.length(); l++){\n for(int i=0; i < word.length() -l + 1 ; i++){\n int j = i + l-1;\n String str = word.substring(i,j+1);\n //if string between i to j is in dictionary T[i][j] is true\n if(dict.contains(str)){\n T[i][j] = i;\n continue;\n }\n //find a k between i+1 to j such that T[i][k-1] && T[k][j] are both true \n for(int k=i+1; k <= j; k++){\n if(T[i][k-1] != -1 && T[k][j] != -1){\n T[i][j] = k;\n break;\n }\n }\n }\n }\n if(T[0][word.length()-1] == -1){\n return null;\n }\n \n //create space separate word from string is possible\n StringBuffer buffer = new StringBuffer();\n int i = 0; int j = word.length() -1;\n while(i < j){\n int k = T[i][j];\n if(i == k){\n buffer.append(word.substring(i, j+1));\n break;\n }\n buffer.append(word.substring(i,k) + \" \");\n i = k;\n }\n \n return buffer.toString();\n }\n\n /**\n * Prints all the words possible instead of just one combination.\n * Reference\n * https://leetcode.com/problems/word-break-ii/\n */\n public List wordBreakTopDown(String s, Set wordDict) {\n Map> dp = new HashMap<>();\n int max = 0;\n for (String s1 : wordDict) {\n max = Math.max(max, s1.length());\n }\n return wordBreakUtil(s, wordDict, dp, 0, max);\n }\n\n private List wordBreakUtil(String s, Set dict, Map> dp, int start, int max) {\n if (start == s.length()) {\n return Collections.singletonList(\"\");\n }\n\n if (dp.containsKey(start)) {\n return dp.get(start);\n }\n\n List words = new ArrayList<>();\n for (int i = start; i < start + max && i < s.length(); i++) {\n String newWord = s.substring(start, i + 1);\n if (!dict.contains(newWord)) {\n continue;\n }\n List result = wordBreakUtil(s, dict, dp, i + 1, max);\n for (String word : result) {\n String extraSpace = word.length() == 0 ? \"\" : \" \";\n words.add(newWord + extraSpace + word);\n }\n }\n dp.put(start, words);\n return words;\n }\n\n /**\n * Check if any one solution exists.\n * https://leetcode.com/problems/word-break/\n */\n public boolean wordBreakTopDownOneSolution(String s, Set wordDict) {\n Map dp = new HashMap<>();\n int max = 0;\n for (String s1 : wordDict) {\n max = Math.max(max, s1.length());\n }\n return wordBreakTopDownOneSolutionUtil(s, wordDict, 0, max, dp);\n\n }\n\n private boolean wordBreakTopDownOneSolutionUtil(String s, Set dict, int start, int max, Map dp) {\n if (start == s.length()) {\n return true;\n }\n\n if (dp.containsKey(start)) {\n return dp.get(start);\n }\n\n for (int i = start; i < start + max && i < s.length(); i++) {\n String newWord = s.substring(start, i + 1);\n if (!dict.contains(newWord)) {\n continue;\n }\n if (wordBreakTopDownOneSolutionUtil(s, dict, i + 1, max, dp)) {\n dp.put(start, true);\n return true;\n }\n }\n dp.put(start, false);\n return false;\n }\n\n public boolean wordBreakBottomUp(String s, List