diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000..891c617
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,27 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000..bbcbbe7
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
diff --git a/.github/PULL_REQUEST_TEMPLATE/pull_request_template.md b/.github/PULL_REQUEST_TEMPLATE/pull_request_template.md
new file mode 100644
index 0000000..ef287c0
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE/pull_request_template.md
@@ -0,0 +1,6 @@
+# Fixes
+
+Changes in this pull Request
+-
+-
+-
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
new file mode 100644
index 0000000..de1a7b4
--- /dev/null
+++ b/.idea/workspace.xml
@@ -0,0 +1,1244 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ sum
+ tw
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1560951205497
+
+
+ 1560951205497
+
+
+ 1560964776815
+
+
+
+ 1560964776816
+
+
+ 1560979068087
+
+
+
+ 1560979068087
+
+
+ 1561101836211
+
+
+
+ 1561101836211
+
+
+ 1561103348404
+
+
+
+ 1561103348404
+
+
+ 1561178157189
+
+
+
+ 1561178157189
+
+
+ 1561193711350
+
+
+
+ 1561193711350
+
+
+ 1561344530239
+
+
+
+ 1561344530240
+
+
+ 1561375761994
+
+
+
+ 1561375761994
+
+
+ 1561707599864
+
+
+
+ 1561707599864
+
+
+ 1561788908204
+
+
+
+ 1561788908204
+
+
+ 1562145848130
+
+
+
+ 1562145848131
+
+
+ 1562586243500
+
+
+
+ 1562586243500
+
+
+ 1562678312823
+
+
+
+ 1562678312824
+
+
+ 1562678865671
+
+
+
+ 1562678865671
+
+
+ 1562679184697
+
+
+
+ 1562679184697
+
+
+ 1562679619784
+
+
+
+ 1562679619784
+
+
+ 1562679668304
+
+
+
+ 1562679668304
+
+
+ 1562869053183
+
+
+
+ 1562869053183
+
+
+ 1562913891824
+
+
+
+ 1562913891824
+
+
+ 1563142574203
+
+
+
+ 1563142574203
+
+
+ 1563142720748
+
+
+
+ 1563142720748
+
+
+ 1563184834461
+
+
+
+ 1563184834461
+
+
+ 1563438345016
+
+
+
+ 1563438345016
+
+
+ 1564485289068
+
+
+
+ 1564485289068
+
+
+ 1564486980580
+
+
+
+ 1564486980581
+
+
+ 1564487125925
+
+
+
+ 1564487125925
+
+
+ 1564845584769
+
+
+
+ 1564845584769
+
+
+ 1565279027717
+
+
+
+ 1565279027717
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ file://$PROJECT_DIR$/Arrays and Strings/InterviewBit_Min_Step_Infinite_Grid.java
+ 56
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Competitive Programming
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Arrays and Strings/D16_Product_Of_Array_Except_Self.java b/Arrays and Strings/D16_Product_Of_Array_Except_Self.java
index 8033fbc..ff80373 100644
--- a/Arrays and Strings/D16_Product_Of_Array_Except_Self.java
+++ b/Arrays and Strings/D16_Product_Of_Array_Except_Self.java
@@ -1,3 +1,4 @@
+import java.util.ArrayList;
import java.util.Scanner;
public class D16_Product_Of_Array_Except_Self {
@@ -13,6 +14,7 @@ public static int[] productExceptSelf(int[] nums) {
nums[i] = (int)Math.round(Math.exp(sum-arr[i]));
}
return nums;
+
}
//Don't make changes here.
diff --git a/Arrays and Strings/D35_Median_in_A_Stream.java b/Arrays and Strings/D35_Median_in_A_Stream.java
new file mode 100644
index 0000000..16a4693
--- /dev/null
+++ b/Arrays and Strings/D35_Median_in_A_Stream.java
@@ -0,0 +1,33 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.Collections;
+import java.util.PriorityQueue;
+import java.util.Scanner;
+
+public class D35_Median_in_A_Stream {
+ public static void main(String[] args) throws IOException {
+
+
+ Scanner scn=new Scanner(System.in);
+ int n=scn.nextInt();
+ PriorityQueue min=new PriorityQueue<>();
+ PriorityQueue max=new PriorityQueue<>(Collections.reverseOrder());
+ for(int i=0;i b = new ArrayList<>();
+// ArrayList a = new ArrayList<>(b);
+// a.addAll(b);
+// Collections.sort(a);
+ int[][] dp =new int[10][10];
+ Arrays.fill(dp[0],1);
+ for(int i=0;imax?score:max;
+ }
+ return max*10;
+ }
+}
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..e8e2c1a
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at singhaniatanay18@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
diff --git a/Competitive Programming.iml b/Competitive Programming.iml
index 1372435..142308e 100644
--- a/Competitive Programming.iml
+++ b/Competitive Programming.iml
@@ -19,6 +19,11 @@
+
+
+
+
+
diff --git a/Dyanamic Programming & Greedy/D36_ChessBoard.java b/Dyanamic Programming & Greedy/D36_ChessBoard.java
new file mode 100644
index 0000000..0c461c1
--- /dev/null
+++ b/Dyanamic Programming & Greedy/D36_ChessBoard.java
@@ -0,0 +1,50 @@
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+/*
+Find total number of Squares in a N*N cheesboard.
+
+Input:
+
+The first line contains an integer T, depicting total
+number of test cases. Then following T lines contains
+an integer N that is the side of the chessboard.
+
+Output:
+
+Each seperate line showing the maximum number of squares possible.
+*/
+
+class D36_ChessBoard {
+ public static void main (String[] args) throws IOException{
+ //code
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ PrintWriter pw = new PrintWriter(System.out);
+ int t = Integer.parseInt(br.readLine());
+ while(t-->0){
+ int n = Integer.parseInt(br.readLine());
+ int ans = chessboard(n);
+ pw.println(ans);
+ }
+ pw.flush();
+ }
+ public static int chessboard(int n){
+ int[][] dp = new int[n][n];
+ for(int i=0;i=0;i--){
+ for(int j=dp.length-2;j>=0;j--){
+ dp[i][j] = Math.min(dp[i+1][j],Math.min(dp[i][j+1],dp[i+1][j+1]))+1;
+ }
+ }
+ int sum=0;
+ for(int i=dp.length-1;i>=0;i--){
+ for(int j=dp.length-1;j>=0;j--){
+ sum+= dp[i][j];
+ }
+ }
+ return sum;
+
+ }
+}
diff --git a/Dyanamic Programming & Greedy/egg_drop.java b/Dyanamic Programming & Greedy/egg_drop.java
new file mode 100644
index 0000000..88a07c8
--- /dev/null
+++ b/Dyanamic Programming & Greedy/egg_drop.java
@@ -0,0 +1,41 @@
+/*package whatever //do not write package name here */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class egg_drop {
+ public static void main (String[] args) {
+ //code
+ Scanner sc = new Scanner(System.in);
+ int t = sc.nextInt();
+ int[][] eggDrop = new int[11][51];
+ eggDropfill(eggDrop,10,50);
+ while(t-->0){
+ int n = sc.nextInt();
+ int k = sc.nextInt();
+ System.out.println(eggDrop[n][k]);
+ }
+ }
+ public static void eggDropfill(int[][] dp,int max_n,int max_k){
+ for(int i=1;i<=max_n;i++){
+ dp[i][0] = 0;
+ dp[i][1] = 1;
+ }
+ for(int i=1;i<=max_k;i++){
+ dp[1][i] = i;
+ }
+ int res =0;
+ for(int i=2;i<=max_n;i++){
+ for(int j=2;j<=max_k;j++){
+ dp[i][j] = Integer.MAX_VALUE;
+ for(int k=1;k<=j;k++){
+ res = 1 + Math.max(dp[i][j-k],dp[i-1][k-1]);
+ if(res> list;
+ Graph(int V){
+ this.V = V;
+ list = new ArrayList<>();
+ for (int i = 0; i < V; i++) {
+ list.add(new LinkedList());
+ }
+ }
+ void addEdge(int src,int dest){
+ LinkedList s = list.get(src);
+ s.add(dest);
+ LinkedList d = list.get(dest);
+ d.add(src);
+ }
+ void printGraph(){
+ for (int i = 0; i ll = list.get(i);
+ for (Integer curr:ll){
+ System.out.print(curr+", ");
+ }
+ System.out.println();
+ }
+ }
+ void BFS(int root){
+ boolean[] visited = new boolean[list.size()];
+ Queue q = new LinkedList<>();
+
+ visited[root] = true;
+ q.add(root);
+ q.add(null);
+ while (!q.isEmpty()){
+ Integer curr = q.remove();
+ if(curr==null){
+ System.out.println();
+ if(!q.isEmpty()){
+ q.add(null);
+ }
+ continue;
+ }
+ System.out.print(curr+", ");
+ LinkedList adj = list.get(curr);
+ for(Integer connected : adj){
+ if(!visited[connected]){
+ visited[connected] = true;
+ q.add(connected);
+ }
+ }
+ }
+ }
+ }
+ public static void main(String[] args) {
+ Graph graph = new Graph(5);
+ graph.addEdge(0,1);
+ graph.addEdge(0,4);
+ graph.addEdge(4,1);
+ graph.addEdge(4,3);
+ graph.addEdge(3,1);
+ graph.addEdge(3,2);
+ graph.addEdge(1,2);
+ graph.printGraph();
+ graph.BFS(0);
+ }
+}
diff --git a/Graphs/D60_DFS.java b/Graphs/D60_DFS.java
new file mode 100644
index 0000000..062da36
--- /dev/null
+++ b/Graphs/D60_DFS.java
@@ -0,0 +1,87 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class D60_DFS {
+ static class Graph{
+ int V;
+ ArrayList> list;
+ Graph(int V){
+ this.V = V;
+ list = new ArrayList<>();
+ for (int i = 0; i < V; i++) {
+ list.add(new LinkedList());
+ }
+ }
+ void addEdge(int src,int dest){
+ LinkedList s = list.get(src);
+ s.add(dest);
+ LinkedList d = list.get(dest);
+ d.add(src);
+ }
+ void printGraph(){
+ for (int i = 0; i ll = list.get(i);
+ for (Integer curr:ll){
+ System.out.print(curr+", ");
+ }
+ System.out.println();
+ }
+ }
+ void BFS(int root){
+ boolean[] visited = new boolean[list.size()];
+ Queue q = new LinkedList<>();
+
+ visited[root] = true;
+ q.add(root);
+ q.add(null);
+ while (!q.isEmpty()){
+ Integer curr = q.remove();
+ if(curr==null){
+ System.out.println();
+ if(!q.isEmpty()){
+ q.add(null);
+ }
+ continue;
+ }
+ System.out.print(curr+", ");
+ LinkedList adj = list.get(curr);
+ for(Integer connected : adj){
+ if(!visited[connected]){
+ visited[connected] = true;
+ q.add(connected);
+ }
+ }
+ }
+ }
+ void DFSUtil(int v,boolean[] visited){
+ visited[v] = true;
+ System.out.println(v);
+ LinkedList ll = list.get(v);
+ for (int i:ll){
+ if(!visited[i]){
+ DFSUtil(i,visited);
+ }
+ }
+ }
+ void DFS(int root){
+ boolean[] visited = new boolean[V];
+ DFSUtil(root,visited);
+ }
+
+ }
+ public static void main(String[] args) {
+ Graph graph = new Graph(5);
+ graph.addEdge(0,1);
+ graph.addEdge(0,4);
+ graph.addEdge(4,1);
+ graph.addEdge(4,3);
+ graph.addEdge(3,1);
+ graph.addEdge(3,2);
+ graph.addEdge(1,2);
+ graph.printGraph();
+ graph.BFS(0);
+ graph.DFS(0);
+ }
+}
diff --git a/Graphs/D60_Representation.java b/Graphs/D60_Representation.java
new file mode 100644
index 0000000..ae1a21a
--- /dev/null
+++ b/Graphs/D60_Representation.java
@@ -0,0 +1,47 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+
+public class D60_Representation {
+ static class Graph{
+ int V;
+ ArrayList> list;
+ Graph(int V){
+ this.V = V;
+ list = new ArrayList<>();
+ for (int i = 0; i < V; i++) {
+ list.add(new LinkedList());
+ }
+ }
+ void addEdge(int src,int dest){
+ LinkedList s = list.get(src);
+ s.add(dest);
+ LinkedList d = list.get(dest);
+ d.add(src);
+ }
+ void printGraph(){
+ for (int i = 0; i ll = list.get(i);
+ for (Integer curr:ll){
+ System.out.print(curr+", ");
+ }
+ System.out.println();
+ }
+ }
+
+ }
+ public static void main(String[] args) {
+ Graph graph = new Graph(5);
+ graph.addEdge(0,1);
+ graph.addEdge(0,4);
+ graph.addEdge(4,1);
+ graph.addEdge(4,3);
+ graph.addEdge(3,1);
+ graph.addEdge(3,2);
+ graph.addEdge(1,2);
+ graph.printGraph();
+ }
+}
+
+
+
diff --git a/Graphs/D61_LenOfShortestChain_ToReachATarget.java b/Graphs/D61_LenOfShortestChain_ToReachATarget.java
new file mode 100644
index 0000000..4e2e056
--- /dev/null
+++ b/Graphs/D61_LenOfShortestChain_ToReachATarget.java
@@ -0,0 +1,58 @@
+import java.util.*;
+
+public class D61_LenOfShortestChain_ToReachATarget {
+ public static void main(String[] args) {
+ Set dict = new HashSet<>();
+ dict.add("poon");
+ dict.add("plee");
+ dict.add("same");
+ dict.add("poie");
+ dict.add("plie");
+ dict.add("poin");
+ dict.add("plea");
+ System.out.println(shortestChainLen(dict,"toon","plea"));
+
+ }
+ public static int shortestChainLen(Set dict,String src,String target){
+ Queue q = new LinkedList<>();
+ Pair item = new Pair(src,1);
+ q.add(item);
+ Set used = new HashSet<>();
+ while (!q.isEmpty()){
+ Pair curr = q.remove();
+ for(String w:dict){
+ if(!used.contains(w) && isAdjacent(w,curr.word)){
+ item.word = w;
+ item.len = curr.len+1;
+ q.add(item);
+ used.add(w);
+ if(w.equals(target))
+ return item.len;
+ }
+ }
+ }
+ return 0;
+ }
+ private static boolean isAdjacent(String word, String word1) {
+ int count=0;
+
+ for (int i = 0; i < word.length(); i++) {
+ char a = word.charAt(i);
+ char b = word1.charAt(i);
+ if(a!=b)
+ count++;
+ if(count>1)
+ return false;
+
+ }
+ return true;
+ }
+}
+class Pair{
+ String word;
+ int len;
+ Pair(String word,int len){
+ this.word = word;
+ this.len = len;
+ }
+}
diff --git a/Graphs/D61_Topological_Sort.java b/Graphs/D61_Topological_Sort.java
new file mode 100644
index 0000000..e7cdf50
--- /dev/null
+++ b/Graphs/D61_Topological_Sort.java
@@ -0,0 +1,49 @@
+import java.util.LinkedList;
+import java.util.Stack;
+
+public class D61_Topological_Sort {
+ public static void main(String[] args) {
+ Graph graph = new Graph(5);
+ graph.addEdge(0,1);
+ graph.addEdge(0,4);
+ graph.addEdge(4,1);
+ graph.addEdge(4,3);
+ graph.addEdge(3,1);
+ graph.addEdge(3,2);
+ graph.addEdge(1,2);
+ graph.printGraph();
+ //though pointless here since while adding edge
+ //it makes undirected graph in which topological sort
+ //is DFS only
+ String ans = topologicalSort(graph);
+ System.out.println(ans);
+ }
+ public static String topologicalSort(Graph graph){
+ boolean[] visited = new boolean[graph.V];
+ topoSort = new Stack<>();
+ for (int i = 0; i topoSort;
+ private static void topologicalSortUtil(Graph graph, boolean[] visited, int i) {
+ visited[i] = true;
+ LinkedList adj = graph.list.get(i);
+ for (int ele:adj){
+ if (!visited[ele]){
+ topologicalSortUtil(graph, visited, ele);
+ }
+ }
+ topoSort.push(i);
+ }
+}
diff --git a/Graphs/Graph.java b/Graphs/Graph.java
new file mode 100644
index 0000000..bad7fa1
--- /dev/null
+++ b/Graphs/Graph.java
@@ -0,0 +1,30 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+
+public class Graph {
+ int V;
+ ArrayList> list;
+ Graph(int V){
+ this.V = V;
+ list = new ArrayList<>();
+ for (int i = 0; i < V; i++) {
+ list.add(new LinkedList());
+ }
+ }
+ void addEdge(int src,int dest){
+ LinkedList s = list.get(src);
+ s.add(dest);
+ LinkedList d = list.get(dest);
+ d.add(src);
+ }
+ void printGraph(){
+ for (int i = 0; i ll = list.get(i);
+ for (Integer curr:ll){
+ System.out.print(curr+", ");
+ }
+ System.out.println();
+ }
+ }
+}
diff --git a/Graphs/evenForest.java b/Graphs/evenForest.java
new file mode 100644
index 0000000..2300fce
--- /dev/null
+++ b/Graphs/evenForest.java
@@ -0,0 +1,79 @@
+import java.io.*;
+import java.math.*;
+import java.security.*;
+import java.text.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.function.*;
+import java.util.regex.*;
+import java.util.stream.*;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toList;
+
+public class evenForest {
+
+ // Complete the evenForest function below.
+ static int evenForestfunc(int t_nodes, int t_edges, List t_from, List t_to) {
+ ArrayList[] graph = new ArrayList[t_nodes];
+ for(int i=0;i();
+ for(int i=0;i[] graph,int src){
+ if(visited[src]) return 0;
+ int ans = 0;
+ visited[src] = true;
+ for(int i:graph[src]){
+ if(visited[i]) continue;
+ int currAns = breakTree(graph,i);
+ if(currAns%2==0) count++;
+ ans+=currAns;
+ }
+ return ans+1;
+
+ }
+ public static boolean[] visited;
+ public static int count = 0;
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));
+
+ String[] tNodesEdges = bufferedReader.readLine().replaceAll("\\s+$", "").split(" ");
+
+ int tNodes = Integer.parseInt(tNodesEdges[0]);
+ int tEdges = Integer.parseInt(tNodesEdges[1]);
+
+ List tFrom = new ArrayList<>();
+ List tTo = new ArrayList<>();
+
+ IntStream.range(0, tEdges).forEach(i -> {
+ try {
+ String[] tFromTo = bufferedReader.readLine().replaceAll("\\s+$", "").split(" ");
+
+ tFrom.add(Integer.parseInt(tFromTo[0]));
+ tTo.add(Integer.parseInt(tFromTo[1]));
+ } catch (IOException ex) {
+ throw new RuntimeException(ex);
+ }
+ });
+
+ int res = evenForestfunc(tNodes, tEdges, tFrom, tTo);
+
+ bufferedWriter.write(String.valueOf(res));
+ bufferedWriter.newLine();
+
+ bufferedReader.close();
+ bufferedWriter.close();
+ }
+}
diff --git a/Graphs/has_path.java b/Graphs/has_path.java
new file mode 100644
index 0000000..5121465
--- /dev/null
+++ b/Graphs/has_path.java
@@ -0,0 +1,47 @@
+public class has_path{
+ static class Edge{
+ int src;
+ int nbr;
+ int wt;
+
+ Edge(int src,int nbr, int wt){
+ this.src = src;
+ this.nbr = nbr;
+ this.wt = wt;
+ }
+ }
+ public static void main(String[] args) {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+ int vtces = Interger.parseInt(br.readLine());
+ ArrayList[] graph = new ArrayList[vtces];
+ for(int i=0;i();
+
+ int edges = Integer.parseInt(br.readLine());
+ for(int i=0;i[] graph,int src, int dest,boolean[] visited){
+ if(src==dest) return true;
+ visited[src] = true;
+ for(Edge edge : graph[src]){
+ if(visited[edge.nbr]) continue;
+ boolean hasNbrPath = hasPath(graph,edge.nbr,dest,visited);
+ if(hasNbrPath) return true;
+ }
+ return false;
+ }
+}
\ No newline at end of file
diff --git a/Graphs/journeyToMoon.java b/Graphs/journeyToMoon.java
new file mode 100644
index 0000000..1a69558
--- /dev/null
+++ b/Graphs/journeyToMoon.java
@@ -0,0 +1,76 @@
+import java.io.*;
+import java.math.*;
+import java.security.*;
+import java.text.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.regex.*;
+
+public class journeyToMoon {
+
+ // Complete the journeyToMoon function below.
+ static long journeytoMoon(int n, int[][] ast) {
+ if(n<=1) return 0;
+ ArrayList> graph = new ArrayList<>();
+ for(int i=0;i());
+ for(int i=0;i> graph, int src){
+ if(visited[src]) return 0;
+ long ans = 0;
+ visited[src] = true;
+ for(int nbr: graph.get(src)){
+ if(visited[nbr]) continue;
+ ans += getConnected(graph,nbr);
+ }
+ return ans+1;
+ }
+ public static boolean[] visited;
+
+ private static final Scanner scanner = new Scanner(System.in);
+
+ public static void main(String[] args) throws IOException {
+ BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));
+
+ String[] np = scanner.nextLine().split(" ");
+
+ int n = Integer.parseInt(np[0]);
+
+ int p = Integer.parseInt(np[1]);
+
+ int[][] astronaut = new int[p][2];
+
+ for (int i = 0; i < p; i++) {
+ String[] astronautRowItems = scanner.nextLine().split(" ");
+ scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
+
+ for (int j = 0; j < 2; j++) {
+ int astronautItem = Integer.parseInt(astronautRowItems[j]);
+ astronaut[i][j] = astronautItem;
+ }
+ }
+
+ long result = journeytoMoon(n, astronaut);
+
+ bufferedWriter.write(String.valueOf(result));
+ bufferedWriter.newLine();
+
+ bufferedWriter.close();
+
+ scanner.close();
+ }
+}
diff --git a/Graphs/schedule_course.java b/Graphs/schedule_course.java
new file mode 100644
index 0000000..588fbb7
--- /dev/null
+++ b/Graphs/schedule_course.java
@@ -0,0 +1,36 @@
+class schedule_course {
+ public int[] findOrder(int num, int[][] pre) {
+ ArrayList[] graph = new ArrayList[num];
+ for(int i=0;i();
+ for(int i=0;i[] graph,int src){
+ if(done[src]) return true;
+ if(visited[src]) return false;
+
+ visited[src] = true;
+ for(int i:graph[src]){
+ if(isOrder(graph,i)) continue;
+ return false;
+ }
+ done[src] = true;
+ ans[k++] = src;
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/LinkedList/D1_arrange_vowels_and_consonants.java b/LinkedList/D1_arrange_vowels_and_consonants.java
new file mode 100644
index 0000000..4839fbf
--- /dev/null
+++ b/LinkedList/D1_arrange_vowels_and_consonants.java
@@ -0,0 +1,102 @@
+import java.util.Scanner;
+
+public class D1_arrange_vowels_and_consonants{
+
+ public static void main(String args[]) {
+ Scanner sc = new Scanner(System.in);
+
+ int n = sc.nextInt();
+ char h = sc.next().charAt(0);
+ insert(h);
+
+ for (int i = 1; i < n; i++) {
+ char ch = sc.next().charAt(0);
+ insert(ch);
+ }
+
+ head = arcv(head);
+ display();
+
+ }
+
+ //---------------------------------------------------------------
+ //This is a functional problem. Only this function has to be written.
+ // This function should return the head of node after sorting.
+ public static Node arcv(Node head) {
+ Node vowel = null;
+ Node vt = null;
+ Node consonant = null;
+ Node ct = null;
+ while(head!=null){
+ if(isVowel(head.data)){
+ if(vowel==null){
+ vowel = new Node(head.data,null);
+ vt = vowel;
+ }else{
+ vt.next = new Node(head.data,null);
+ vt = vt.next;
+ }
+ }
+ else{
+ if(consonant==null){
+ consonant = new Node(head.data,null);
+ ct = consonant;
+ }else{
+ ct.next = new Node(head.data,null);
+ ct = ct.next;
+ }
+ }
+
+ head = head.next;
+ }
+ if(vowel!=null)
+ vt.next = consonant;
+ else
+ return consonant;
+ return vowel;
+
+ }
+ public static boolean isVowel(char ch){
+ if(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u')
+ return true;
+
+ return false;
+ }
+ //------------------------------------------------------------------
+
+
+ private static class Node {
+ char data;
+ Node next;
+
+ public Node(char data, Node next) {
+ this.data = data;
+ this.next = next;
+ }
+
+ }
+
+ static Node head;
+ static Node tail;
+ static int size;
+
+ public static void insert(char data) {
+
+ Node nn = new Node(data, null);
+ if (head == null) {
+ head = nn;
+ tail = nn;
+ } else {
+ tail.next = nn;
+ tail = nn;
+ }
+ size++;
+ }
+
+ public static void display() {
+ for (Node node = head; node != null; node = node.next) {
+ System.out.print(node.data+" ");
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/LinkedList/D35_GDG_SamsungProb_DeleteNode.java b/LinkedList/D35_GDG_SamsungProb_DeleteNode.java
new file mode 100644
index 0000000..e074704
--- /dev/null
+++ b/LinkedList/D35_GDG_SamsungProb_DeleteNode.java
@@ -0,0 +1,31 @@
+/*
+You are given a pointer/reference to the node which
+is to be deleted from the linked list of N nodes.
+The task is to delete the node.
+Pointer/ reference to head node is not given.
+
+Note: No head reference is given to you.
+*/
+
+
+class Node{
+ int data;
+ Node next;
+}
+
+
+public class D35_GDG_SamsungProb_DeleteNode {
+ void deleteNode(Node node)
+ {
+ // Your code here
+ Node temp = node;
+ Node prev = null;
+ while(temp.next!=null){
+ temp.data = temp.next.data;
+ prev = temp;
+ temp = temp.next;
+ }
+ if(prev==null)
+ prev.next = null;
+ }
+}
diff --git a/LinkedList/remove_duplicates.java b/LinkedList/remove_duplicates.java
new file mode 100644
index 0000000..28eb948
--- /dev/null
+++ b/LinkedList/remove_duplicates.java
@@ -0,0 +1,102 @@
+// { Driver Code Starts
+/* package whatever; // don't place package name! */
+import java.util.*;
+class Node
+ {
+ int data;
+ Node next;
+ Node(int d) {data = d; next = null; }
+ }
+class remove_duplicates
+{
+ Node head;
+ Node tail;
+ public void addToTheLast(Node node)
+ {
+ if (head == null)
+ {
+ head = node;
+ tail = node;
+ }
+ else
+ {
+ tail.next = node;
+ tail = node;
+ }
+ }
+ void printList()
+ {
+ Node temp = head;
+ while (temp != null)
+ {
+ System.out.print(temp.data+" ");
+ temp = temp.next;
+ }
+ System.out.println();
+ }
+ /* Drier program to test above functions */
+ public static void main(String args[])
+ {
+ Scanner sc = new Scanner(System.in);
+ int t=sc.nextInt();
+ while(t>0)
+ {
+ int n = sc.nextInt();
+ Remove_Duplicate_From_LL llist = new Remove_Duplicate_From_LL();
+ int a1=sc.nextInt();
+ Node head= new Node(a1);
+ llist.addToTheLast(head);
+ for (int i = 1; i < n; i++)
+ {
+ int a = sc.nextInt();
+ llist.addToTheLast(new Node(a));
+ }
+
+ GfG g = new GfG();
+ llist.head = g.removeDuplicates(llist.head);
+ llist.printList();
+
+ t--;
+ }
+ }}// } Driver Code Ends
+
+
+/*
+class Node
+ {
+ int data;
+ Node next;
+ Node(int d) {data = d; next = null; }
+ }
+*/
+
+class GfG
+{
+ // head: head node
+ Node removeDuplicates(Node root)
+ {
+ // Your code here
+ Node prev = null;
+ Node curr = root;
+ Node next = root.next;
+ while(curr!=null){
+ if(prev==null) {
+ prev = curr;
+ curr = next;
+ next = next==null?null:next.next;
+ continue;
+ }
+ if(prev.data==curr.data){
+ prev.next = next;
+ curr = next;
+ next = next==null?null:next.next;
+ continue;
+ }
+ prev = curr;
+ curr = next;
+ next = next==null?null:next.next;
+ }
+
+ return root;
+ }
+}
diff --git a/MakeMyTrip/LRUCache.java b/MakeMyTrip/LRUCache.java
new file mode 100644
index 0000000..d840eeb
--- /dev/null
+++ b/MakeMyTrip/LRUCache.java
@@ -0,0 +1,79 @@
+// { Driver Code Starts
+import java.io.*;
+import java.util.*;
+import java.lang.*;
+
+ public class LRUDesign {
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader read =
+ new BufferedReader(new InputStreamReader(System.in));
+
+ int t = Integer.parseInt(read.readLine());
+
+ while (t-- > 0) {
+
+ int capacity = Integer.parseInt(read.readLine());
+ int queries = Integer.parseInt(read.readLine());
+ LRUCache cache = new LRUCache(capacity);
+ String str[] = read.readLine().trim().split(" ");
+ int len = str.length;
+ int itr = 0;
+
+ for (int i = 0; (i < queries) && (itr < len); i++) {
+ String queryType = str[itr++];
+ if (queryType.equals("SET")) {
+ int key = Integer.parseInt(str[itr++]);
+ int value = Integer.parseInt(str[itr++]);
+ cache.set(key, value);
+ }
+ if (queryType.equals("GET")) {
+ int key = Integer.parseInt(str[itr++]);
+ System.out.print(cache.get(key) + " ");
+ }
+ }
+ System.out.println();
+ }
+ }
+}
+// } Driver Code Ends
+
+
+// design the class in the most optimal way
+class LRUCache
+{
+ Map map ;
+ int capacity ;
+
+ public LRUCache(int N) {
+
+ this.map = new LinkedHashMap();
+ this.capacity = N;
+ }
+
+ public int get(int x) {
+ int key = x;
+ if(!map.containsKey(key)) return -1;
+ int value = map.get(key);
+ if(map.size()>1) {
+ map.remove(key);
+ map.put(key,value);
+ }
+ return value;
+ }
+
+ public void set(int x, int y) {
+ int key = x;
+ int value = y;
+ if(!map.containsKey(key)) {
+ if(map.size()==capacity) {
+ int firstKey = map.keySet().iterator().next();
+ map.remove(firstKey);
+ }
+ map.put(key,value);
+ } else {
+ map.remove(key);
+ map.put(key,value);
+ }
+}
+}
diff --git a/MakeMyTrip/binary_tree_in_vertical_order.java b/MakeMyTrip/binary_tree_in_vertical_order.java
new file mode 100644
index 0000000..705c7a4
--- /dev/null
+++ b/MakeMyTrip/binary_tree_in_vertical_order.java
@@ -0,0 +1,162 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+//Contributed by Sudarshan Sharma
+import java.util.LinkedList;
+import java.util.Queue;
+import java.io.*;
+import java.util.*;
+
+class Node{
+ int data;
+ Node left;
+ Node right;
+ Node(int data){
+ this.data = data;
+ left=null;
+ right=null;
+ }
+}
+
+class GfG {
+
+ static Node buildTree(String str){
+
+ if(str.length()==0 || str.charAt(0)=='N'){
+ return null;
+ }
+
+ String ip[] = str.split(" ");
+ // Create the root of the tree
+ Node root = new Node(Integer.parseInt(ip[0]));
+ // Push the root to the queue
+
+ Queue queue = new LinkedList<>();
+
+ queue.add(root);
+ // Starting from the second element
+
+ int i = 1;
+ while(queue.size()>0 && i < ip.length) {
+
+ // Get and remove the front of the queue
+ Node currNode = queue.peek();
+ queue.remove();
+
+ // Get the current node's value from the string
+ String currVal = ip[i];
+
+ // If the left child is not null
+ if(!currVal.equals("N")) {
+
+ // Create the left child for the current node
+ currNode.left = new Node(Integer.parseInt(currVal));
+ // Push it to the queue
+ queue.add(currNode.left);
+ }
+
+ // For the right child
+ i++;
+ if(i >= ip.length)
+ break;
+
+ currVal = ip[i];
+
+ // If the right child is not null
+ if(!currVal.equals("N")) {
+
+ // Create the right child for the current node
+ currNode.right = new Node(Integer.parseInt(currVal));
+
+ // Push it to the queue
+ queue.add(currNode.right);
+ }
+ i++;
+ }
+
+ return root;
+ }
+ static void printInorder(Node root)
+ {
+ if(root == null)
+ return;
+
+ printInorder(root.left);
+ System.out.print(root.data+" ");
+
+ printInorder(root.right);
+ }
+
+ public static void main (String[] args) throws IOException{
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+ int t=Integer.parseInt(br.readLine());
+
+ while(t-- > 0){
+ String s = br.readLine();
+ Node root = buildTree(s);
+ BinaryTree obj = new BinaryTree();
+ ArrayList res = obj.verticalOrder(root);
+ for (Integer num : res) System.out.print(num + " ");
+ System.out.println();
+
+ }
+ }
+}
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+
+/*class Node
+{
+ int data;
+ Node left, right;
+
+ Node(int key)
+ {
+ data = key;
+ left = right = null;
+ }
+}*/
+
+class BinaryTree
+{ static SortedMap> fmap;
+ static ArrayList verticalOrder(Node root)
+ {
+ // add your code here
+ fmap = new TreeMap<>();
+ HashMap map = new HashMap<>();
+ ArrayList ans = new ArrayList<>();
+ Queue q = new LinkedList<>();
+ q.add(root);
+ q.add(null);
+ map.put(root,0);
+ while(!q.isEmpty()){
+ Node curr = q.remove();
+ if(curr==null){
+ if(!q.isEmpty()) q.add(null);
+ continue;
+ }
+ int lvl = map.get(curr);
+ if(curr.left!=null){
+ q.add(curr.left);
+ map.put(curr.left,lvl-1);
+ }
+ if(curr.right!=null){
+ q.add(curr.right);
+ map.put(curr.right,lvl+1);
+ }
+ ArrayList list = fmap.getOrDefault(lvl,new ArrayList<>());
+ list.add(curr.data);
+ fmap.put(lvl,list);
+ }
+ for(int i:fmap.keySet()){
+ ans.addAll(fmap.get(i));
+ }
+ return ans;
+
+ }
+
+}
\ No newline at end of file
diff --git a/MakeMyTrip/count_type_char.java b/MakeMyTrip/count_type_char.java
new file mode 100644
index 0000000..129919b
--- /dev/null
+++ b/MakeMyTrip/count_type_char.java
@@ -0,0 +1,29 @@
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+class GFG {
+public static void main (String[] args) {
+ Scanner sc =new Scanner(System.in);
+ int t = sc.nextInt();
+ sc.nextLine();
+ while(t-->0){
+ int a=0;
+ int b=0;
+ int c=0;
+ int d=0;
+ String n=sc.nextLine();
+
+ for(int i=0;i='a' && n.charAt(i)<='z') a++;
+ else if(n.charAt(i)>='A' && n.charAt(i)<='Z') b++;
+ else if(n.charAt(i)>='0' && n.charAt(i)<='9') c++;
+
+ }
+ System.out.println(b);
+ System.out.println(a);
+ System.out.println(c);
+ System.out.println(n.length()-a-b-c);
+ }
+
+ }
+}
\ No newline at end of file
diff --git a/MakeMyTrip/distinct_palindrome_substrings.java b/MakeMyTrip/distinct_palindrome_substrings.java
new file mode 100644
index 0000000..f69b4a7
--- /dev/null
+++ b/MakeMyTrip/distinct_palindrome_substrings.java
@@ -0,0 +1,45 @@
+/*package whatever //do not write package name here */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class GFG {
+ public static void main (String[] args) {
+ //code
+ Scanner sc = new Scanner(System.in);
+ int t = sc.nextInt();
+ while(t-->0){
+ String s = sc.next();
+ System.out.println(getSubs(s));
+ }
+ }
+ public static int getSubs(String s){
+ int ans = 0;
+ char[] ar = s.toCharArray();
+ boolean[][] dp = new boolean[ar.length][ar.length];
+ int n = ar.length;
+ for(int i=0;ij-1) continue;
+ dp[i][j] = dp[i+1][j-1];
+ }
+ }
+ }
+ HashSet set = new HashSet();
+ for(int gap=0;gap0){
+ int n = (2*sc.nextInt())+2;
+ int[] arr = new int[n];
+ HashSet set = new HashSet();
+ for(int i=0;i0){
+ int n = sc.nextInt();
+ int ans = -1;
+ for(int i=0;i0){
+
+ int V = sc.nextInt();
+ NTree ntree1 = new NTree(V);
+ NTree ntree2 = new NTree(V);
+ int e = sc.nextInt();
+ for(int i = 0; i < e; i++){
+ ntree1.addEdge(sc.nextInt(),sc.nextInt());
+ }
+ for(int i = 0; i < e; i++){
+ ntree2.addEdge(sc.nextInt(),sc.nextInt());
+ }
+
+ boolean isMirror = true;
+ for(int j = 0; j < V&&isMirror; j++){
+ int n1Size = ntree1.adj.get(j).size();
+ int n2Size = ntree2.adj.get(j).size();
+ if(n1Size==n2Size){
+ for(int i = 0; i< n1Size && isMirror; i++ ){
+ int n1 = ntree1.adj.get(j).get(i);
+ int n2 = ntree2.adj.get(j).get(n1Size-i-1);
+ if(n1!=n2){
+ isMirror = false;
+ }
+ }
+ }else{
+ isMirror = false;
+ }
+ }
+ if(isMirror){
+ System.out.println(1);
+ }else{
+ System.out.println(0);
+ }
+ t--;
+ }
+ }
+
+ static class NTree {
+
+ int V ;
+ ArrayList> adj;
+
+ NTree(int V){
+ this.V = V;
+ adj = new ArrayList<>();
+ for(int i = 0 ; i < V; i++){
+ adj.add(new LinkedList<>());
+ }
+ }
+
+ public void addEdge(int u, int v){
+ adj.get(u-1).add(v-1);
+ }
+
+
+ }
+
+}
\ No newline at end of file
diff --git a/MakeMyTrip/isSubTree.java b/MakeMyTrip/isSubTree.java
new file mode 100644
index 0000000..538cfdc
--- /dev/null
+++ b/MakeMyTrip/isSubTree.java
@@ -0,0 +1,143 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.io.*;
+import java.util.*;
+
+class Node{
+ int data;
+ Node left;
+ Node right;
+ Node(int data){
+ this.data = data;
+ left=null;
+ right=null;
+ }
+}
+
+class GfG {
+
+ static Node buildTree(String str){
+
+ if(str.length()==0 || str.charAt(0)=='N'){
+ return null;
+ }
+
+ String ip[] = str.split(" ");
+ // Create the root of the tree
+ Node root = new Node(Integer.parseInt(ip[0]));
+ // Push the root to the queue
+
+ Queue queue = new LinkedList<>();
+
+ queue.add(root);
+ // Starting from the second element
+
+ int i = 1;
+ while(queue.size()>0 && i < ip.length) {
+
+ // Get and remove the front of the queue
+ Node currNode = queue.peek();
+ queue.remove();
+
+ // Get the current node's value from the string
+ String currVal = ip[i];
+
+ // If the left child is not null
+ if(!currVal.equals("N")) {
+
+ // Create the left child for the current node
+ currNode.left = new Node(Integer.parseInt(currVal));
+ // Push it to the queue
+ queue.add(currNode.left);
+ }
+
+ // For the right child
+ i++;
+ if(i >= ip.length)
+ break;
+
+ currVal = ip[i];
+
+ // If the right child is not null
+ if(!currVal.equals("N")) {
+
+ // Create the right child for the current node
+ currNode.right = new Node(Integer.parseInt(currVal));
+
+ // Push it to the queue
+ queue.add(currNode.right);
+ }
+ i++;
+ }
+
+ return root;
+ }
+ static void printInorder(Node root){
+ if(root == null)
+ return;
+
+ printInorder(root.left);
+ System.out.print(root.data+" ");
+
+ printInorder(root.right);
+ }
+
+ public static void main (String[] args) throws IOException {
+ BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
+
+ int t=Integer.parseInt(br.readLine());
+ while(t-- > 0){
+ String tt= br.readLine();
+ Node rootT = buildTree(tt);
+
+ String s= br.readLine();
+ Node rootS = buildTree(s);
+ // printInorder(root);
+
+ Tree tr=new Tree();
+ boolean st=tr.isSubtree(rootT, rootS);
+ if(st==true){
+ System.out.println("1");
+ }else{
+ System.out.println("0");
+ }
+ }
+ }
+}// } Driver Code Ends
+
+
+//User function Template for Java
+
+/*complete the given function*/
+
+/* class Node{
+ int data;
+ Node left,right;
+ Node(int d)
+ {
+ data=d;
+ left=null;
+ right=null;
+ }
+}*/
+
+class Tree {
+ public static boolean isSubtree(Node T, Node S) {
+ // add code here.
+ if(S==null && T==null)
+ return true;
+ if(T==null || S==null)
+ return false;
+
+ boolean ans = false;
+ if(T.data==S.data){
+ ans = isSubtree(T.left,S.left) && isSubtree(T.right,S.right);
+ }
+ if(ans) return ans;
+ return isSubtree(T.left,S) || isSubtree(T.right,S);
+ }
+}
\ No newline at end of file
diff --git a/MakeMyTrip/is_subarray_with_sum_0.java b/MakeMyTrip/is_subarray_with_sum_0.java
new file mode 100644
index 0000000..04c14d5
--- /dev/null
+++ b/MakeMyTrip/is_subarray_with_sum_0.java
@@ -0,0 +1,31 @@
+/*package whatever //do not write package name here */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class GFG {
+ public static void main (String[] args) {
+ //code
+ Scanner sc = new Scanner(System.in);
+ int t = sc.nextInt();
+ while(t-->0){
+ int n = sc.nextInt();
+ int[] arr = new int[n];
+ for(int i=0;i sums = new HashSet<>();
+ for(int i:arr){
+ sums.add(sum);
+ sum+=i;
+ if(sums.contains(sum)) {
+ flag = true;
+ break;
+ }
+ }
+ if(flag) System.out.println("Yes");
+ else System.out.println("No");
+ }
+ }
+}
\ No newline at end of file
diff --git a/MakeMyTrip/knights_min_path_chess.java b/MakeMyTrip/knights_min_path_chess.java
new file mode 100644
index 0000000..e03813f
--- /dev/null
+++ b/MakeMyTrip/knights_min_path_chess.java
@@ -0,0 +1,57 @@
+/*package whatever //do not write package name here */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class GFG {
+ static int[] xv = new int[]{2, 2, -2, -2, 1, -1, 1, -1};
+ static int[] yv = new int[]{1, -1, 1, -1, 2, 2, -2, -2};
+
+ public static void main (String[] args) {
+ //code
+ Scanner sc = new Scanner(System.in);
+ int t = sc.nextInt();
+ while(t-->0){
+ int N = sc.nextInt();
+ int sx = sc.nextInt();
+ int sy = sc.nextInt();
+ int tx = sc.nextInt();
+ int ty = sc.nextInt();
+ int[][] chess = new int[N][N];
+ for(int i = 0; i < N; i++){
+ for(int j = 0; j < N; j++){
+ chess[i][j] = 0;
+ }
+ }
+ System.out.println(moves(chess, N, sx-1, sy-1, tx-1, ty-1)); }
+ }
+
+ static int moves(int[][] chess, int N, int kx, int ky, int tx, int ty){
+ Queue iq = new LinkedList();
+ Queue jq = new LinkedList();
+ Queue moves = new LinkedList();
+
+ iq.add(kx);
+ jq.add(ky);
+ moves.add(0);
+
+ while(!iq.isEmpty()){
+ int x = iq.remove();
+ int y = jq.remove();
+ int move = moves.remove();
+ if(x == tx && y == ty) return move;
+ chess[x][y] = -1;
+ for(int p = 0; p < 8; p++){
+ int xn = x + xv[p];
+ int yn = y + yv[p];
+ if(xn < 0 || yn < 0) continue;
+ if(xn >= N || yn >= N) continue;
+ if(chess[xn][yn] == -1) continue;
+ iq.add(xn);
+ jq.add(yn);
+ moves.add(move + 1);
+ }
+ }
+ return 1;
+ }}
\ No newline at end of file
diff --git a/MakeMyTrip/largest_num_in_k_swaps.java b/MakeMyTrip/largest_num_in_k_swaps.java
new file mode 100644
index 0000000..1ed98f5
--- /dev/null
+++ b/MakeMyTrip/largest_num_in_k_swaps.java
@@ -0,0 +1,68 @@
+class GFG
+ {
+ public static char[] maxNum;
+ public static void main (String[] args) throws NumberFormatException
+ {
+ //code
+ Scanner sc = new Scanner(System.in);
+ int test = sc.nextInt();
+ while(test-- >0){
+ int k = sc.nextInt();
+ sc.nextLine();
+ String teststr = sc.nextLine();
+
+ char[] str = teststr.toCharArray();
+ maxNum = teststr.toCharArray();
+ maxNumber(k,str);
+ for(int i=0; i ch2[i])
+ return true;
+ else if(ch1[i] < ch2[i])
+ return false;
+ }
+ return false;
+ }
+
+}
\ No newline at end of file
diff --git a/MakeMyTrip/make_distinct_digit_Array.java b/MakeMyTrip/make_distinct_digit_Array.java
new file mode 100644
index 0000000..ff91f93
--- /dev/null
+++ b/MakeMyTrip/make_distinct_digit_Array.java
@@ -0,0 +1,30 @@
+/*package whatever //do not write package name here */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class GFG {
+ public static void main (String[] args) {
+ //code
+ Scanner sc = new Scanner(System.in);
+ int t = sc.nextInt();
+ while(t-->0){
+ int n = sc.nextInt();
+ int[] arr = new int[n];
+ for(int i=0;i s = new ArrayList(n);
+ for (int i=0;i res =g.findMatchedWords(s, tt);
+ Collections.sort(res);
+ for (int i = 0;i < res.size();i++)
+ System.out.print(res.get(i)+" ");
+ System.out.println();
+
+ }
+ }
+}// } Driver Code Ends
+
+
+/*Complete the provided function*/
+
+class GfG
+{
+/* The function returns an array of strings
+present in the dictionary which matches
+the string pattern.
+You are required to complete this method */
+public static ArrayList findMatchedWords(ArrayList dict, String pt)
+ {
+ //add code here.
+ ArrayList ans = new ArrayList<>();
+ for(String word : dict){
+ HashMap map = new HashMap<>();
+ if(word.length()!=pt.length()) continue;
+ boolean flag = true;
+ for(int i=0;i 0)
+ {
+ int N = sc.nextInt();
+ int a[] = new int[N];
+ for (int i = 0; i < N; i++)
+ a[i] = sc.nextInt();
+
+
+ GfG g = new GfG();
+ int n = g.maxLen(a, a.length);
+
+ System.out.println(n);
+
+ T--;
+ }
+ }
+}
+// } Driver Code Ends
+
+
+class GfG {
+
+ // arr[] : the input array containing 0s and 1s
+ // N : size of the input array
+
+ // return the maximum length of the subarray
+ // with equal 0s and 1s
+ int maxLen(int[] arr, int N)
+ {
+ // Your code here
+ int []arr1 = new int[N];
+ arr1[0] = arr[0] == 0 ? -1 : 1;
+ for ( int i = 1 ; i < N; i++){
+ arr1[i] = arr1[i-1]+(arr[i] == 0 ? -1 : 1);
+ }
+ int maxLength = 0;
+ HashMap map = new HashMap<>();
+ int i = 0;
+ for ( int s : arr1){
+ if ( s == 0 ){
+ maxLength = Math.max(maxLength,i+1);
+ }
+ if(map.containsKey(s)){
+ maxLength = Math.max(maxLength,i-map.get(s));
+ }
+ else
+ map.put(s,i);
+ i++;
+ }
+ return maxLength;
+ }
+}
diff --git a/MakeMyTrip/max_subarray_with_0_sum.java b/MakeMyTrip/max_subarray_with_0_sum.java
new file mode 100644
index 0000000..b3e9e53
--- /dev/null
+++ b/MakeMyTrip/max_subarray_with_0_sum.java
@@ -0,0 +1,51 @@
+// { Driver Code Starts
+import java.util.*;
+
+class MaxLenZeroSumSub
+{
+
+ // Returns length of the maximum length subarray with 0 sum
+
+ // Drive method
+ public static void main(String arg[])
+ {
+ Scanner sc = new Scanner(System.in);
+ int T = sc.nextInt();
+ while (T > 0)
+ {
+ int n = sc.nextInt();
+ int arr[] = new int[n];
+ for (int i = 0; i < n; i++)
+ arr[i] = sc.nextInt();
+
+ GfG g = new GfG();
+ System.out.println(g.maxLen(arr, n));
+ T--;
+ }
+ }
+}// } Driver Code Ends
+
+
+
+
+class GfG
+{
+ int maxLen(int arr[], int n)
+ {
+ // Your code here
+ int[] a2 = new int[n];
+ a2[0] = arr[0];
+ for(int i=1;i map = new HashMap<>();
+ int maxLen = 0;
+ for(int i=0;i0){
+ String num = sc.next();
+ long n = Long.parseLong(num);
+ StringBuilder sb = new StringBuilder();
+ sb.append(num);
+ String rnum = sb.reverse().toString();
+ long r = Long.parseLong(rnum);
+ System.out.println(power(n,r,mod));
+ }
+ }
+ public static long power(long n , long r , int b){
+
+ if(r==0){
+ return 1 ;
+ }
+
+ long ans = power(n,r/2,b) ;
+ if (r%2 == 0)
+ return ((ans%b)*(ans%b))%b;
+ else
+ return (n*((ans*ans)%b))%b;
+ }
+
+}
\ No newline at end of file
diff --git a/MakeMyTrip/reverse_ll.java b/MakeMyTrip/reverse_ll.java
new file mode 100644
index 0000000..3305d7b
--- /dev/null
+++ b/MakeMyTrip/reverse_ll.java
@@ -0,0 +1,84 @@
+// { Driver Code Starts
+import java.util.*;
+import java.io.*;
+
+class Node{
+ int data;
+ Node next;
+
+ Node(int x){
+ data = x;
+ next = null;
+ }
+
+}
+class GFG{
+ static void printList(Node node)
+ {
+ while (node != null)
+ {
+ System.out.print(node.data + " ");
+ node = node.next;
+ }
+ System.out.println();
+ }
+ public static void main(String args[]) throws IOException {
+
+ Scanner sc = new Scanner(System.in);
+ int t = sc.nextInt();
+
+ while(t > 0){
+
+ int n = sc.nextInt();
+
+ Node head = new Node(sc.nextInt());
+ Node tail = head;
+
+ for(int i=0; i 0) {
+ String s = sc.next();
+ Solution obj = new Solution();
+ System.out.println(obj.reverseWords(s));
+ t--;
+ }
+ }
+}
+// } Driver Code Ends
+
+
+
+class Solution {
+ String reverseWords(String s) {
+ // code here
+ String[] ar = s.split("\\.");
+ StringBuilder sb = new StringBuilder();
+ for(int i=ar.length-1;i>=0;i--){
+ sb.append(ar[i]);
+ if(i!=0) sb.append(".");
+ }
+ return sb.toString();
+ }
+}
\ No newline at end of file
diff --git a/MakeMyTrip/rotten_oranges.java b/MakeMyTrip/rotten_oranges.java
new file mode 100644
index 0000000..1ebeae0
--- /dev/null
+++ b/MakeMyTrip/rotten_oranges.java
@@ -0,0 +1,76 @@
+/*package whatever //do not write package name here */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class GFG {
+ static class Pair{
+ int x;
+ int y;
+ Pair(int a,int b){
+ this.x = a;
+ this.y = b;
+ }
+ }
+ public static void main (String[] args) {
+ //code
+ Scanner sc = new Scanner(System.in);
+ int t = sc.nextInt();
+ while(t-->0){
+ int r = sc.nextInt();
+ int c = sc.nextInt();
+ int[][] mat = new int[r][c];
+ int count =0;
+ Queue q = new LinkedList<>();
+ for(int i=0;i0){
+ Pair p = q.remove();
+ int x = p.x;
+ int y = p.y;
+ //up
+ if(y-1>=0 && mat[x][y-1]==1){
+ //rot it
+ mat[x][y-1] = 2;
+ q.add(new Pair(x,y-1));
+ }
+ //down
+ if(y+1=0 && mat[x-1][y]==1){
+ //rot it
+ mat[x-1][y] = 2;
+ q.add(new Pair(x-1,y));
+ }
+ //right
+ if(x+1
+using namespace std;
+#define ll long long
+
+int doit(int n , int m , int k , vector &a,vector&b){
+
+ set s;
+ for(auto i:b) s.insert(i);
+ map dp;
+ int i = 0 ;
+ int j = 0;
+ int c = 0 ;
+ int l = -1, r = n;
+ while(jk){
+ dp[a[i]]--;
+ if(s.count(a[i]) && !dp[a[i]]) c--;
+ i++;
+ }
+ while(c==k){
+ dp[a[i]]--;
+ if(!s.count(a[i]) || dp[a[i]]){
+ i++;
+ }
+ else{
+ if(r-l > j-i){
+ l = i;
+ r = j;
+ }
+ c--;
+ i++;
+ }
+ }
+ j++;
+ }
+ if(l==-1) return -1;
+ return r-l+1;
+}
+
+int main(){
+ int n,m,k;
+ cin >> n >> m >>k;
+ vector a(n),b(m);
+ for(auto &i:a) cin >> i;
+ for(auto &i:b) cin >> i;
+ cout << doit(n,m,k,a,b);
+ return 0;
+}
\ No newline at end of file
diff --git a/MakeMyTrip/smallest_window_in_a_string.java b/MakeMyTrip/smallest_window_in_a_string.java
new file mode 100644
index 0000000..76949df
--- /dev/null
+++ b/MakeMyTrip/smallest_window_in_a_string.java
@@ -0,0 +1,58 @@
+// { Driver Code Starts
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class GFG {
+ public static void main (String[] args) {
+ Scanner scan = new Scanner(System.in);
+ int test = scan.nextInt();
+
+ while(test > 0){
+ String s = scan.next();
+ String t = scan.next();
+
+ System.out.println(new solve().smallestWindow(s, t));
+ test--;
+ }
+ }
+}// } Driver Code Ends
+
+
+class solve
+{
+ // return the smallest window in S with all the characters of P
+ // if no such window exists, return "-1"
+ public static String smallestWindow(String S, String P){
+ // Your code here
+ int l1 = S.length();
+ int l2 = P.length();
+ int[] hash_s = new int[256];
+ int[] hash_p = new int[256];
+ for(int i=0;ihash_p[S.charAt(st)] || hash_p[S.charAt(st)]==0){
+ if(hash_s[S.charAt(st)]>hash_p[S.charAt(st)]) hash_s[S.charAt(st)]--;
+ st++;
+ }
+ int win = j-st+1;
+ if(win 0)
+ {
+ int grid[][] = new int[9][9];
+ for(int i = 0; i < 9; i++)
+ {
+ for(int j = 0; j < 9; j++)
+ grid[i][j] = sc.nextInt();
+ }
+
+ if(new Sudoku().SolveSudoku(grid) == true)
+ new Sudoku().printGrid(grid);
+ else
+ System.out.print("NO solution exists");
+ System.out.println();
+
+ }
+ }
+}
+
+
+
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+class Sudoku
+{
+ static boolean SolveSudoku(int board[][])
+ {
+ // add your code here
+ int row = -1;
+ int col = -1;
+ boolean isEmpty = true;
+ for (int i = 0; i < 9; i++)
+ {
+ for (int j = 0; j < 9; j++)
+ {
+ if (board[i][j] == 0)
+ {
+ row = i;
+ col = j;
+
+ // we still have some remaining
+ // missing values in Sudoku
+ isEmpty = false;
+ break;
+ }
+ }
+ if (!isEmpty)
+ {
+ break;
+ }
+ }
+
+ // no empty space left
+ if (isEmpty)
+ {
+ return true;
+ }
+
+ // else for each-row backtrack
+ for (int num = 1; num <= 9; num++)
+ {
+ if (isSafe(board, row, col, num))
+ {
+ board[row][col] = num;
+ if (SolveSudoku(board))
+ {
+ // print(board, n);
+ return true;
+ }
+ else
+ {
+ board[row][col] = 0; // replace it
+ }
+ }
+ }
+ return false;
+ }
+ public static boolean isSafe(int[][] board,int row,int col,int num)
+ {
+ for (int d = 0; d < board.length; d++)
+ {
+ // if the number we are trying to
+ // place is already present in
+ // that row, return false;
+ if (board[row][d] == num)
+ {
+ return false;
+ }
+ }
+
+ // column has the unique numbers (column-clash)
+ for (int r = 0; r < board.length; r++)
+ {
+ // if the number we are trying to
+ // place is already present in
+ // that column, return false;
+
+ if (board[r][col] == num)
+ {
+ return false;
+ }
+ }
+
+ // corresponding square has
+ // unique number (box-clash)
+ int sqrt = (int) Math.sqrt(board.length);
+ int boxRowStart = row - row % sqrt;
+ int boxColStart = col - col % sqrt;
+
+ for (int r = boxRowStart;
+ r < boxRowStart + sqrt; r++)
+ {
+ for (int d = boxColStart;
+ d < boxColStart + sqrt; d++)
+ {
+ if (board[r][d] == num)
+ {
+ return false;
+ }
+ }
+ }
+
+ // if there is no clash, it's safe
+ return true;
+}
+ static void printGrid (int grid[][])
+ {
+ // add your code here
+ for(int i=0;i 0){
+ int n = sc.nextInt();
+ int array[] = new int [n];
+ for(int i=0; i0){
+ int n = Integer.parseInt(br.readLine().trim());
+ int arr[] = new int[n];
+ String inputLine[] = br.readLine().trim().split(" ");
+ for(int i=0; i0){
+ int n=sc.nextInt();
+ Stack s=new Stack<>();
+ GfG g=new GfG();
+ while(!g.isFull(s,n)){
+ g.push(sc.nextInt(),s);
+ }
+ System.out.println(g.min(s));
+ }
+ }
+}// } Driver Code Ends
+
+/*Complete the function(s) below*/
+class GfG{
+ public int minVal = Integer.MAX_VALUE;
+ public void push(int a,Stack s)
+ {
+ //add code here.
+ minVal = Math.min(minVal,a);
+ s.push(a);
+ }
+ public int pop(Stack s)
+ {
+ //add code here.
+ int top = s.pop();
+ if(top==minVal){
+ Stack s2 = new Stack<>();
+ minVal = Integer.MAX_VALUE;
+ while(!s.isEmpty()){
+ int c = s.pop();
+ minVal = Math.min(minVal,c);
+ s2.push(c);
+ }
+ while(!s2.isEmpty()) s.push(s2.pop());
+ }
+ return top;
+ }
+ public int min(Stack s)
+ {
+ //add code here.
+ return minVal;
+ }
+ public boolean isFull(Stacks, int n)
+ {
+ //add code here.
+ return s.size()==n;
+ }
+ public boolean isEmpty(Stacks)
+ {
+ //add code here.
+ return s.isEmpty();
+ }
+}
\ No newline at end of file
diff --git a/MakeMyTrip/stock-buy-sell.java b/MakeMyTrip/stock-buy-sell.java
new file mode 100644
index 0000000..9292ade
--- /dev/null
+++ b/MakeMyTrip/stock-buy-sell.java
@@ -0,0 +1,56 @@
+// { Driver Code Starts
+// Initial Template for Java
+
+import java.io.*;
+import java.util.*;
+
+class GFG {
+ public static void main(String[] args) throws IOException {
+ BufferedReader br =
+ new BufferedReader(new InputStreamReader(System.in));
+
+ int tc = Integer.parseInt(br.readLine().trim());
+
+ while (tc-- > 0) {
+ int n = Integer.parseInt(br.readLine().trim());
+ int[] price = new int[n];
+ String[] str = br.readLine().trim().split(" ");
+ for (int i = 0; i < n; i++) {
+ price[i] = Integer.parseInt(str[i]);
+ }
+ Solution sln = new Solution();
+ sln.stockBuySell(price, n);
+ }
+ }
+}// } Driver Code Ends
+
+
+// User function Template for Java
+
+class Solution {
+ public void stockBuySell(int[] price, int n) {
+ // code here
+ int i=0;
+ int profit=0;
+ while(i=price[bottom+1]){
+ bottom++;
+ }
+ int top=bottom;
+ while(top+1 x)
+ {
+ count++;
+ t = t - (x - y);
+ }
+ count++;
+ }
+ }
+
+ System.out.println(count);
+ }
+
+ }
+
+}
\ No newline at end of file
diff --git a/MakeMyTrip/transpose_matrix.java b/MakeMyTrip/transpose_matrix.java
new file mode 100644
index 0000000..31df99d
--- /dev/null
+++ b/MakeMyTrip/transpose_matrix.java
@@ -0,0 +1,40 @@
+/*package whatever //do not write package name here */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class GFG {
+ public static void main (String[] args) {
+ //code
+ Scanner sc = new Scanner(System.in);
+ int t = sc.nextInt();
+ while(t-->0){
+ int n = sc.nextInt();
+ int[][] mat = new int[n][n];
+ for(int i=0;i0){
+ int m = sc.nextInt();
+ int n = sc.nextInt();
+ int d = sc.nextInt();
+ int ans = getOpns(m,n,d);
+
+ System.out.println(ans);
+ }
+ }
+ public static int getOpns(int m,int n,int d){
+ if(d==0) return 0;
+ if(d>Math.max(m,n)) return -1;
+ if((d % gcd(m,n))!=0) return -1;
+ return Math.min(getMoves(m,n,d),getMoves(n,m,d));
+ }
+ public static int gcd(int a,int b){
+ if(a==0) return b;
+ return gcd(b%a,a);
+ }
+ public static int getMoves(int fromTot,int toTot,int d){
+ int from = fromTot;
+ int to = 0;
+ int moves = 1;
+ while(from!=d && to!=d){
+ int waterThatCanBePoured = Math.min(from,toTot-to);
+ from -= waterThatCanBePoured;
+ to += waterThatCanBePoured;
+ moves++;
+ if(from==d || to==d) break;
+ if(from==0){
+ moves++;
+ from = fromTot;
+ }
+ if(to==toTot){
+ moves++;
+ to = 0;
+ }
+ }
+ return moves;
+ }
+}
\ No newline at end of file
diff --git a/MakeMyTrip/wordboggle.java b/MakeMyTrip/wordboggle.java
new file mode 100644
index 0000000..8bdc01d
--- /dev/null
+++ b/MakeMyTrip/wordboggle.java
@@ -0,0 +1,109 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+import java.io.*;
+import java.util.*;
+
+class GFG
+{
+ public static void main(String args[])
+ {
+ Scanner sc = new Scanner(System.in);
+ int t = sc.nextInt();
+ while(t>0)
+ {
+ int x = sc.nextInt();
+ String[] dictionary = new String[x];
+ for(int i=0;i ans = new ArrayList<>();
+ HashMap> map = new HashMap<>();
+ for(int i=0;i indexes = map.getOrDefault(c,new ArrayList());
+ indexes.add(i);
+ map.put(c,indexes);
+ }
+ for(int i=0;i indexes = map.getOrDefault(c,new ArrayList());
+ for(int k:indexes){
+ if(!ans.contains(k)&&canBe(b,i,j,dict[k],0)){
+ ans.add(k);
+ }
+ }
+ }
+ }
+ String[] aa = new String[ans.size()];
+ int l=0;
+ for(int i:ans){
+ aa[l++] = dict[i];
+ }
+ return aa;
+ }
+ public static boolean canBe(char[][] b,int i,int j,String st,int k){
+ if(k==st.length()) return true;
+ if(i<0 || j<0 || i>=b.length || j>=b[0].length) return false;
+
+ if(b[i][j]!=st.charAt(k)){
+ return false;
+ }
+ char t = b[i][j];
+ b[i][j] = '#';
+ k++;
+ boolean res = canBe(b,i+1,j,st,k) ||
+ canBe(b,i+1,j+1,st,k) ||
+ canBe(b,i+1,j-1,st,k) ||
+ canBe(b,i,j+1,st,k) ||
+ canBe(b,i,j-1,st,k) ||
+ canBe(b,i-1,j-1,st,k) ||
+ canBe(b,i-1,j,st,k) ||
+ canBe(b,i-1,j+1,st,k);
+ b[i][j] = t;
+ return res;
+ }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 8c9105e..1976126 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,34 @@
-# Competitive-Programming
+Competitive Programming
+=========================
+
+Topics Covered :
+-------------------
+ - Arrays & Strings
+ - Bitwise Algorithms
+ - Dynamic Programming
+ - Greedy Algorithms
+ - HashMap & Heaps
+ - LinkedList
+ - Stack & Queues
+ - Trees
+
+Installation
+---------------
+Clone the GitHub Repository.
+
+```
+$ git clone https://github.com/singhaniatanay/Competitive-Programming
+```
+
+Contributing
+------------
+
+Please refer to each project's style for submitting better solutions and additions. In general, we follow the "fork-and-pull" Git workflow.
+
+ 1. **Fork** the repo on GitHub
+ 2. **Clone** the project to your own machine
+ 3. **Commit** changes to your own branch
+ 4. **Push** your work back up to your fork
+ 5. Submit a **Pull request** so that I can review your changes
+
+NOTE: Be sure to merge the latest from "upstream" before making a pull request!
diff --git a/Trees/D28_K_far.java b/Trees/D28_K_far.java
new file mode 100644
index 0000000..b097e3c
--- /dev/null
+++ b/Trees/D28_K_far.java
@@ -0,0 +1,50 @@
+public class D28_K_far {
+ private static class Node{
+ int data;
+ Node left;
+ Node right;
+
+ Node(int data,Node left,Node right){
+ this.data = data;
+ this.left= left;
+ this.right = right;
+ }
+
+ }
+ public static int dist=0;
+ public static void kdown(Node n,int k,Node blocker){
+ if(n==null||n==blocker||k<0){
+ return;
+ }else if(k==0){
+ System.out.println(n.data);
+ return;
+ }
+ kdown(n.left,k-1,blocker);
+ kdown(n.right,k-1,blocker);
+ }
+ public static boolean kfar(Node node,int d,int k){
+ if(node==null)
+ return false;
+ else if(node.data==d){
+ kdown(node,k,null);
+ dist++;
+ return true;
+ }
+ else if(kfar(node.left,d,k)) {
+ kdown(node, k - dist, node.left);
+ dist++;
+ return true;
+
+ }
+ else if(kfar(node.right,d,k)) {
+ kdown(node, k - dist, node.left);
+ dist++;
+ return true;
+ }
+ return false;
+ }
+ public static void main(String[] args) {
+ //todo main function from pep portal
+
+ }
+}
diff --git a/Trees/D28_Longest_Increasing_Path.java b/Trees/D28_Longest_Increasing_Path.java
new file mode 100644
index 0000000..5ed8808
--- /dev/null
+++ b/Trees/D28_Longest_Increasing_Path.java
@@ -0,0 +1,44 @@
+import java.util.ArrayList;
+
+public class D28_Longest_Increasing_Path {
+ private static class Node{
+ int data;
+ Node left;
+ Node right;
+
+ Node(int data, Node left, Node right){
+ this.data = data;
+ this.left= left;
+ this.right = right;
+ }
+
+ }
+ static ArrayList psf = new ArrayList<>();
+ static ArrayList best= new ArrayList<>();
+ static void longestIncreasingPath(Node node){
+ if(psf.size()>best.size()){
+ best = new ArrayList<>(psf);
+
+ }
+ if(node==null)
+ return;
+
+ if(psf.size()==0 || node.data>psf.get(psf.size()-1)){
+ psf.add(node.data);
+ longestIncreasingPath(node.left);
+ longestIncreasingPath(node.right);
+ psf.remove(psf.size()-1);
+ }else{
+ ArrayList temp = psf;
+ psf = new ArrayList<>();
+ psf.add(node.data);
+ longestIncreasingPath(node.left);
+ longestIncreasingPath(node.right);
+ psf = temp;
+ }
+ }
+ public static void main(String[] args) {
+ //todo main from portal
+ }
+
+}
diff --git a/Trees/D29_Binary_Tree_Paths.java b/Trees/D29_Binary_Tree_Paths.java
new file mode 100644
index 0000000..1864b25
--- /dev/null
+++ b/Trees/D29_Binary_Tree_Paths.java
@@ -0,0 +1,115 @@
+import java.util.*;
+
+public class D29_Binary_Tree_Paths {
+
+ // TreeNode class for a node of a Binary Search Tree
+ public static class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+
+ TreeNode(int x) {
+ val = x;
+ }
+ }
+
+ // This is a functional problem. You have to complete this function.
+ // It takes as input the root node of a binary tree. It should return
+ // an arraylist containing all root-to-leaf paths in any order.
+ public static ArrayList binaryTreePaths(TreeNode root) {
+ // write your code here.
+ getBtPaths(root,"");
+ return btPaths;
+
+ }
+ public static ArrayList btPaths = new ArrayList<>();
+ public static void getBtPaths(TreeNode root,String pathSoFar){
+ if(root==null)
+ return;
+
+ if(root.left==null && root.right==null){
+ //leaf
+ pathSoFar+= root.val;
+ btPaths.add(pathSoFar);
+ return;
+ }
+ pathSoFar+= root.val+"->";
+ getBtPaths(root.left,pathSoFar);
+ getBtPaths(root.right,pathSoFar);
+
+ }
+
+
+
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+ String input = sc.nextLine().trim();
+
+ Integer[] treeArr = inputSplitSpace(input);
+ TreeNode root = createTree(treeArr);
+
+ ArrayList result = binaryTreePaths(root);
+ Collections.sort(result);
+ for(String s: result){
+ System.out.println(s);
+ }
+
+ }
+
+ // utility function to display a binary tree.
+ public static void display(TreeNode node) {
+ if (node == null) {
+ return;
+ }
+
+ String str = "";
+
+ str += node.left == null ? "." : node.left.val;
+ str += " <= " + node.val + " => ";
+ str += node.right == null ? "." : node.right.val;
+
+ System.out.println(str);
+
+ display(node.left);
+ display(node.right);
+ }
+
+ // utility function, don't change its code
+ public static Integer[] inputSplitSpace(String str) {
+ String[] sArr = str.split(" ");
+ Integer[] arr = new Integer[sArr.length];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = sArr[i].equals("null") ? null : Integer.parseInt(sArr[i]);
+ }
+ return arr;
+ }
+
+ // utility function to create a tree, don't change its code.
+ public static TreeNode createTree(Integer[] arr) {
+ ArrayDeque que = new ArrayDeque<>();
+ TreeNode root = new TreeNode(arr[0]);
+ que.addLast(root);
+ int i = 1;
+ while (!que.isEmpty() && i < arr.length) {
+ TreeNode nn = que.removeFirst();
+
+ if (i < arr.length && arr[i] != null) {
+ TreeNode n = new TreeNode(arr[i]);
+ nn.left = n;
+ que.addLast(n);
+ }
+ i++;
+
+ if (i < arr.length && arr[i] != null) {
+ TreeNode n = new TreeNode(arr[i]);
+ nn.right = n;
+ que.addLast(n);
+ }
+ i++;
+ }
+
+ return root;
+ }
+
+
+}
\ No newline at end of file
diff --git a/Trees/D29_Lvl_Order_Bottom_UP.java b/Trees/D29_Lvl_Order_Bottom_UP.java
new file mode 100644
index 0000000..0d6d4a3
--- /dev/null
+++ b/Trees/D29_Lvl_Order_Bottom_UP.java
@@ -0,0 +1,118 @@
+import java.lang.reflect.Array;
+import java.util.*;
+
+public class D29_Lvl_Order_Bottom_UP {
+
+ // TreeNode class for a node of a Binary Search Tree
+ public static class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+
+ TreeNode(int x) {
+ val = x;
+ }
+ }
+
+ // This is a functional problem. You have to complete this function.
+ // It takes as input the root of the given tree. It should return the
+ // bottom-up level order traversal as an arraylist of arraylist.
+ public static ArrayList> createTreeBottom(TreeNode root) {
+ // write your code here.
+ Queue q = new LinkedList<>();
+ Stack> ans = new Stack<>();
+ ArrayList currList = new ArrayList<>();
+ q.add(root);
+ q.add(null);
+ while (!q.isEmpty()){
+ TreeNode curr = q.remove();
+ if(curr==null){
+ ans.push(currList);
+ currList = new ArrayList<>();
+ if(q.size()>0){
+ q.add(null);
+ }
+ continue;
+ }
+ currList.add(curr.val);
+ if(curr.left!=null)
+ q.add(curr.left);
+ if(curr.right!=null)
+ q.add(curr.right);
+ }
+
+ ArrayList> returnVal = new ArrayList<>();
+ while (!ans.isEmpty()){
+ ArrayList i = ans.pop();
+ returnVal.add(i);
+ }
+ return returnVal;
+
+ }
+
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+
+ // length of array representing the tree
+ int len = sc.nextInt();
+
+ int[] arr = new int[len];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = sc.nextInt();
+ }
+ TreeNode root = createTree(arr);
+
+ ArrayList> res = createTreeBottom(root);
+
+ for(ArrayList list: res) {
+ for(Integer i: list){
+ System.out.print(i + " ");
+ }
+ System.out.println();
+ }
+
+ }
+
+ // utility function to display a binary tree
+ public static void display(TreeNode node) {
+ if (node == null) {
+ return;
+ }
+
+ String str = "";
+
+ str += node.left == null ? "." : node.left.val;
+ str += " <= " + node.val + " => ";
+ str += node.right == null ? "." : node.right.val;
+
+ System.out.println(str);
+
+ display(node.left);
+ display(node.right);
+ }
+
+ // creation of tree from array by level order, -1 says there is no node
+ public static TreeNode createTree(int[] arr) {
+
+ TreeNode[] nodes = new TreeNode[arr.length];
+ for (int i = 0; i < nodes.length; i++) {
+ if (arr[i] != -1) {
+ nodes[i] = new TreeNode(arr[i]);
+
+ if (i > 0) {
+ int pi = (i - 1) / 2;
+
+ if (i == 2 * pi + 1) {
+ nodes[pi].left = nodes[i];
+ } else {
+ nodes[pi].right = nodes[i];
+ }
+ }
+ }
+ }
+
+ TreeNode root = nodes[0];
+ return root;
+ }
+
+}
\ No newline at end of file
diff --git a/Trees/D29_Lvl_Order_Traversal.java b/Trees/D29_Lvl_Order_Traversal.java
new file mode 100644
index 0000000..c7dce33
--- /dev/null
+++ b/Trees/D29_Lvl_Order_Traversal.java
@@ -0,0 +1,111 @@
+import java.util.*;
+
+public class D29_Lvl_Order_Traversal {
+
+ // TreeNode class for a node of a Binary Search Tree
+ public static class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+
+ TreeNode(int x) {
+ val = x;
+ }
+ }
+
+ // This is a functional problem. You have to complete this function.
+ // It takes as input the root of the given tree. It should return the
+ // level order traversal as an arraylist of arraylist.
+ public static ArrayList> levelOrderTraversal(TreeNode node) {
+ // write your code here.
+ Queue q = new LinkedList<>();
+ ArrayList> ans = new ArrayList<>();
+ ArrayList currList = new ArrayList<>();
+ q.add(node);
+ q.add(null);
+ while (!q.isEmpty()){
+ TreeNode curr = q.remove();
+ if(curr==null){
+ ans.add(currList);
+ currList = new ArrayList<>();
+ if(q.size()>0){
+ q.add(null);
+ }
+ continue;
+ }
+ currList.add(curr.val);
+ if(curr.left!=null)
+ q.add(curr.left);
+ if(curr.right!=null)
+ q.add(curr.right);
+ }
+ return ans;
+
+ }
+
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+
+ // length of array representing the tree
+ int len = sc.nextInt();
+
+ int[] arr = new int[len];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = sc.nextInt();
+ }
+ TreeNode root = levelOrder(arr);
+
+ ArrayList> res = levelOrderTraversal(root);
+
+ for(ArrayList list: res) {
+ for(Integer i: list){
+ System.out.print(i + " ");
+ }
+ System.out.println();
+ }
+
+ }
+
+ // utility function to display a binary tree
+ public static void display(TreeNode node) {
+ if (node == null) {
+ return;
+ }
+
+ String str = "";
+
+ str += node.left == null ? "." : node.left.val;
+ str += " <= " + node.val + " => ";
+ str += node.right == null ? "." : node.right.val;
+
+ System.out.println(str);
+
+ display(node.left);
+ display(node.right);
+ }
+
+ // creation of tree from array by level order, -1 says there is no node
+ public static TreeNode levelOrder(int[] arr) {
+
+ TreeNode[] nodes = new TreeNode[arr.length];
+ for (int i = 0; i < nodes.length; i++) {
+ if (arr[i] != -1) {
+ nodes[i] = new TreeNode(arr[i]);
+
+ if (i > 0) {
+ int pi = (i - 1) / 2;
+
+ if (i == 2 * pi + 1) {
+ nodes[pi].left = nodes[i];
+ } else {
+ nodes[pi].right = nodes[i];
+ }
+ }
+ }
+ }
+
+ TreeNode root = nodes[0];
+ return root;
+ }
+
+}
\ No newline at end of file
diff --git a/Trees/D30_MORRIS.java b/Trees/D30_MORRIS.java
new file mode 100644
index 0000000..6aedf4d
--- /dev/null
+++ b/Trees/D30_MORRIS.java
@@ -0,0 +1,91 @@
+import java.util.ArrayDeque;
+
+public class D30_MORRIS {
+ public static class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+
+ TreeNode(int x) {
+ val = x;
+ }
+ }
+ public static void display(TreeNode node) {
+ if (node == null) {
+ return;
+ }
+
+ String str = "";
+
+ str += node.left == null ? "." : node.left.val;
+ str += " <= " + node.val + " => ";
+ str += node.right == null ? "." : node.right.val;
+
+ System.out.println(str);
+
+ display(node.left);
+ display(node.right);
+ }
+ public static Integer[] inputSplitSpace(String str) {
+ String[] sArr = str.split(" ");
+ Integer[] arr = new Integer[sArr.length];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = sArr[i].equals("null") ? null : Integer.parseInt(sArr[i]);
+ }
+ return arr;
+ }
+ public static TreeNode createTree(Integer[] arr) {
+ ArrayDeque que = new ArrayDeque<>();
+ TreeNode root = new TreeNode(arr[0]);
+ que.addLast(root);
+ int i = 1;
+ while (!que.isEmpty() && i < arr.length) {
+ TreeNode nn = que.removeFirst();
+
+ if (i < arr.length && arr[i] != null) {
+ TreeNode n = new TreeNode(arr[i]);
+ nn.left = n;
+ que.addLast(n);
+ }
+ i++;
+
+ if (i < arr.length && arr[i] != null) {
+ TreeNode n = new TreeNode(arr[i]);
+ nn.right = n;
+ que.addLast(n);
+ }
+ i++;
+ }
+
+ return root;
+ }
+
+ public static void morris(TreeNode node){
+ while(node!=null){
+ if(node.left==null){
+ System.out.println(node.val);
+ node = node.right;
+ }else{
+ TreeNode LftKaRightMost = lkaRM(node);
+ if(LftKaRightMost.right==null){
+ LftKaRightMost.right = node;
+ node = node.left;
+ }
+ else if(LftKaRightMost.right==node){
+ LftKaRightMost.right=null;
+ System.out.println(node.val);
+ node = node.right;
+ }
+ }
+ }
+ }
+
+ private static TreeNode lkaRM(TreeNode node) {
+ TreeNode lkarm = node.left;
+ while (lkarm.right!=null && lkarm.right!=node){
+ lkarm = lkarm.right;
+ }
+ return lkarm;
+ }
+
+}
diff --git a/Trees/D30_PreOrder_to_Inorder.java b/Trees/D30_PreOrder_to_Inorder.java
new file mode 100644
index 0000000..da42290
--- /dev/null
+++ b/Trees/D30_PreOrder_to_Inorder.java
@@ -0,0 +1,82 @@
+import java.util.ArrayDeque;
+
+public class D30_PreOrder_to_Inorder {
+ public static class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+
+ TreeNode(int x) {
+ val = x;
+ }
+ }
+ public static void display(TreeNode node) {
+ if (node == null) {
+ return;
+ }
+
+ String str = "";
+
+ str += node.left == null ? "." : node.left.val;
+ str += " <= " + node.val + " => ";
+ str += node.right == null ? "." : node.right.val;
+
+ System.out.println(str);
+
+ display(node.left);
+ display(node.right);
+ }
+ public static Integer[] inputSplitSpace(String str) {
+ String[] sArr = str.split(" ");
+ Integer[] arr = new Integer[sArr.length];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = sArr[i].equals("null") ? null : Integer.parseInt(sArr[i]);
+ }
+ return arr;
+ }
+ public static TreeNode createTree(Integer[] arr) {
+ ArrayDeque que = new ArrayDeque<>();
+ TreeNode root = new TreeNode(arr[0]);
+ que.addLast(root);
+ int i = 1;
+ while (!que.isEmpty() && i < arr.length) {
+ TreeNode nn = que.removeFirst();
+
+ if (i < arr.length && arr[i] != null) {
+ TreeNode n = new TreeNode(arr[i]);
+ nn.left = n;
+ que.addLast(n);
+ }
+ i++;
+
+ if (i < arr.length && arr[i] != null) {
+ TreeNode n = new TreeNode(arr[i]);
+ nn.right = n;
+ que.addLast(n);
+ }
+ i++;
+ }
+
+ return root;
+ }
+ public static TreeNode construct(char[] pre,int psi,int pei,
+ char[] in, int isi,int iei){
+
+ if(isi>iei || psi>pei){
+ return null;
+ }
+ int index = -1;
+ for(int i=isi;i<=iei;i++){
+ if(in[i]==pre[psi]){
+ index = i;
+ break;
+ }
+ }
+ int lhs = index-isi;
+ TreeNode node = new TreeNode(pre[psi]);
+ node.left = construct(pre,psi+1,psi+lhs,in,isi,index-1);
+ node.right= construct(pre,psi+lhs+1,pei,in,index+1,iei);
+
+ return node;
+ }
+}
diff --git a/Trees/D32_CountLeaves.java b/Trees/D32_CountLeaves.java
new file mode 100644
index 0000000..b68dcf9
--- /dev/null
+++ b/Trees/D32_CountLeaves.java
@@ -0,0 +1,25 @@
+class TNode
+{
+ int data;
+ TNode left, right;
+ TNode(int item)
+ {
+ data = item;
+ left = right = null;
+ }
+}
+class D32_CountLeaves
+{
+ int countLeaves(TNode node)
+ {
+ // Your code
+ if(node==null){
+ return 0;
+ }
+ if(node.left==null && node.right==null){
+ return 1;
+ }
+
+ return countLeaves(node.left)+countLeaves(node.right);
+ }
+}
diff --git a/Trees/D33_MirrorTree.java b/Trees/D33_MirrorTree.java
new file mode 100644
index 0000000..9fa5826
--- /dev/null
+++ b/Trees/D33_MirrorTree.java
@@ -0,0 +1,19 @@
+//Given a Binary Tree, convert it into its mirror.
+
+class D33_MirrorTree
+{
+ void mirror(TNode node)
+ {
+ // Your code here
+ if(node==null || (node.left==null&&node.right==null)){
+ return;
+ }
+ TNode temp = node.right;
+ node.right = node.left;
+ node.left = temp;
+
+ mirror(node.left);
+ mirror(node.right);
+
+ }
+}
\ No newline at end of file
diff --git a/Trees/IB_Iterative_PostOrder.java b/Trees/IB_Iterative_PostOrder.java
new file mode 100644
index 0000000..1f0ed50
--- /dev/null
+++ b/Trees/IB_Iterative_PostOrder.java
@@ -0,0 +1,70 @@
+import java.util.*;
+public class IB_Iterative_PostOrder {
+
+ static class node {
+ int data;
+ node left, right;
+
+ public node(int data)
+ {
+ this.data = data;
+ }
+ }
+
+ // Two stacks as used in explanation
+ static Stack s1, s2;
+
+ static void postOrderIterative(node root)
+ {
+ // Create two stacks
+ s1 = new Stack();
+ s2 = new Stack();
+
+ if (root == null)
+ return;
+
+ // push root to first stack
+ s1.push(root);
+
+ //PostOrder is LEFT->RIGHT->CURR
+ //For Stack reverse post order that is CURR->RIGHT->LEFT would be order of pushing into stack
+
+
+ // Run while first stack is not empty
+ while (!s1.isEmpty()) {
+ // Pop an item from s1 and push it to s2
+ node temp = (node)s1.pop();
+ s2.push(temp);
+ // Push left and right children of
+ // removed item to s1
+ if (temp.left != null)
+ s1.push(temp.left);
+ if (temp.right != null)
+ s1.push(temp.right);
+ }
+
+ // Print all elements of second stack
+ while (!s2.isEmpty()) {
+ node temp = s2.pop();
+ System.out.print(temp.data +" ");
+ }
+ }
+
+ public static void main(String[] args)
+ {
+// Let us construct the tree
+// shown in above figure
+
+ node root = null;
+ root = new node(1);
+ root.left = new node(2);
+ root.right = new node(3);
+ root.left.left = new node(4);
+ root.left.right = new node(5);
+ root.right.left = new node(6);
+ root.right.right = new node(7);
+
+ postOrderIterative(root);
+ }
+}
+
diff --git a/Trees/IB_Vertical_Order_Traversal.java b/Trees/IB_Vertical_Order_Traversal.java
new file mode 100644
index 0000000..cb8901d
--- /dev/null
+++ b/Trees/IB_Vertical_Order_Traversal.java
@@ -0,0 +1,60 @@
+import java.util.*;
+
+class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+ TreeNode(int x) { val = x;
+ left=null;
+ right=null;
+ }
+}
+class Helper{
+ TreeNode node;
+ int vlvl;
+ Helper(TreeNode node,int lvl){
+ this.vlvl = lvl;
+ this.node = node;
+ }
+}
+
+public class IB_Vertical_Order_Traversal {
+
+ public ArrayList> verticalOrderTraversal(TreeNode A) {
+ ArrayList> ans = new ArrayList<>();
+ HashMap> map = new HashMap<>();
+ Helper root = new Helper(A,0);
+ Queue q = new LinkedList<>();
+ q.add(root);
+ while (!q.isEmpty()){
+ Helper curr = q.remove();
+ if(map.containsKey(curr.vlvl)){
+ ArrayList currLL = map.get(curr.vlvl);
+ currLL.add(curr.node.val);
+ map.put(curr.vlvl,currLL);
+ }else{
+ ArrayList currLL = new ArrayList<>();
+ currLL.add(curr.node.val);
+ map.put(curr.vlvl,currLL);
+ }
+
+ if(curr.node.left!=null){
+ Helper left = new Helper(curr.node.left,curr.vlvl-1);
+ q.add(left);
+ }
+ if(curr.node.right!=null){
+ Helper right = new Helper(curr.node.right,curr.vlvl+1);
+ q.add(right);
+ }
+
+ }
+
+ Integer[] keys = map.keySet().toArray(new Integer[map.size()]);
+ Arrays.sort(keys);
+ for(int i:keys){
+ ans.add(map.get(i));
+ }
+ return ans;
+ }
+
+}
diff --git a/Trees/mirror_tree.java b/Trees/mirror_tree.java
new file mode 100644
index 0000000..9d4faea
--- /dev/null
+++ b/Trees/mirror_tree.java
@@ -0,0 +1,144 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+//Contributed by Sudarshan Sharma
+import java.util.LinkedList;
+import java.util.Queue;
+import java.io.*;
+import java.util.*;
+
+class Node{
+ int data;
+ Node left;
+ Node right;
+ Node(int data){
+ this.data = data;
+ left=null;
+ right=null;
+ }
+}
+
+
+class mirror_tree {
+
+ static Node buildTree(String str){
+
+ if(str.length()==0 || str.charAt(0)=='N'){
+ return null;
+ }
+
+ String ip[] = str.split(" ");
+ // Create the root of the tree
+ Node root = new Node(Integer.parseInt(ip[0]));
+ // Push the root to the queue
+
+ Queue queue = new LinkedList<>();
+
+ queue.add(root);
+ // Starting from the second element
+
+ int i = 1;
+ while(queue.size()>0 && i < ip.length) {
+
+ // Get and remove the front of the queue
+ Node currNode = queue.peek();
+ queue.remove();
+
+ // Get the current node's value from the string
+ String currVal = ip[i];
+
+ // If the left child is not null
+ if(!currVal.equals("N")) {
+
+ // Create the left child for the current node
+ currNode.left = new Node(Integer.parseInt(currVal));
+ // Push it to the queue
+ queue.add(currNode.left);
+ }
+
+ // For the right child
+ i++;
+ if(i >= ip.length)
+ break;
+
+ currVal = ip[i];
+
+ // If the right child is not null
+ if(!currVal.equals("N")) {
+
+ // Create the right child for the current node
+ currNode.right = new Node(Integer.parseInt(currVal));
+
+ // Push it to the queue
+ queue.add(currNode.right);
+ }
+ i++;
+ }
+
+ return root;
+ }
+ void inOrder(Node node) {
+ if (node == null) {
+ return;
+ }
+
+ inOrder(node.left);
+ System.out.print(node.data + " ");
+
+ inOrder(node.right);
+ }
+
+ public static void main (String[] args) throws IOException{
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+ int t=Integer.parseInt(br.readLine());
+
+ while(t-- > 0){
+ String s = br.readLine();
+ Node root = buildTree(s);
+ Tree obj = new Tree();
+ Tree g = new Tree();
+ g.mirror(root);
+ GfG mt = new GfG();
+ mt.inOrder(root);
+ System.out.println();
+
+ }
+ }
+}
+
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+
+//function Template for Java
+
+// FUNCTION CODE
+/* A Binary Tree node
+class Node
+{
+ int data;
+ Node left, right;
+ Node(int item)
+ {
+ data = item;
+ left = right = null;
+ }
+} */
+
+class Tree
+{
+ void mirror(Node node)
+ {
+ // Your code here
+ if(node==null) return;
+ mirror(node.left);
+ mirror(node.right);
+ Node temp = node.left;
+ node.left = node.right;
+ node.right = temp;
+
+ }
+}
\ No newline at end of file
diff --git a/out/production/Competitive Programming/D10_four_sum_v2.class b/out/production/Competitive Programming/D10_four_sum_v2.class
new file mode 100644
index 0000000..dd01c08
Binary files /dev/null and b/out/production/Competitive Programming/D10_four_sum_v2.class differ
diff --git a/out/production/Competitive Programming/D10_max_points_on_line$Point.class b/out/production/Competitive Programming/D10_max_points_on_line$Point.class
new file mode 100644
index 0000000..fbbaad6
Binary files /dev/null and b/out/production/Competitive Programming/D10_max_points_on_line$Point.class differ
diff --git a/out/production/Competitive Programming/D10_max_points_on_line.class b/out/production/Competitive Programming/D10_max_points_on_line.class
new file mode 100644
index 0000000..00e21f1
Binary files /dev/null and b/out/production/Competitive Programming/D10_max_points_on_line.class differ
diff --git a/out/production/Competitive Programming/D10_school_assembly.class b/out/production/Competitive Programming/D10_school_assembly.class
new file mode 100644
index 0000000..d0a6ad4
Binary files /dev/null and b/out/production/Competitive Programming/D10_school_assembly.class differ
diff --git a/out/production/Competitive Programming/D11_distinct_elements_in_a_stream.class b/out/production/Competitive Programming/D11_distinct_elements_in_a_stream.class
new file mode 100644
index 0000000..701e6bc
Binary files /dev/null and b/out/production/Competitive Programming/D11_distinct_elements_in_a_stream.class differ
diff --git a/out/production/Competitive Programming/D11_duplicate_set.class b/out/production/Competitive Programming/D11_duplicate_set.class
new file mode 100644
index 0000000..27e5a75
Binary files /dev/null and b/out/production/Competitive Programming/D11_duplicate_set.class differ
diff --git a/out/production/Competitive Programming/D11_fake_profile.class b/out/production/Competitive Programming/D11_fake_profile.class
new file mode 100644
index 0000000..4d574fb
Binary files /dev/null and b/out/production/Competitive Programming/D11_fake_profile.class differ
diff --git a/out/production/Competitive Programming/D11_four_sum.class b/out/production/Competitive Programming/D11_four_sum.class
new file mode 100644
index 0000000..74bee71
Binary files /dev/null and b/out/production/Competitive Programming/D11_four_sum.class differ
diff --git a/out/production/Competitive Programming/D11_gap_btw_highest_lowest_occurence.class b/out/production/Competitive Programming/D11_gap_btw_highest_lowest_occurence.class
new file mode 100644
index 0000000..d4bdff9
Binary files /dev/null and b/out/production/Competitive Programming/D11_gap_btw_highest_lowest_occurence.class differ
diff --git a/out/production/Competitive Programming/D11_identify_string$1.class b/out/production/Competitive Programming/D11_identify_string$1.class
new file mode 100644
index 0000000..5941a1c
Binary files /dev/null and b/out/production/Competitive Programming/D11_identify_string$1.class differ
diff --git a/out/production/Competitive Programming/D11_identify_string.class b/out/production/Competitive Programming/D11_identify_string.class
new file mode 100644
index 0000000..96eda77
Binary files /dev/null and b/out/production/Competitive Programming/D11_identify_string.class differ
diff --git a/out/production/Competitive Programming/D11_is_array_contiguous.class b/out/production/Competitive Programming/D11_is_array_contiguous.class
new file mode 100644
index 0000000..18a1299
Binary files /dev/null and b/out/production/Competitive Programming/D11_is_array_contiguous.class differ
diff --git a/out/production/Competitive Programming/D11_k_smallest_ele_in_order.class b/out/production/Competitive Programming/D11_k_smallest_ele_in_order.class
new file mode 100644
index 0000000..d3823a4
Binary files /dev/null and b/out/production/Competitive Programming/D11_k_smallest_ele_in_order.class differ
diff --git a/out/production/Competitive Programming/D11_number_of_primes.class b/out/production/Competitive Programming/D11_number_of_primes.class
new file mode 100644
index 0000000..ebc9650
Binary files /dev/null and b/out/production/Competitive Programming/D11_number_of_primes.class differ
diff --git a/out/production/Competitive Programming/D11_smaller_on_left.class b/out/production/Competitive Programming/D11_smaller_on_left.class
new file mode 100644
index 0000000..c747170
Binary files /dev/null and b/out/production/Competitive Programming/D11_smaller_on_left.class differ
diff --git a/out/production/Competitive Programming/D11_sort_char_by_freq$1.class b/out/production/Competitive Programming/D11_sort_char_by_freq$1.class
new file mode 100644
index 0000000..1d05991
Binary files /dev/null and b/out/production/Competitive Programming/D11_sort_char_by_freq$1.class differ
diff --git a/out/production/Competitive Programming/D11_sort_char_by_freq.class b/out/production/Competitive Programming/D11_sort_char_by_freq.class
new file mode 100644
index 0000000..dae423e
Binary files /dev/null and b/out/production/Competitive Programming/D11_sort_char_by_freq.class differ
diff --git a/out/production/Competitive Programming/D12_ANAGRAM_MAPPING.class b/out/production/Competitive Programming/D12_ANAGRAM_MAPPING.class
new file mode 100644
index 0000000..7574c6b
Binary files /dev/null and b/out/production/Competitive Programming/D12_ANAGRAM_MAPPING.class differ
diff --git a/out/production/Competitive Programming/D12_SMALLEST_SUBARRAY_WITH_ALL_OCCURENCES_OF_MOST_FREQUENT_ELEMENT.class b/out/production/Competitive Programming/D12_SMALLEST_SUBARRAY_WITH_ALL_OCCURENCES_OF_MOST_FREQUENT_ELEMENT.class
new file mode 100644
index 0000000..8d30ac0
Binary files /dev/null and b/out/production/Competitive Programming/D12_SMALLEST_SUBARRAY_WITH_ALL_OCCURENCES_OF_MOST_FREQUENT_ELEMENT.class differ
diff --git a/out/production/Competitive Programming/D12_SMALLEST_WINDOW_IN_STR_CONTAINING_ALL_CHAR_OF_ANOTHER.class b/out/production/Competitive Programming/D12_SMALLEST_WINDOW_IN_STR_CONTAINING_ALL_CHAR_OF_ANOTHER.class
new file mode 100644
index 0000000..ffd7169
Binary files /dev/null and b/out/production/Competitive Programming/D12_SMALLEST_WINDOW_IN_STR_CONTAINING_ALL_CHAR_OF_ANOTHER.class differ
diff --git a/out/production/Competitive Programming/D12_SORTING_ELE_OF_ARR_BY_FREQ$mapComparator.class b/out/production/Competitive Programming/D12_SORTING_ELE_OF_ARR_BY_FREQ$mapComparator.class
new file mode 100644
index 0000000..e34ea88
Binary files /dev/null and b/out/production/Competitive Programming/D12_SORTING_ELE_OF_ARR_BY_FREQ$mapComparator.class differ
diff --git a/out/production/Competitive Programming/D12_SORTING_ELE_OF_ARR_BY_FREQ.class b/out/production/Competitive Programming/D12_SORTING_ELE_OF_ARR_BY_FREQ.class
new file mode 100644
index 0000000..092d37e
Binary files /dev/null and b/out/production/Competitive Programming/D12_SORTING_ELE_OF_ARR_BY_FREQ.class differ
diff --git a/out/production/Competitive Programming/D12_SUBARRAY_RANGE_WITH_GIVEN_SUM.class b/out/production/Competitive Programming/D12_SUBARRAY_RANGE_WITH_GIVEN_SUM.class
new file mode 100644
index 0000000..47d386d
Binary files /dev/null and b/out/production/Competitive Programming/D12_SUBARRAY_RANGE_WITH_GIVEN_SUM.class differ
diff --git a/out/production/Competitive Programming/D12_SUBARRAY_SUM_DIV_BY_K.class b/out/production/Competitive Programming/D12_SUBARRAY_SUM_DIV_BY_K.class
new file mode 100644
index 0000000..d86c17e
Binary files /dev/null and b/out/production/Competitive Programming/D12_SUBARRAY_SUM_DIV_BY_K.class differ
diff --git a/out/production/Competitive Programming/D12_SubArrays_With_Equal_1s_n_0s.class b/out/production/Competitive Programming/D12_SubArrays_With_Equal_1s_n_0s.class
new file mode 100644
index 0000000..96892e7
Binary files /dev/null and b/out/production/Competitive Programming/D12_SubArrays_With_Equal_1s_n_0s.class differ
diff --git a/out/production/Competitive Programming/D12_TWO_SUM.class b/out/production/Competitive Programming/D12_TWO_SUM.class
new file mode 100644
index 0000000..4038b25
Binary files /dev/null and b/out/production/Competitive Programming/D12_TWO_SUM.class differ
diff --git a/out/production/Competitive Programming/D12_powerful_integer.class b/out/production/Competitive Programming/D12_powerful_integer.class
new file mode 100644
index 0000000..277b002
Binary files /dev/null and b/out/production/Competitive Programming/D12_powerful_integer.class differ
diff --git a/out/production/Competitive Programming/D12_smallest_distinct_window.class b/out/production/Competitive Programming/D12_smallest_distinct_window.class
new file mode 100644
index 0000000..750d505
Binary files /dev/null and b/out/production/Competitive Programming/D12_smallest_distinct_window.class differ
diff --git a/out/production/Competitive Programming/D12_subdomain_visit_count.class b/out/production/Competitive Programming/D12_subdomain_visit_count.class
new file mode 100644
index 0000000..d3e52df
Binary files /dev/null and b/out/production/Competitive Programming/D12_subdomain_visit_count.class differ
diff --git a/out/production/Competitive Programming/D12_sum_of_length_of_all_substrings_no_duplicacy.class b/out/production/Competitive Programming/D12_sum_of_length_of_all_substrings_no_duplicacy.class
new file mode 100644
index 0000000..befe0ae
Binary files /dev/null and b/out/production/Competitive Programming/D12_sum_of_length_of_all_substrings_no_duplicacy.class differ
diff --git a/out/production/Competitive Programming/D13_Group_Anagrams$ListComparator.class b/out/production/Competitive Programming/D13_Group_Anagrams$ListComparator.class
new file mode 100644
index 0000000..e56c673
Binary files /dev/null and b/out/production/Competitive Programming/D13_Group_Anagrams$ListComparator.class differ
diff --git a/out/production/Competitive Programming/D13_Group_Anagrams.class b/out/production/Competitive Programming/D13_Group_Anagrams.class
new file mode 100644
index 0000000..c64c7b5
Binary files /dev/null and b/out/production/Competitive Programming/D13_Group_Anagrams.class differ
diff --git a/out/production/Competitive Programming/D13_Group_Shifted_Strings$ListComparator.class b/out/production/Competitive Programming/D13_Group_Shifted_Strings$ListComparator.class
new file mode 100644
index 0000000..2f73093
Binary files /dev/null and b/out/production/Competitive Programming/D13_Group_Shifted_Strings$ListComparator.class differ
diff --git a/out/production/Competitive Programming/D13_Group_Shifted_Strings.class b/out/production/Competitive Programming/D13_Group_Shifted_Strings.class
new file mode 100644
index 0000000..ae4c0f6
Binary files /dev/null and b/out/production/Competitive Programming/D13_Group_Shifted_Strings.class differ
diff --git a/out/production/Competitive Programming/D13_Happy_Number.class b/out/production/Competitive Programming/D13_Happy_Number.class
new file mode 100644
index 0000000..7e44108
Binary files /dev/null and b/out/production/Competitive Programming/D13_Happy_Number.class differ
diff --git a/out/production/Competitive Programming/D13_Height_OF_HEAP.class b/out/production/Competitive Programming/D13_Height_OF_HEAP.class
new file mode 100644
index 0000000..84a71cc
Binary files /dev/null and b/out/production/Competitive Programming/D13_Height_OF_HEAP.class differ
diff --git a/out/production/Competitive Programming/D13_ISLAND_PERIMETER.class b/out/production/Competitive Programming/D13_ISLAND_PERIMETER.class
new file mode 100644
index 0000000..48811f3
Binary files /dev/null and b/out/production/Competitive Programming/D13_ISLAND_PERIMETER.class differ
diff --git a/out/production/Competitive Programming/D13_Jewels_n_Stones.class b/out/production/Competitive Programming/D13_Jewels_n_Stones.class
new file mode 100644
index 0000000..f44ce5e
Binary files /dev/null and b/out/production/Competitive Programming/D13_Jewels_n_Stones.class differ
diff --git a/out/production/Competitive Programming/D13_K_Closest_to_Origin$PointComparator.class b/out/production/Competitive Programming/D13_K_Closest_to_Origin$PointComparator.class
new file mode 100644
index 0000000..7935244
Binary files /dev/null and b/out/production/Competitive Programming/D13_K_Closest_to_Origin$PointComparator.class differ
diff --git a/out/production/Competitive Programming/D13_K_Closest_to_Origin$point.class b/out/production/Competitive Programming/D13_K_Closest_to_Origin$point.class
new file mode 100644
index 0000000..fa3c4b7
Binary files /dev/null and b/out/production/Competitive Programming/D13_K_Closest_to_Origin$point.class differ
diff --git a/out/production/Competitive Programming/D13_K_Closest_to_Origin.class b/out/production/Competitive Programming/D13_K_Closest_to_Origin.class
new file mode 100644
index 0000000..7667a4d
Binary files /dev/null and b/out/production/Competitive Programming/D13_K_Closest_to_Origin.class differ
diff --git a/out/production/Competitive Programming/D13_Pepcoding_New_System.class b/out/production/Competitive Programming/D13_Pepcoding_New_System.class
new file mode 100644
index 0000000..4095a04
Binary files /dev/null and b/out/production/Competitive Programming/D13_Pepcoding_New_System.class differ
diff --git a/out/production/Competitive Programming/D13_Uncommon_Characters.class b/out/production/Competitive Programming/D13_Uncommon_Characters.class
new file mode 100644
index 0000000..443d408
Binary files /dev/null and b/out/production/Competitive Programming/D13_Uncommon_Characters.class differ
diff --git a/out/production/Competitive Programming/D13_Uncommon_Words.class b/out/production/Competitive Programming/D13_Uncommon_Words.class
new file mode 100644
index 0000000..d92c7ca
Binary files /dev/null and b/out/production/Competitive Programming/D13_Uncommon_Words.class differ
diff --git a/out/production/Competitive Programming/D13_Union_Of_Two_Arrays.class b/out/production/Competitive Programming/D13_Union_Of_Two_Arrays.class
new file mode 100644
index 0000000..bb47ea4
Binary files /dev/null and b/out/production/Competitive Programming/D13_Union_Of_Two_Arrays.class differ
diff --git a/out/production/Competitive Programming/D13_VALID_SUDOku.class b/out/production/Competitive Programming/D13_VALID_SUDOku.class
new file mode 100644
index 0000000..3dec764
Binary files /dev/null and b/out/production/Competitive Programming/D13_VALID_SUDOku.class differ
diff --git a/out/production/Competitive Programming/D13_Valid_Anagram.class b/out/production/Competitive Programming/D13_Valid_Anagram.class
new file mode 100644
index 0000000..3f4ad31
Binary files /dev/null and b/out/production/Competitive Programming/D13_Valid_Anagram.class differ
diff --git a/out/production/Competitive Programming/D13_find_k_pairs_with_smallest_sums$ListComparator.class b/out/production/Competitive Programming/D13_find_k_pairs_with_smallest_sums$ListComparator.class
new file mode 100644
index 0000000..bd09568
Binary files /dev/null and b/out/production/Competitive Programming/D13_find_k_pairs_with_smallest_sums$ListComparator.class differ
diff --git a/out/production/Competitive Programming/D13_find_k_pairs_with_smallest_sums.class b/out/production/Competitive Programming/D13_find_k_pairs_with_smallest_sums.class
new file mode 100644
index 0000000..1867f69
Binary files /dev/null and b/out/production/Competitive Programming/D13_find_k_pairs_with_smallest_sums.class differ
diff --git a/out/production/Competitive Programming/D14_Equivalent_Sub_Arrays.class b/out/production/Competitive Programming/D14_Equivalent_Sub_Arrays.class
new file mode 100644
index 0000000..a52c286
Binary files /dev/null and b/out/production/Competitive Programming/D14_Equivalent_Sub_Arrays.class differ
diff --git a/out/production/Competitive Programming/D14_Huffman_Decoding$heapComparator.class b/out/production/Competitive Programming/D14_Huffman_Decoding$heapComparator.class
new file mode 100644
index 0000000..3a0c79f
Binary files /dev/null and b/out/production/Competitive Programming/D14_Huffman_Decoding$heapComparator.class differ
diff --git a/out/production/Competitive Programming/D14_Huffman_Decoding$minHeapNode.class b/out/production/Competitive Programming/D14_Huffman_Decoding$minHeapNode.class
new file mode 100644
index 0000000..00bac6e
Binary files /dev/null and b/out/production/Competitive Programming/D14_Huffman_Decoding$minHeapNode.class differ
diff --git a/out/production/Competitive Programming/D14_Huffman_Decoding.class b/out/production/Competitive Programming/D14_Huffman_Decoding.class
new file mode 100644
index 0000000..f119690
Binary files /dev/null and b/out/production/Competitive Programming/D14_Huffman_Decoding.class differ
diff --git a/out/production/Competitive Programming/D14_Huffman_Encoding$Node.class b/out/production/Competitive Programming/D14_Huffman_Encoding$Node.class
new file mode 100644
index 0000000..e926824
Binary files /dev/null and b/out/production/Competitive Programming/D14_Huffman_Encoding$Node.class differ
diff --git a/out/production/Competitive Programming/D14_Huffman_Encoding$NodeComparator.class b/out/production/Competitive Programming/D14_Huffman_Encoding$NodeComparator.class
new file mode 100644
index 0000000..6677138
Binary files /dev/null and b/out/production/Competitive Programming/D14_Huffman_Encoding$NodeComparator.class differ
diff --git a/out/production/Competitive Programming/D14_Huffman_Encoding.class b/out/production/Competitive Programming/D14_Huffman_Encoding.class
new file mode 100644
index 0000000..602c7be
Binary files /dev/null and b/out/production/Competitive Programming/D14_Huffman_Encoding.class differ
diff --git a/out/production/Competitive Programming/D14_INTERSECTION_OF_TWO_ARR.class b/out/production/Competitive Programming/D14_INTERSECTION_OF_TWO_ARR.class
new file mode 100644
index 0000000..7613be5
Binary files /dev/null and b/out/production/Competitive Programming/D14_INTERSECTION_OF_TWO_ARR.class differ
diff --git a/out/production/Competitive Programming/D14_INTERSECTION_OF_TWO_ARRAYS_V2.class b/out/production/Competitive Programming/D14_INTERSECTION_OF_TWO_ARRAYS_V2.class
new file mode 100644
index 0000000..f928c13
Binary files /dev/null and b/out/production/Competitive Programming/D14_INTERSECTION_OF_TWO_ARRAYS_V2.class differ
diff --git a/out/production/Competitive Programming/D14_IN_FIRST_BUT_SECOND.class b/out/production/Competitive Programming/D14_IN_FIRST_BUT_SECOND.class
new file mode 100644
index 0000000..48cac7d
Binary files /dev/null and b/out/production/Competitive Programming/D14_IN_FIRST_BUT_SECOND.class differ
diff --git a/out/production/Competitive Programming/D14_IS_ISOMORPHIC.class b/out/production/Competitive Programming/D14_IS_ISOMORPHIC.class
new file mode 100644
index 0000000..7156ab4
Binary files /dev/null and b/out/production/Competitive Programming/D14_IS_ISOMORPHIC.class differ
diff --git a/out/production/Competitive Programming/D14_Keyboard_Row.class b/out/production/Competitive Programming/D14_Keyboard_Row.class
new file mode 100644
index 0000000..5a4abe2
Binary files /dev/null and b/out/production/Competitive Programming/D14_Keyboard_Row.class differ
diff --git a/out/production/Competitive Programming/D14_LONGEST_SUBSTRING_WITHOUT_REPEATING_CHAR.class b/out/production/Competitive Programming/D14_LONGEST_SUBSTRING_WITHOUT_REPEATING_CHAR.class
new file mode 100644
index 0000000..7d70155
Binary files /dev/null and b/out/production/Competitive Programming/D14_LONGEST_SUBSTRING_WITHOUT_REPEATING_CHAR.class differ
diff --git a/out/production/Competitive Programming/D14_LONGEST_SUBSTRING_WITH_EQUAL_NUMBER_0s_n_1s.class b/out/production/Competitive Programming/D14_LONGEST_SUBSTRING_WITH_EQUAL_NUMBER_0s_n_1s.class
new file mode 100644
index 0000000..453543f
Binary files /dev/null and b/out/production/Competitive Programming/D14_LONGEST_SUBSTRING_WITH_EQUAL_NUMBER_0s_n_1s.class differ
diff --git a/out/production/Competitive Programming/D14_LONGEST_SubArr_With_Sum_Div_K.class b/out/production/Competitive Programming/D14_LONGEST_SubArr_With_Sum_Div_K.class
new file mode 100644
index 0000000..94a21ec
Binary files /dev/null and b/out/production/Competitive Programming/D14_LONGEST_SubArr_With_Sum_Div_K.class differ
diff --git a/out/production/Competitive Programming/D14_Largest_Fibonaci_SubSeq.class b/out/production/Competitive Programming/D14_Largest_Fibonaci_SubSeq.class
new file mode 100644
index 0000000..cd8bcbf
Binary files /dev/null and b/out/production/Competitive Programming/D14_Largest_Fibonaci_SubSeq.class differ
diff --git a/out/production/Competitive Programming/D14_Largest_Subarray_with_0_Sum.class b/out/production/Competitive Programming/D14_Largest_Subarray_with_0_Sum.class
new file mode 100644
index 0000000..3350f65
Binary files /dev/null and b/out/production/Competitive Programming/D14_Largest_Subarray_with_0_Sum.class differ
diff --git a/out/production/Competitive Programming/D14_Logger_Rate_Limiter$Logger.class b/out/production/Competitive Programming/D14_Logger_Rate_Limiter$Logger.class
new file mode 100644
index 0000000..f5c05a6
Binary files /dev/null and b/out/production/Competitive Programming/D14_Logger_Rate_Limiter$Logger.class differ
diff --git a/out/production/Competitive Programming/D14_Logger_Rate_Limiter.class b/out/production/Competitive Programming/D14_Logger_Rate_Limiter.class
new file mode 100644
index 0000000..a6f2aed
Binary files /dev/null and b/out/production/Competitive Programming/D14_Logger_Rate_Limiter.class differ
diff --git a/out/production/Competitive Programming/D14_Longest_Consecutive_Sub_Seq.class b/out/production/Competitive Programming/D14_Longest_Consecutive_Sub_Seq.class
new file mode 100644
index 0000000..09f5317
Binary files /dev/null and b/out/production/Competitive Programming/D14_Longest_Consecutive_Sub_Seq.class differ
diff --git a/out/production/Competitive Programming/D14_Longest_K_Unique_Substring.class b/out/production/Competitive Programming/D14_Longest_K_Unique_Substring.class
new file mode 100644
index 0000000..27f37f9
Binary files /dev/null and b/out/production/Competitive Programming/D14_Longest_K_Unique_Substring.class differ
diff --git a/out/production/Competitive Programming/D14_Longest_Palindrome.class b/out/production/Competitive Programming/D14_Longest_Palindrome.class
new file mode 100644
index 0000000..601edd9
Binary files /dev/null and b/out/production/Competitive Programming/D14_Longest_Palindrome.class differ
diff --git a/out/production/Competitive Programming/D14_Longest_SubArr_With_Sum_K.class b/out/production/Competitive Programming/D14_Longest_SubArr_With_Sum_K.class
new file mode 100644
index 0000000..5c15875
Binary files /dev/null and b/out/production/Competitive Programming/D14_Longest_SubArr_With_Sum_K.class differ
diff --git a/out/production/Competitive Programming/D14_Love_for_the_twins.class b/out/production/Competitive Programming/D14_Love_for_the_twins.class
new file mode 100644
index 0000000..506de22
Binary files /dev/null and b/out/production/Competitive Programming/D14_Love_for_the_twins.class differ
diff --git a/out/production/Competitive Programming/D14_MeetingRooms2.class b/out/production/Competitive Programming/D14_MeetingRooms2.class
new file mode 100644
index 0000000..bb2a107
Binary files /dev/null and b/out/production/Competitive Programming/D14_MeetingRooms2.class differ
diff --git a/out/production/Competitive Programming/D14_Tiger_Zinda_Hai_Close_Opened_Tabs.class b/out/production/Competitive Programming/D14_Tiger_Zinda_Hai_Close_Opened_Tabs.class
new file mode 100644
index 0000000..ddb8a4e
Binary files /dev/null and b/out/production/Competitive Programming/D14_Tiger_Zinda_Hai_Close_Opened_Tabs.class differ
diff --git a/out/production/Competitive Programming/D14_Unique_num.class b/out/production/Competitive Programming/D14_Unique_num.class
new file mode 100644
index 0000000..788eaea
Binary files /dev/null and b/out/production/Competitive Programming/D14_Unique_num.class differ
diff --git a/out/production/Competitive Programming/D14_Winner_of_Election.class b/out/production/Competitive Programming/D14_Winner_of_Election.class
new file mode 100644
index 0000000..1e481f4
Binary files /dev/null and b/out/production/Competitive Programming/D14_Winner_of_Election.class differ
diff --git a/out/production/Competitive Programming/D14_Word_Pattern.class b/out/production/Competitive Programming/D14_Word_Pattern.class
new file mode 100644
index 0000000..bc87d0c
Binary files /dev/null and b/out/production/Competitive Programming/D14_Word_Pattern.class differ
diff --git a/out/production/Competitive Programming/D14_k_largest_elemts.class b/out/production/Competitive Programming/D14_k_largest_elemts.class
new file mode 100644
index 0000000..46ac051
Binary files /dev/null and b/out/production/Competitive Programming/D14_k_largest_elemts.class differ
diff --git a/out/production/Competitive Programming/D14_kth_Distinct_Element.class b/out/production/Competitive Programming/D14_kth_Distinct_Element.class
new file mode 100644
index 0000000..d3e5201
Binary files /dev/null and b/out/production/Competitive Programming/D14_kth_Distinct_Element.class differ
diff --git a/out/production/Competitive Programming/D14_kth_Element_In_Matrix.class b/out/production/Competitive Programming/D14_kth_Element_In_Matrix.class
new file mode 100644
index 0000000..9e59892
Binary files /dev/null and b/out/production/Competitive Programming/D14_kth_Element_In_Matrix.class differ
diff --git a/out/production/Competitive Programming/D14_kth_largest_in_a_stream$KthLargest.class b/out/production/Competitive Programming/D14_kth_largest_in_a_stream$KthLargest.class
new file mode 100644
index 0000000..3c9a00e
Binary files /dev/null and b/out/production/Competitive Programming/D14_kth_largest_in_a_stream$KthLargest.class differ
diff --git a/out/production/Competitive Programming/D14_kth_largest_in_a_stream.class b/out/production/Competitive Programming/D14_kth_largest_in_a_stream.class
new file mode 100644
index 0000000..4bf8c03
Binary files /dev/null and b/out/production/Competitive Programming/D14_kth_largest_in_a_stream.class differ
diff --git a/out/production/Competitive Programming/D14_tom_n_String_GenerateHashVal.class b/out/production/Competitive Programming/D14_tom_n_String_GenerateHashVal.class
new file mode 100644
index 0000000..486f79c
Binary files /dev/null and b/out/production/Competitive Programming/D14_tom_n_String_GenerateHashVal.class differ
diff --git a/out/production/Competitive Programming/D14_top_k_frequent$PQComparator.class b/out/production/Competitive Programming/D14_top_k_frequent$PQComparator.class
new file mode 100644
index 0000000..ca8c790
Binary files /dev/null and b/out/production/Competitive Programming/D14_top_k_frequent$PQComparator.class differ
diff --git a/out/production/Competitive Programming/D14_top_k_frequent.class b/out/production/Competitive Programming/D14_top_k_frequent.class
new file mode 100644
index 0000000..20999e2
Binary files /dev/null and b/out/production/Competitive Programming/D14_top_k_frequent.class differ
diff --git a/out/production/Competitive Programming/D14_top_k_frequent_words$PQComparator.class b/out/production/Competitive Programming/D14_top_k_frequent_words$PQComparator.class
new file mode 100644
index 0000000..3d21e16
Binary files /dev/null and b/out/production/Competitive Programming/D14_top_k_frequent_words$PQComparator.class differ
diff --git a/out/production/Competitive Programming/D14_top_k_frequent_words.class b/out/production/Competitive Programming/D14_top_k_frequent_words.class
new file mode 100644
index 0000000..070fbbb
Binary files /dev/null and b/out/production/Competitive Programming/D14_top_k_frequent_words.class differ
diff --git a/out/production/Competitive Programming/D15_Add_Bold_Tag.class b/out/production/Competitive Programming/D15_Add_Bold_Tag.class
new file mode 100644
index 0000000..d5f1c44
Binary files /dev/null and b/out/production/Competitive Programming/D15_Add_Bold_Tag.class differ
diff --git a/out/production/Competitive Programming/D15_Integer_To_String.class b/out/production/Competitive Programming/D15_Integer_To_String.class
new file mode 100644
index 0000000..d8d5af2
Binary files /dev/null and b/out/production/Competitive Programming/D15_Integer_To_String.class differ
diff --git a/out/production/Competitive Programming/D15_Long_Pressed_Name.class b/out/production/Competitive Programming/D15_Long_Pressed_Name.class
new file mode 100644
index 0000000..532d952
Binary files /dev/null and b/out/production/Competitive Programming/D15_Long_Pressed_Name.class differ
diff --git a/out/production/Competitive Programming/D15_Max_CHunks_To_Sorted.class b/out/production/Competitive Programming/D15_Max_CHunks_To_Sorted.class
new file mode 100644
index 0000000..4812b1b
Binary files /dev/null and b/out/production/Competitive Programming/D15_Max_CHunks_To_Sorted.class differ
diff --git a/out/production/Competitive Programming/D15_Num_Of_Magic_Sq.class b/out/production/Competitive Programming/D15_Num_Of_Magic_Sq.class
new file mode 100644
index 0000000..5e0423a
Binary files /dev/null and b/out/production/Competitive Programming/D15_Num_Of_Magic_Sq.class differ
diff --git a/out/production/Competitive Programming/D15_Reveal_Cards_In_Deck.class b/out/production/Competitive Programming/D15_Reveal_Cards_In_Deck.class
new file mode 100644
index 0000000..4b9ba44
Binary files /dev/null and b/out/production/Competitive Programming/D15_Reveal_Cards_In_Deck.class differ
diff --git a/out/production/Competitive Programming/D15_Shifting_Letters.class b/out/production/Competitive Programming/D15_Shifting_Letters.class
new file mode 100644
index 0000000..062d5c9
Binary files /dev/null and b/out/production/Competitive Programming/D15_Shifting_Letters.class differ
diff --git a/out/production/Competitive Programming/D16_Attacking.class b/out/production/Competitive Programming/D16_Attacking.class
new file mode 100644
index 0000000..2c4a8d0
Binary files /dev/null and b/out/production/Competitive Programming/D16_Attacking.class differ
diff --git a/out/production/Competitive Programming/D16_Max_Consecutive_Ones.class b/out/production/Competitive Programming/D16_Max_Consecutive_Ones.class
new file mode 100644
index 0000000..50b7bb5
Binary files /dev/null and b/out/production/Competitive Programming/D16_Max_Consecutive_Ones.class differ
diff --git a/out/production/Competitive Programming/D16_Next_Closest_Time.class b/out/production/Competitive Programming/D16_Next_Closest_Time.class
new file mode 100644
index 0000000..1b69431
Binary files /dev/null and b/out/production/Competitive Programming/D16_Next_Closest_Time.class differ
diff --git a/out/production/Competitive Programming/D16_One_Edit_Distance.class b/out/production/Competitive Programming/D16_One_Edit_Distance.class
new file mode 100644
index 0000000..a02b6ca
Binary files /dev/null and b/out/production/Competitive Programming/D16_One_Edit_Distance.class differ
diff --git a/out/production/Competitive Programming/D16_Product_Of_Array_Except_Self.class b/out/production/Competitive Programming/D16_Product_Of_Array_Except_Self.class
new file mode 100644
index 0000000..1e5f1b6
Binary files /dev/null and b/out/production/Competitive Programming/D16_Product_Of_Array_Except_Self.class differ
diff --git a/out/production/Competitive Programming/D16_Ransom_Note.class b/out/production/Competitive Programming/D16_Ransom_Note.class
new file mode 100644
index 0000000..bc86705
Binary files /dev/null and b/out/production/Competitive Programming/D16_Ransom_Note.class differ
diff --git a/out/production/Competitive Programming/D16_Remove_Comments.class b/out/production/Competitive Programming/D16_Remove_Comments.class
new file mode 100644
index 0000000..1d06741
Binary files /dev/null and b/out/production/Competitive Programming/D16_Remove_Comments.class differ
diff --git a/out/production/Competitive Programming/D16_Shortest_Word_Distance.class b/out/production/Competitive Programming/D16_Shortest_Word_Distance.class
new file mode 100644
index 0000000..e9f3b0a
Binary files /dev/null and b/out/production/Competitive Programming/D16_Shortest_Word_Distance.class differ
diff --git a/out/production/Competitive Programming/D16_Shortest_n_Unsorted_SubArray.class b/out/production/Competitive Programming/D16_Shortest_n_Unsorted_SubArray.class
new file mode 100644
index 0000000..74780a4
Binary files /dev/null and b/out/production/Competitive Programming/D16_Shortest_n_Unsorted_SubArray.class differ
diff --git a/out/production/Competitive Programming/D16_Similar_RGB_Color.class b/out/production/Competitive Programming/D16_Similar_RGB_Color.class
new file mode 100644
index 0000000..9530dcf
Binary files /dev/null and b/out/production/Competitive Programming/D16_Similar_RGB_Color.class differ
diff --git a/out/production/Competitive Programming/D16_Sort_Array_By_Parity.class b/out/production/Competitive Programming/D16_Sort_Array_By_Parity.class
new file mode 100644
index 0000000..b15ab80
Binary files /dev/null and b/out/production/Competitive Programming/D16_Sort_Array_By_Parity.class differ
diff --git a/out/production/Competitive Programming/D16_Squares_Of_Sorted_Array.class b/out/production/Competitive Programming/D16_Squares_Of_Sorted_Array.class
new file mode 100644
index 0000000..831fc78
Binary files /dev/null and b/out/production/Competitive Programming/D16_Squares_Of_Sorted_Array.class differ
diff --git a/out/production/Competitive Programming/D16_Student_Attendance_record.class b/out/production/Competitive Programming/D16_Student_Attendance_record.class
new file mode 100644
index 0000000..f1a3d39
Binary files /dev/null and b/out/production/Competitive Programming/D16_Student_Attendance_record.class differ
diff --git a/out/production/Competitive Programming/D16_Toeplitz_Matrix.class b/out/production/Competitive Programming/D16_Toeplitz_Matrix.class
new file mode 100644
index 0000000..64112b4
Binary files /dev/null and b/out/production/Competitive Programming/D16_Toeplitz_Matrix.class differ
diff --git a/out/production/Competitive Programming/D17_Buy_Stock_Sell_Stock_V2.class b/out/production/Competitive Programming/D17_Buy_Stock_Sell_Stock_V2.class
new file mode 100644
index 0000000..dc93480
Binary files /dev/null and b/out/production/Competitive Programming/D17_Buy_Stock_Sell_Stock_V2.class differ
diff --git a/out/production/Competitive Programming/D17_Character_Replacment.class b/out/production/Competitive Programming/D17_Character_Replacment.class
new file mode 100644
index 0000000..1b1f58d
Binary files /dev/null and b/out/production/Competitive Programming/D17_Character_Replacment.class differ
diff --git a/out/production/Competitive Programming/D17_Container_With_Most_Water.class b/out/production/Competitive Programming/D17_Container_With_Most_Water.class
new file mode 100644
index 0000000..7f99196
Binary files /dev/null and b/out/production/Competitive Programming/D17_Container_With_Most_Water.class differ
diff --git a/out/production/Competitive Programming/D17_Count_Binary_Strings.class b/out/production/Competitive Programming/D17_Count_Binary_Strings.class
new file mode 100644
index 0000000..c944086
Binary files /dev/null and b/out/production/Competitive Programming/D17_Count_Binary_Strings.class differ
diff --git a/out/production/Competitive Programming/D17_Flip_Game.class b/out/production/Competitive Programming/D17_Flip_Game.class
new file mode 100644
index 0000000..0d5858a
Binary files /dev/null and b/out/production/Competitive Programming/D17_Flip_Game.class differ
diff --git a/out/production/Competitive Programming/D17_Masking_Personal_Information.class b/out/production/Competitive Programming/D17_Masking_Personal_Information.class
new file mode 100644
index 0000000..4272885
Binary files /dev/null and b/out/production/Competitive Programming/D17_Masking_Personal_Information.class differ
diff --git a/out/production/Competitive Programming/D17_Nesting_Array.class b/out/production/Competitive Programming/D17_Nesting_Array.class
new file mode 100644
index 0000000..dcc47ab
Binary files /dev/null and b/out/production/Competitive Programming/D17_Nesting_Array.class differ
diff --git a/out/production/Competitive Programming/D17_Nice_Arrangement.class b/out/production/Competitive Programming/D17_Nice_Arrangement.class
new file mode 100644
index 0000000..d05c0df
Binary files /dev/null and b/out/production/Competitive Programming/D17_Nice_Arrangement.class differ
diff --git a/out/production/Competitive Programming/D17_PlusOne.class b/out/production/Competitive Programming/D17_PlusOne.class
new file mode 100644
index 0000000..3cac898
Binary files /dev/null and b/out/production/Competitive Programming/D17_PlusOne.class differ
diff --git a/out/production/Competitive Programming/D17_Reverse_String_Without_Space.class b/out/production/Competitive Programming/D17_Reverse_String_Without_Space.class
new file mode 100644
index 0000000..b311586
Binary files /dev/null and b/out/production/Competitive Programming/D17_Reverse_String_Without_Space.class differ
diff --git a/out/production/Competitive Programming/D17_Robot_Return_to_Origin_Judge_Circle.class b/out/production/Competitive Programming/D17_Robot_Return_to_Origin_Judge_Circle.class
new file mode 100644
index 0000000..b64ded5
Binary files /dev/null and b/out/production/Competitive Programming/D17_Robot_Return_to_Origin_Judge_Circle.class differ
diff --git a/out/production/Competitive Programming/D17_Rotate_Array.class b/out/production/Competitive Programming/D17_Rotate_Array.class
new file mode 100644
index 0000000..56cdd70
Binary files /dev/null and b/out/production/Competitive Programming/D17_Rotate_Array.class differ
diff --git a/out/production/Competitive Programming/D17_Split_Array_With_Equal_Sum.class b/out/production/Competitive Programming/D17_Split_Array_With_Equal_Sum.class
new file mode 100644
index 0000000..d38570f
Binary files /dev/null and b/out/production/Competitive Programming/D17_Split_Array_With_Equal_Sum.class differ
diff --git a/out/production/Competitive Programming/D17_Three_Sum$1.class b/out/production/Competitive Programming/D17_Three_Sum$1.class
new file mode 100644
index 0000000..7aea2d6
Binary files /dev/null and b/out/production/Competitive Programming/D17_Three_Sum$1.class differ
diff --git a/out/production/Competitive Programming/D17_Three_Sum.class b/out/production/Competitive Programming/D17_Three_Sum.class
new file mode 100644
index 0000000..a3c8772
Binary files /dev/null and b/out/production/Competitive Programming/D17_Three_Sum.class differ
diff --git a/out/production/Competitive Programming/D18_Compare_Two_Versions.class b/out/production/Competitive Programming/D18_Compare_Two_Versions.class
new file mode 100644
index 0000000..93ba977
Binary files /dev/null and b/out/production/Competitive Programming/D18_Compare_Two_Versions.class differ
diff --git a/out/production/Competitive Programming/D18_Custom_Sort_String.class b/out/production/Competitive Programming/D18_Custom_Sort_String.class
new file mode 100644
index 0000000..430a95e
Binary files /dev/null and b/out/production/Competitive Programming/D18_Custom_Sort_String.class differ
diff --git a/out/production/Competitive Programming/D18_Detect_Cycle_Circular.class b/out/production/Competitive Programming/D18_Detect_Cycle_Circular.class
new file mode 100644
index 0000000..2fcf88e
Binary files /dev/null and b/out/production/Competitive Programming/D18_Detect_Cycle_Circular.class differ
diff --git a/out/production/Competitive Programming/D18_Sort_Transformed_Array.class b/out/production/Competitive Programming/D18_Sort_Transformed_Array.class
new file mode 100644
index 0000000..b94624f
Binary files /dev/null and b/out/production/Competitive Programming/D18_Sort_Transformed_Array.class differ
diff --git a/out/production/Competitive Programming/D18_To_Lower_Case.class b/out/production/Competitive Programming/D18_To_Lower_Case.class
new file mode 100644
index 0000000..115d429
Binary files /dev/null and b/out/production/Competitive Programming/D18_To_Lower_Case.class differ
diff --git a/out/production/Competitive Programming/D19_Fibbonacci_Number.class b/out/production/Competitive Programming/D19_Fibbonacci_Number.class
new file mode 100644
index 0000000..9d5881e
Binary files /dev/null and b/out/production/Competitive Programming/D19_Fibbonacci_Number.class differ
diff --git a/out/production/Competitive Programming/D19_Infy_Test_Fun_With_Strings.class b/out/production/Competitive Programming/D19_Infy_Test_Fun_With_Strings.class
new file mode 100644
index 0000000..2253761
Binary files /dev/null and b/out/production/Competitive Programming/D19_Infy_Test_Fun_With_Strings.class differ
diff --git a/out/production/Competitive Programming/D19_Pour_Water.class b/out/production/Competitive Programming/D19_Pour_Water.class
new file mode 100644
index 0000000..ab61dd1
Binary files /dev/null and b/out/production/Competitive Programming/D19_Pour_Water.class differ
diff --git a/out/production/Competitive Programming/D19_Range_Addition.class b/out/production/Competitive Programming/D19_Range_Addition.class
new file mode 100644
index 0000000..c314be8
Binary files /dev/null and b/out/production/Competitive Programming/D19_Range_Addition.class differ
diff --git a/out/production/Competitive Programming/D19_Three_Sum_CLoser.class b/out/production/Competitive Programming/D19_Three_Sum_CLoser.class
new file mode 100644
index 0000000..35ad7e4
Binary files /dev/null and b/out/production/Competitive Programming/D19_Three_Sum_CLoser.class differ
diff --git a/out/production/Competitive Programming/D20_Ambiguous_Co_Ordinates.class b/out/production/Competitive Programming/D20_Ambiguous_Co_Ordinates.class
new file mode 100644
index 0000000..98ee97e
Binary files /dev/null and b/out/production/Competitive Programming/D20_Ambiguous_Co_Ordinates.class differ
diff --git a/out/production/Competitive Programming/D20_Global_And_Local_Inversions.class b/out/production/Competitive Programming/D20_Global_And_Local_Inversions.class
new file mode 100644
index 0000000..cf68582
Binary files /dev/null and b/out/production/Competitive Programming/D20_Global_And_Local_Inversions.class differ
diff --git a/out/production/Competitive Programming/D20_Integer_To_Roman.class b/out/production/Competitive Programming/D20_Integer_To_Roman.class
new file mode 100644
index 0000000..9f2fa62
Binary files /dev/null and b/out/production/Competitive Programming/D20_Integer_To_Roman.class differ
diff --git a/out/production/Competitive Programming/D20_Longest_repeating_Character.class b/out/production/Competitive Programming/D20_Longest_repeating_Character.class
new file mode 100644
index 0000000..7f05217
Binary files /dev/null and b/out/production/Competitive Programming/D20_Longest_repeating_Character.class differ
diff --git a/out/production/Competitive Programming/D20_Majority_Element.class b/out/production/Competitive Programming/D20_Majority_Element.class
new file mode 100644
index 0000000..d478f72
Binary files /dev/null and b/out/production/Competitive Programming/D20_Majority_Element.class differ
diff --git a/out/production/Competitive Programming/D21_Burst_Balloons.class b/out/production/Competitive Programming/D21_Burst_Balloons.class
new file mode 100644
index 0000000..0088f88
Binary files /dev/null and b/out/production/Competitive Programming/D21_Burst_Balloons.class differ
diff --git a/out/production/Competitive Programming/D21_Count_Board_Dice.class b/out/production/Competitive Programming/D21_Count_Board_Dice.class
new file mode 100644
index 0000000..795584b
Binary files /dev/null and b/out/production/Competitive Programming/D21_Count_Board_Dice.class differ
diff --git a/out/production/Competitive Programming/D21_Longest_Increasing_Sequence.class b/out/production/Competitive Programming/D21_Longest_Increasing_Sequence.class
new file mode 100644
index 0000000..1590ecd
Binary files /dev/null and b/out/production/Competitive Programming/D21_Longest_Increasing_Sequence.class differ
diff --git a/out/production/Competitive Programming/D21_Min_Deletions_to_make_sorted.class b/out/production/Competitive Programming/D21_Min_Deletions_to_make_sorted.class
new file mode 100644
index 0000000..1e0974b
Binary files /dev/null and b/out/production/Competitive Programming/D21_Min_Deletions_to_make_sorted.class differ
diff --git a/out/production/Competitive Programming/D22_Count_Maze_Paths.class b/out/production/Competitive Programming/D22_Count_Maze_Paths.class
new file mode 100644
index 0000000..8d78883
Binary files /dev/null and b/out/production/Competitive Programming/D22_Count_Maze_Paths.class differ
diff --git a/out/production/Competitive Programming/D23_GoldMineTabulated.class b/out/production/Competitive Programming/D23_GoldMineTabulated.class
new file mode 100644
index 0000000..a92ab91
Binary files /dev/null and b/out/production/Competitive Programming/D23_GoldMineTabulated.class differ
diff --git a/out/production/Competitive Programming/D23_Max_Size_Sq_In_A_Matrix.class b/out/production/Competitive Programming/D23_Max_Size_Sq_In_A_Matrix.class
new file mode 100644
index 0000000..e745c82
Binary files /dev/null and b/out/production/Competitive Programming/D23_Max_Size_Sq_In_A_Matrix.class differ
diff --git a/out/production/Competitive Programming/D23_Min_Cost_Path.class b/out/production/Competitive Programming/D23_Min_Cost_Path.class
new file mode 100644
index 0000000..5e403af
Binary files /dev/null and b/out/production/Competitive Programming/D23_Min_Cost_Path.class differ
diff --git a/out/production/Competitive Programming/D23_Palindrome_Substring.class b/out/production/Competitive Programming/D23_Palindrome_Substring.class
new file mode 100644
index 0000000..3168c6d
Binary files /dev/null and b/out/production/Competitive Programming/D23_Palindrome_Substring.class differ
diff --git a/out/production/Competitive Programming/D24_Coin_Change_Permutation_Memoized.class b/out/production/Competitive Programming/D24_Coin_Change_Permutation_Memoized.class
new file mode 100644
index 0000000..8a3cf4d
Binary files /dev/null and b/out/production/Competitive Programming/D24_Coin_Change_Permutation_Memoized.class differ
diff --git a/out/production/Competitive Programming/D24_Coin_Change_Permutations.class b/out/production/Competitive Programming/D24_Coin_Change_Permutations.class
new file mode 100644
index 0000000..4f14cac
Binary files /dev/null and b/out/production/Competitive Programming/D24_Coin_Change_Permutations.class differ
diff --git a/out/production/Competitive Programming/D24_Coin_Change_Tabulated.class b/out/production/Competitive Programming/D24_Coin_Change_Tabulated.class
new file mode 100644
index 0000000..2f09ec8
Binary files /dev/null and b/out/production/Competitive Programming/D24_Coin_Change_Tabulated.class differ
diff --git a/out/production/Competitive Programming/D24_Rod_Cutting.class b/out/production/Competitive Programming/D24_Rod_Cutting.class
new file mode 100644
index 0000000..9cccf66
Binary files /dev/null and b/out/production/Competitive Programming/D24_Rod_Cutting.class differ
diff --git a/out/production/Competitive Programming/D24_Rod_Cutting_Memoized.class b/out/production/Competitive Programming/D24_Rod_Cutting_Memoized.class
new file mode 100644
index 0000000..7ca535d
Binary files /dev/null and b/out/production/Competitive Programming/D24_Rod_Cutting_Memoized.class differ
diff --git a/out/production/Competitive Programming/D25_Egg_Drop_Memoized.class b/out/production/Competitive Programming/D25_Egg_Drop_Memoized.class
new file mode 100644
index 0000000..972c1bc
Binary files /dev/null and b/out/production/Competitive Programming/D25_Egg_Drop_Memoized.class differ
diff --git a/out/production/Competitive Programming/D25_Egg_Drop_Tabulated.class b/out/production/Competitive Programming/D25_Egg_Drop_Tabulated.class
new file mode 100644
index 0000000..688bd03
Binary files /dev/null and b/out/production/Competitive Programming/D25_Egg_Drop_Tabulated.class differ
diff --git a/out/production/Competitive Programming/D25_Friends_Pairing_Problem.class b/out/production/Competitive Programming/D25_Friends_Pairing_Problem.class
new file mode 100644
index 0000000..b931688
Binary files /dev/null and b/out/production/Competitive Programming/D25_Friends_Pairing_Problem.class differ
diff --git a/out/production/Competitive Programming/D25_Highway_Bikkboard_Problem.class b/out/production/Competitive Programming/D25_Highway_Bikkboard_Problem.class
new file mode 100644
index 0000000..1b3b0f1
Binary files /dev/null and b/out/production/Competitive Programming/D25_Highway_Bikkboard_Problem.class differ
diff --git a/out/production/Competitive Programming/D25_Longest_Bitonic_Subsequence.class b/out/production/Competitive Programming/D25_Longest_Bitonic_Subsequence.class
new file mode 100644
index 0000000..285968e
Binary files /dev/null and b/out/production/Competitive Programming/D25_Longest_Bitonic_Subsequence.class differ
diff --git a/out/production/Competitive Programming/D25_Matrix_Chain_Multiplication.class b/out/production/Competitive Programming/D25_Matrix_Chain_Multiplication.class
new file mode 100644
index 0000000..b3c9a49
Binary files /dev/null and b/out/production/Competitive Programming/D25_Matrix_Chain_Multiplication.class differ
diff --git a/out/production/Competitive Programming/D25_Matrix_Chain_Multiplication_Tabulated.class b/out/production/Competitive Programming/D25_Matrix_Chain_Multiplication_Tabulated.class
new file mode 100644
index 0000000..aa70134
Binary files /dev/null and b/out/production/Competitive Programming/D25_Matrix_Chain_Multiplication_Tabulated.class differ
diff --git a/out/production/Competitive Programming/D25_Minimum_Palindromic_Cut.class b/out/production/Competitive Programming/D25_Minimum_Palindromic_Cut.class
new file mode 100644
index 0000000..58623c0
Binary files /dev/null and b/out/production/Competitive Programming/D25_Minimum_Palindromic_Cut.class differ
diff --git a/out/production/Competitive Programming/D25_Minimum_Palindromic_Cut_Tabulated.class b/out/production/Competitive Programming/D25_Minimum_Palindromic_Cut_Tabulated.class
new file mode 100644
index 0000000..54e55ef
Binary files /dev/null and b/out/production/Competitive Programming/D25_Minimum_Palindromic_Cut_Tabulated.class differ
diff --git a/out/production/Competitive Programming/D26_2_KEYS_KEYBOARD_COPY_PASTE_Q.class b/out/production/Competitive Programming/D26_2_KEYS_KEYBOARD_COPY_PASTE_Q.class
new file mode 100644
index 0000000..37a6ad3
Binary files /dev/null and b/out/production/Competitive Programming/D26_2_KEYS_KEYBOARD_COPY_PASTE_Q.class differ
diff --git a/out/production/Competitive Programming/D26_4_Keys_Keyboard.class b/out/production/Competitive Programming/D26_4_Keys_Keyboard.class
new file mode 100644
index 0000000..a9525c9
Binary files /dev/null and b/out/production/Competitive Programming/D26_4_Keys_Keyboard.class differ
diff --git a/out/production/Competitive Programming/D26_Add_One_Row_To_Tree$TreeNode.class b/out/production/Competitive Programming/D26_Add_One_Row_To_Tree$TreeNode.class
new file mode 100644
index 0000000..b9e52a9
Binary files /dev/null and b/out/production/Competitive Programming/D26_Add_One_Row_To_Tree$TreeNode.class differ
diff --git a/out/production/Competitive Programming/D26_Add_One_Row_To_Tree.class b/out/production/Competitive Programming/D26_Add_One_Row_To_Tree.class
new file mode 100644
index 0000000..b9cb413
Binary files /dev/null and b/out/production/Competitive Programming/D26_Add_One_Row_To_Tree.class differ
diff --git a/out/production/Competitive Programming/D26_Ancestors_In_A_Binary_Tree$TreeNode.class b/out/production/Competitive Programming/D26_Ancestors_In_A_Binary_Tree$TreeNode.class
new file mode 100644
index 0000000..d77cf4e
Binary files /dev/null and b/out/production/Competitive Programming/D26_Ancestors_In_A_Binary_Tree$TreeNode.class differ
diff --git a/out/production/Competitive Programming/D26_Ancestors_In_A_Binary_Tree.class b/out/production/Competitive Programming/D26_Ancestors_In_A_Binary_Tree.class
new file mode 100644
index 0000000..2f1fa2b
Binary files /dev/null and b/out/production/Competitive Programming/D26_Ancestors_In_A_Binary_Tree.class differ
diff --git a/out/production/Competitive Programming/D26_Array_to_BST.class b/out/production/Competitive Programming/D26_Array_to_BST.class
new file mode 100644
index 0000000..79e9537
Binary files /dev/null and b/out/production/Competitive Programming/D26_Array_to_BST.class differ
diff --git a/out/production/Competitive Programming/D26_Average_Lvls_In_A_Binary_Tree$TreeNode.class b/out/production/Competitive Programming/D26_Average_Lvls_In_A_Binary_Tree$TreeNode.class
new file mode 100644
index 0000000..26a877c
Binary files /dev/null and b/out/production/Competitive Programming/D26_Average_Lvls_In_A_Binary_Tree$TreeNode.class differ
diff --git a/out/production/Competitive Programming/D26_Average_Lvls_In_A_Binary_Tree.class b/out/production/Competitive Programming/D26_Average_Lvls_In_A_Binary_Tree.class
new file mode 100644
index 0000000..b7fd71e
Binary files /dev/null and b/out/production/Competitive Programming/D26_Average_Lvls_In_A_Binary_Tree.class differ
diff --git a/out/production/Competitive Programming/D26_BST_Iterator$BST_Iterator.class b/out/production/Competitive Programming/D26_BST_Iterator$BST_Iterator.class
new file mode 100644
index 0000000..2ceec46
Binary files /dev/null and b/out/production/Competitive Programming/D26_BST_Iterator$BST_Iterator.class differ
diff --git a/out/production/Competitive Programming/D26_BST_Iterator$TreeNode.class b/out/production/Competitive Programming/D26_BST_Iterator$TreeNode.class
new file mode 100644
index 0000000..3ecfccf
Binary files /dev/null and b/out/production/Competitive Programming/D26_BST_Iterator$TreeNode.class differ
diff --git a/out/production/Competitive Programming/D26_BST_Iterator.class b/out/production/Competitive Programming/D26_BST_Iterator.class
new file mode 100644
index 0000000..1fdfecf
Binary files /dev/null and b/out/production/Competitive Programming/D26_BST_Iterator.class differ
diff --git a/out/production/Competitive Programming/D27_Binary_Search_Tree_to_Greater_Sum_Tree$TreeNode.class b/out/production/Competitive Programming/D27_Binary_Search_Tree_to_Greater_Sum_Tree$TreeNode.class
new file mode 100644
index 0000000..5929eec
Binary files /dev/null and b/out/production/Competitive Programming/D27_Binary_Search_Tree_to_Greater_Sum_Tree$TreeNode.class differ
diff --git a/out/production/Competitive Programming/D27_Binary_Search_Tree_to_Greater_Sum_Tree.class b/out/production/Competitive Programming/D27_Binary_Search_Tree_to_Greater_Sum_Tree.class
new file mode 100644
index 0000000..7eb5245
Binary files /dev/null and b/out/production/Competitive Programming/D27_Binary_Search_Tree_to_Greater_Sum_Tree.class differ
diff --git a/out/production/Competitive Programming/D27_Inordewr_Traversal$TreeNode.class b/out/production/Competitive Programming/D27_Inordewr_Traversal$TreeNode.class
new file mode 100644
index 0000000..3ae957f
Binary files /dev/null and b/out/production/Competitive Programming/D27_Inordewr_Traversal$TreeNode.class differ
diff --git a/out/production/Competitive Programming/D27_Inordewr_Traversal.class b/out/production/Competitive Programming/D27_Inordewr_Traversal.class
new file mode 100644
index 0000000..65a783a
Binary files /dev/null and b/out/production/Competitive Programming/D27_Inordewr_Traversal.class differ
diff --git a/out/production/Competitive Programming/D28_K_far$Node.class b/out/production/Competitive Programming/D28_K_far$Node.class
new file mode 100644
index 0000000..bb3b6e9
Binary files /dev/null and b/out/production/Competitive Programming/D28_K_far$Node.class differ
diff --git a/out/production/Competitive Programming/D28_K_far.class b/out/production/Competitive Programming/D28_K_far.class
new file mode 100644
index 0000000..38118f0
Binary files /dev/null and b/out/production/Competitive Programming/D28_K_far.class differ
diff --git a/out/production/Competitive Programming/D28_Longest_Increasing_Path$Node.class b/out/production/Competitive Programming/D28_Longest_Increasing_Path$Node.class
new file mode 100644
index 0000000..4bf1945
Binary files /dev/null and b/out/production/Competitive Programming/D28_Longest_Increasing_Path$Node.class differ
diff --git a/out/production/Competitive Programming/D28_Longest_Increasing_Path.class b/out/production/Competitive Programming/D28_Longest_Increasing_Path.class
new file mode 100644
index 0000000..2ce6490
Binary files /dev/null and b/out/production/Competitive Programming/D28_Longest_Increasing_Path.class differ
diff --git a/out/production/Competitive Programming/D29_Binary_Tree_Paths$TreeNode.class b/out/production/Competitive Programming/D29_Binary_Tree_Paths$TreeNode.class
new file mode 100644
index 0000000..8a9edf9
Binary files /dev/null and b/out/production/Competitive Programming/D29_Binary_Tree_Paths$TreeNode.class differ
diff --git a/out/production/Competitive Programming/D29_Binary_Tree_Paths.class b/out/production/Competitive Programming/D29_Binary_Tree_Paths.class
new file mode 100644
index 0000000..4b87aed
Binary files /dev/null and b/out/production/Competitive Programming/D29_Binary_Tree_Paths.class differ
diff --git a/out/production/Competitive Programming/D29_Lvl_Order_Bottom_UP$TreeNode.class b/out/production/Competitive Programming/D29_Lvl_Order_Bottom_UP$TreeNode.class
new file mode 100644
index 0000000..1248ff1
Binary files /dev/null and b/out/production/Competitive Programming/D29_Lvl_Order_Bottom_UP$TreeNode.class differ
diff --git a/out/production/Competitive Programming/D29_Lvl_Order_Bottom_UP.class b/out/production/Competitive Programming/D29_Lvl_Order_Bottom_UP.class
new file mode 100644
index 0000000..d1398c4
Binary files /dev/null and b/out/production/Competitive Programming/D29_Lvl_Order_Bottom_UP.class differ
diff --git a/out/production/Competitive Programming/D29_Lvl_Order_Traversal$TreeNode.class b/out/production/Competitive Programming/D29_Lvl_Order_Traversal$TreeNode.class
new file mode 100644
index 0000000..aea8aa7
Binary files /dev/null and b/out/production/Competitive Programming/D29_Lvl_Order_Traversal$TreeNode.class differ
diff --git a/out/production/Competitive Programming/D29_Lvl_Order_Traversal.class b/out/production/Competitive Programming/D29_Lvl_Order_Traversal.class
new file mode 100644
index 0000000..cce4a9d
Binary files /dev/null and b/out/production/Competitive Programming/D29_Lvl_Order_Traversal.class differ
diff --git a/out/production/Competitive Programming/D30_MORRIS$TreeNode.class b/out/production/Competitive Programming/D30_MORRIS$TreeNode.class
new file mode 100644
index 0000000..ea83811
Binary files /dev/null and b/out/production/Competitive Programming/D30_MORRIS$TreeNode.class differ
diff --git a/out/production/Competitive Programming/D30_MORRIS.class b/out/production/Competitive Programming/D30_MORRIS.class
new file mode 100644
index 0000000..70f2dd4
Binary files /dev/null and b/out/production/Competitive Programming/D30_MORRIS.class differ
diff --git a/out/production/Competitive Programming/D30_PreOrder_to_Inorder$TreeNode.class b/out/production/Competitive Programming/D30_PreOrder_to_Inorder$TreeNode.class
new file mode 100644
index 0000000..682cd4b
Binary files /dev/null and b/out/production/Competitive Programming/D30_PreOrder_to_Inorder$TreeNode.class differ
diff --git a/out/production/Competitive Programming/D30_PreOrder_to_Inorder.class b/out/production/Competitive Programming/D30_PreOrder_to_Inorder.class
new file mode 100644
index 0000000..949f9d8
Binary files /dev/null and b/out/production/Competitive Programming/D30_PreOrder_to_Inorder.class differ
diff --git a/out/production/Competitive Programming/D32_CountLeaves.class b/out/production/Competitive Programming/D32_CountLeaves.class
new file mode 100644
index 0000000..ee41a2b
Binary files /dev/null and b/out/production/Competitive Programming/D32_CountLeaves.class differ
diff --git a/out/production/Competitive Programming/D33_MirrorTree.class b/out/production/Competitive Programming/D33_MirrorTree.class
new file mode 100644
index 0000000..d83f631
Binary files /dev/null and b/out/production/Competitive Programming/D33_MirrorTree.class differ
diff --git a/out/production/Competitive Programming/D35_Count_Of_N_plus_i_equals_n_xor_i.class b/out/production/Competitive Programming/D35_Count_Of_N_plus_i_equals_n_xor_i.class
new file mode 100644
index 0000000..d66fbac
Binary files /dev/null and b/out/production/Competitive Programming/D35_Count_Of_N_plus_i_equals_n_xor_i.class differ
diff --git a/out/production/Competitive Programming/D35_GDG_SamsungProb_DeleteNode.class b/out/production/Competitive Programming/D35_GDG_SamsungProb_DeleteNode.class
new file mode 100644
index 0000000..632095c
Binary files /dev/null and b/out/production/Competitive Programming/D35_GDG_SamsungProb_DeleteNode.class differ
diff --git a/out/production/Competitive Programming/D35_Median_in_A_Stream.class b/out/production/Competitive Programming/D35_Median_in_A_Stream.class
new file mode 100644
index 0000000..1d53154
Binary files /dev/null and b/out/production/Competitive Programming/D35_Median_in_A_Stream.class differ
diff --git a/out/production/Competitive Programming/D35_SwitchNibbles.class b/out/production/Competitive Programming/D35_SwitchNibbles.class
new file mode 100644
index 0000000..1e6b0ca
Binary files /dev/null and b/out/production/Competitive Programming/D35_SwitchNibbles.class differ
diff --git a/out/production/Competitive Programming/D3_SplitList$Node.class b/out/production/Competitive Programming/D3_SplitList$Node.class
new file mode 100644
index 0000000..46e9146
Binary files /dev/null and b/out/production/Competitive Programming/D3_SplitList$Node.class differ
diff --git a/out/production/Competitive Programming/D3_SplitList.class b/out/production/Competitive Programming/D3_SplitList.class
new file mode 100644
index 0000000..d54a672
Binary files /dev/null and b/out/production/Competitive Programming/D3_SplitList.class differ
diff --git a/out/production/Competitive Programming/D3_addLL$Node.class b/out/production/Competitive Programming/D3_addLL$Node.class
new file mode 100644
index 0000000..ecedf6d
Binary files /dev/null and b/out/production/Competitive Programming/D3_addLL$Node.class differ
diff --git a/out/production/Competitive Programming/D3_addLL.class b/out/production/Competitive Programming/D3_addLL.class
new file mode 100644
index 0000000..5f8785a
Binary files /dev/null and b/out/production/Competitive Programming/D3_addLL.class differ
diff --git a/out/production/Competitive Programming/D3_addOne$Node.class b/out/production/Competitive Programming/D3_addOne$Node.class
new file mode 100644
index 0000000..258abe1
Binary files /dev/null and b/out/production/Competitive Programming/D3_addOne$Node.class differ
diff --git a/out/production/Competitive Programming/D3_addOne.class b/out/production/Competitive Programming/D3_addOne.class
new file mode 100644
index 0000000..1cc3f6f
Binary files /dev/null and b/out/production/Competitive Programming/D3_addOne.class differ
diff --git a/out/production/Competitive Programming/D3_adjacent_twins.class b/out/production/Competitive Programming/D3_adjacent_twins.class
new file mode 100644
index 0000000..9edda1e
Binary files /dev/null and b/out/production/Competitive Programming/D3_adjacent_twins.class differ
diff --git a/out/production/Competitive Programming/D3_cloneList$Node.class b/out/production/Competitive Programming/D3_cloneList$Node.class
new file mode 100644
index 0000000..aad5290
Binary files /dev/null and b/out/production/Competitive Programming/D3_cloneList$Node.class differ
diff --git a/out/production/Competitive Programming/D3_cloneList.class b/out/production/Competitive Programming/D3_cloneList.class
new file mode 100644
index 0000000..8396bb9
Binary files /dev/null and b/out/production/Competitive Programming/D3_cloneList.class differ
diff --git a/out/production/Competitive Programming/D3_consecutive_pairs_in_an_array.class b/out/production/Competitive Programming/D3_consecutive_pairs_in_an_array.class
new file mode 100644
index 0000000..51bba3a
Binary files /dev/null and b/out/production/Competitive Programming/D3_consecutive_pairs_in_an_array.class differ
diff --git a/out/production/Competitive Programming/D3_deleteKnode$Node.class b/out/production/Competitive Programming/D3_deleteKnode$Node.class
new file mode 100644
index 0000000..f724153
Binary files /dev/null and b/out/production/Competitive Programming/D3_deleteKnode$Node.class differ
diff --git a/out/production/Competitive Programming/D3_deleteKnode.class b/out/production/Competitive Programming/D3_deleteKnode.class
new file mode 100644
index 0000000..56a035d
Binary files /dev/null and b/out/production/Competitive Programming/D3_deleteKnode.class differ
diff --git a/out/production/Competitive Programming/D3_deleteMiddle$Node.class b/out/production/Competitive Programming/D3_deleteMiddle$Node.class
new file mode 100644
index 0000000..78808a3
Binary files /dev/null and b/out/production/Competitive Programming/D3_deleteMiddle$Node.class differ
diff --git a/out/production/Competitive Programming/D3_deleteMiddle.class b/out/production/Competitive Programming/D3_deleteMiddle.class
new file mode 100644
index 0000000..67212d1
Binary files /dev/null and b/out/production/Competitive Programming/D3_deleteMiddle.class differ
diff --git a/out/production/Competitive Programming/D3_in_place_linked_list_rearrangement$Node.class b/out/production/Competitive Programming/D3_in_place_linked_list_rearrangement$Node.class
new file mode 100644
index 0000000..73b3f62
Binary files /dev/null and b/out/production/Competitive Programming/D3_in_place_linked_list_rearrangement$Node.class differ
diff --git a/out/production/Competitive Programming/D3_in_place_linked_list_rearrangement.class b/out/production/Competitive Programming/D3_in_place_linked_list_rearrangement.class
new file mode 100644
index 0000000..5fab1dc
Binary files /dev/null and b/out/production/Competitive Programming/D3_in_place_linked_list_rearrangement.class differ
diff --git a/out/production/Competitive Programming/D3_is_linked_list_palindrome$Node.class b/out/production/Competitive Programming/D3_is_linked_list_palindrome$Node.class
new file mode 100644
index 0000000..46a4651
Binary files /dev/null and b/out/production/Competitive Programming/D3_is_linked_list_palindrome$Node.class differ
diff --git a/out/production/Competitive Programming/D3_is_linked_list_palindrome.class b/out/production/Competitive Programming/D3_is_linked_list_palindrome.class
new file mode 100644
index 0000000..02d3461
Binary files /dev/null and b/out/production/Competitive Programming/D3_is_linked_list_palindrome.class differ
diff --git a/out/production/Competitive Programming/D3_last_occurrence_of_an_item$Node.class b/out/production/Competitive Programming/D3_last_occurrence_of_an_item$Node.class
new file mode 100644
index 0000000..8d5c138
Binary files /dev/null and b/out/production/Competitive Programming/D3_last_occurrence_of_an_item$Node.class differ
diff --git a/out/production/Competitive Programming/D3_last_occurrence_of_an_item.class b/out/production/Competitive Programming/D3_last_occurrence_of_an_item.class
new file mode 100644
index 0000000..f36a20f
Binary files /dev/null and b/out/production/Competitive Programming/D3_last_occurrence_of_an_item.class differ
diff --git a/out/production/Competitive Programming/D3_long_parenthesis.class b/out/production/Competitive Programming/D3_long_parenthesis.class
new file mode 100644
index 0000000..6f3e7bc
Binary files /dev/null and b/out/production/Competitive Programming/D3_long_parenthesis.class differ
diff --git a/out/production/Competitive Programming/D3_merge_multiple_sorted_linked_lists$Node.class b/out/production/Competitive Programming/D3_merge_multiple_sorted_linked_lists$Node.class
new file mode 100644
index 0000000..0e31f19
Binary files /dev/null and b/out/production/Competitive Programming/D3_merge_multiple_sorted_linked_lists$Node.class differ
diff --git a/out/production/Competitive Programming/D3_merge_multiple_sorted_linked_lists.class b/out/production/Competitive Programming/D3_merge_multiple_sorted_linked_lists.class
new file mode 100644
index 0000000..0c30fba
Binary files /dev/null and b/out/production/Competitive Programming/D3_merge_multiple_sorted_linked_lists.class differ
diff --git a/out/production/Competitive Programming/D3_modular_node_in_a_linked_list$Node.class b/out/production/Competitive Programming/D3_modular_node_in_a_linked_list$Node.class
new file mode 100644
index 0000000..080fb94
Binary files /dev/null and b/out/production/Competitive Programming/D3_modular_node_in_a_linked_list$Node.class differ
diff --git a/out/production/Competitive Programming/D3_modular_node_in_a_linked_list.class b/out/production/Competitive Programming/D3_modular_node_in_a_linked_list.class
new file mode 100644
index 0000000..a285a66
Binary files /dev/null and b/out/production/Competitive Programming/D3_modular_node_in_a_linked_list.class differ
diff --git a/out/production/Competitive Programming/D3_modular_node_in_linkedlist$Node.class b/out/production/Competitive Programming/D3_modular_node_in_linkedlist$Node.class
new file mode 100644
index 0000000..2d4cd30
Binary files /dev/null and b/out/production/Competitive Programming/D3_modular_node_in_linkedlist$Node.class differ
diff --git a/out/production/Competitive Programming/D3_modular_node_in_linkedlist.class b/out/production/Competitive Programming/D3_modular_node_in_linkedlist.class
new file mode 100644
index 0000000..9e75ea7
Binary files /dev/null and b/out/production/Competitive Programming/D3_modular_node_in_linkedlist.class differ
diff --git a/out/production/Competitive Programming/D3_mustang.class b/out/production/Competitive Programming/D3_mustang.class
new file mode 100644
index 0000000..747c65a
Binary files /dev/null and b/out/production/Competitive Programming/D3_mustang.class differ
diff --git a/out/production/Competitive Programming/D3_negative_value_in_k_sized_window.class b/out/production/Competitive Programming/D3_negative_value_in_k_sized_window.class
new file mode 100644
index 0000000..d55c5cd
Binary files /dev/null and b/out/production/Competitive Programming/D3_negative_value_in_k_sized_window.class differ
diff --git a/out/production/Competitive Programming/D3_number_of_fetches$RecentFetch.class b/out/production/Competitive Programming/D3_number_of_fetches$RecentFetch.class
new file mode 100644
index 0000000..ad3a0ed
Binary files /dev/null and b/out/production/Competitive Programming/D3_number_of_fetches$RecentFetch.class differ
diff --git a/out/production/Competitive Programming/D3_number_of_fetches.class b/out/production/Competitive Programming/D3_number_of_fetches.class
new file mode 100644
index 0000000..ba96418
Binary files /dev/null and b/out/production/Competitive Programming/D3_number_of_fetches.class differ
diff --git a/out/production/Competitive Programming/D3_occurence_of_a_number_in_linked_list$Node.class b/out/production/Competitive Programming/D3_occurence_of_a_number_in_linked_list$Node.class
new file mode 100644
index 0000000..850e99f
Binary files /dev/null and b/out/production/Competitive Programming/D3_occurence_of_a_number_in_linked_list$Node.class differ
diff --git a/out/production/Competitive Programming/D3_occurence_of_a_number_in_linked_list.class b/out/production/Competitive Programming/D3_occurence_of_a_number_in_linked_list.class
new file mode 100644
index 0000000..a40d2ff
Binary files /dev/null and b/out/production/Competitive Programming/D3_occurence_of_a_number_in_linked_list.class differ
diff --git a/out/production/Competitive Programming/D3_partition_linked_list$Node.class b/out/production/Competitive Programming/D3_partition_linked_list$Node.class
new file mode 100644
index 0000000..3891df9
Binary files /dev/null and b/out/production/Competitive Programming/D3_partition_linked_list$Node.class differ
diff --git a/out/production/Competitive Programming/D3_partition_linked_list.class b/out/production/Competitive Programming/D3_partition_linked_list.class
new file mode 100644
index 0000000..d80e788
Binary files /dev/null and b/out/production/Competitive Programming/D3_partition_linked_list.class differ
diff --git a/out/production/Competitive Programming/D3_playing_the_game.class b/out/production/Competitive Programming/D3_playing_the_game.class
new file mode 100644
index 0000000..a952915
Binary files /dev/null and b/out/production/Competitive Programming/D3_playing_the_game.class differ
diff --git a/out/production/Competitive Programming/D3_remove_all_duplicate_nodes_in_sorted_linked_list$Node.class b/out/production/Competitive Programming/D3_remove_all_duplicate_nodes_in_sorted_linked_list$Node.class
new file mode 100644
index 0000000..646d520
Binary files /dev/null and b/out/production/Competitive Programming/D3_remove_all_duplicate_nodes_in_sorted_linked_list$Node.class differ
diff --git a/out/production/Competitive Programming/D3_remove_all_duplicate_nodes_in_sorted_linked_list.class b/out/production/Competitive Programming/D3_remove_all_duplicate_nodes_in_sorted_linked_list.class
new file mode 100644
index 0000000..4c658ad
Binary files /dev/null and b/out/production/Competitive Programming/D3_remove_all_duplicate_nodes_in_sorted_linked_list.class differ
diff --git a/out/production/Competitive Programming/D3_tiny_big_tiny.class b/out/production/Competitive Programming/D3_tiny_big_tiny.class
new file mode 100644
index 0000000..2c209cc
Binary files /dev/null and b/out/production/Competitive Programming/D3_tiny_big_tiny.class differ
diff --git a/out/production/Competitive Programming/D4_Expressions.class b/out/production/Competitive Programming/D4_Expressions.class
new file mode 100644
index 0000000..944365d
Binary files /dev/null and b/out/production/Competitive Programming/D4_Expressions.class differ
diff --git a/out/production/Competitive Programming/D4_bracket_position.class b/out/production/Competitive Programming/D4_bracket_position.class
new file mode 100644
index 0000000..87718ec
Binary files /dev/null and b/out/production/Competitive Programming/D4_bracket_position.class differ
diff --git a/out/production/Competitive Programming/D4_decoding_a_string.class b/out/production/Competitive Programming/D4_decoding_a_string.class
new file mode 100644
index 0000000..ee17ada
Binary files /dev/null and b/out/production/Competitive Programming/D4_decoding_a_string.class differ
diff --git a/out/production/Competitive Programming/D4_fun_with_asteroids.class b/out/production/Competitive Programming/D4_fun_with_asteroids.class
new file mode 100644
index 0000000..ba9cc58
Binary files /dev/null and b/out/production/Competitive Programming/D4_fun_with_asteroids.class differ
diff --git a/out/production/Competitive Programming/D4_next_greater_node$ListNode.class b/out/production/Competitive Programming/D4_next_greater_node$ListNode.class
new file mode 100644
index 0000000..92c6af5
Binary files /dev/null and b/out/production/Competitive Programming/D4_next_greater_node$ListNode.class differ
diff --git a/out/production/Competitive Programming/D4_next_greater_node.class b/out/production/Competitive Programming/D4_next_greater_node.class
new file mode 100644
index 0000000..b1c4cb7
Binary files /dev/null and b/out/production/Competitive Programming/D4_next_greater_node.class differ
diff --git a/out/production/Competitive Programming/D4_rotation_of_cards.class b/out/production/Competitive Programming/D4_rotation_of_cards.class
new file mode 100644
index 0000000..1bc5be2
Binary files /dev/null and b/out/production/Competitive Programming/D4_rotation_of_cards.class differ
diff --git a/out/production/Competitive Programming/D4_stack_with_frequency$FreqStack.class b/out/production/Competitive Programming/D4_stack_with_frequency$FreqStack.class
new file mode 100644
index 0000000..7e15ae7
Binary files /dev/null and b/out/production/Competitive Programming/D4_stack_with_frequency$FreqStack.class differ
diff --git a/out/production/Competitive Programming/D4_stack_with_frequency.class b/out/production/Competitive Programming/D4_stack_with_frequency.class
new file mode 100644
index 0000000..76bebe6
Binary files /dev/null and b/out/production/Competitive Programming/D4_stack_with_frequency.class differ
diff --git a/out/production/Competitive Programming/D4_stock_span_queries$StockSpanner.class b/out/production/Competitive Programming/D4_stock_span_queries$StockSpanner.class
new file mode 100644
index 0000000..f31ca9c
Binary files /dev/null and b/out/production/Competitive Programming/D4_stock_span_queries$StockSpanner.class differ
diff --git a/out/production/Competitive Programming/D4_stock_span_queries.class b/out/production/Competitive Programming/D4_stock_span_queries.class
new file mode 100644
index 0000000..8403e4b
Binary files /dev/null and b/out/production/Competitive Programming/D4_stock_span_queries.class differ
diff --git a/out/production/Competitive Programming/D4_unique_character.class b/out/production/Competitive Programming/D4_unique_character.class
new file mode 100644
index 0000000..86f00b7
Binary files /dev/null and b/out/production/Competitive Programming/D4_unique_character.class differ
diff --git a/out/production/Competitive Programming/D5_array_with_two_stacks$TwoStack.class b/out/production/Competitive Programming/D5_array_with_two_stacks$TwoStack.class
new file mode 100644
index 0000000..808accd
Binary files /dev/null and b/out/production/Competitive Programming/D5_array_with_two_stacks$TwoStack.class differ
diff --git a/out/production/Competitive Programming/D5_array_with_two_stacks.class b/out/production/Competitive Programming/D5_array_with_two_stacks.class
new file mode 100644
index 0000000..68ea9db
Binary files /dev/null and b/out/production/Competitive Programming/D5_array_with_two_stacks.class differ
diff --git a/out/production/Competitive Programming/D5_decode_string_at_index.class b/out/production/Competitive Programming/D5_decode_string_at_index.class
new file mode 100644
index 0000000..81d2714
Binary files /dev/null and b/out/production/Competitive Programming/D5_decode_string_at_index.class differ
diff --git a/out/production/Competitive Programming/D5_largest_min_pair.class b/out/production/Competitive Programming/D5_largest_min_pair.class
new file mode 100644
index 0000000..7452a72
Binary files /dev/null and b/out/production/Competitive Programming/D5_largest_min_pair.class differ
diff --git a/out/production/Competitive Programming/D5_largest_rectangle_in_a_matrix.class b/out/production/Competitive Programming/D5_largest_rectangle_in_a_matrix.class
new file mode 100644
index 0000000..2ec8be8
Binary files /dev/null and b/out/production/Competitive Programming/D5_largest_rectangle_in_a_matrix.class differ
diff --git a/out/production/Competitive Programming/D5_number_of_reversals.class b/out/production/Competitive Programming/D5_number_of_reversals.class
new file mode 100644
index 0000000..292fbe2
Binary files /dev/null and b/out/production/Competitive Programming/D5_number_of_reversals.class differ
diff --git a/out/production/Competitive Programming/D5_stack_supporting_min_operation.class b/out/production/Competitive Programming/D5_stack_supporting_min_operation.class
new file mode 100644
index 0000000..2ddcb29
Binary files /dev/null and b/out/production/Competitive Programming/D5_stack_supporting_min_operation.class differ
diff --git a/out/production/Competitive Programming/D6_absolute_canonical_path.class b/out/production/Competitive Programming/D6_absolute_canonical_path.class
new file mode 100644
index 0000000..51c1bec
Binary files /dev/null and b/out/production/Competitive Programming/D6_absolute_canonical_path.class differ
diff --git a/out/production/Competitive Programming/D6_celebrity_party.class b/out/production/Competitive Programming/D6_celebrity_party.class
new file mode 100644
index 0000000..a3175b5
Binary files /dev/null and b/out/production/Competitive Programming/D6_celebrity_party.class differ
diff --git a/out/production/Competitive Programming/D6_connecting_ropes.class b/out/production/Competitive Programming/D6_connecting_ropes.class
new file mode 100644
index 0000000..e07a701
Binary files /dev/null and b/out/production/Competitive Programming/D6_connecting_ropes.class differ
diff --git a/out/production/Competitive Programming/D6_height_of_closest_tower.class b/out/production/Competitive Programming/D6_height_of_closest_tower.class
new file mode 100644
index 0000000..ccfcd26
Binary files /dev/null and b/out/production/Competitive Programming/D6_height_of_closest_tower.class differ
diff --git a/out/production/Competitive Programming/D6_k_reverse_in_a_queue.class b/out/production/Competitive Programming/D6_k_reverse_in_a_queue.class
new file mode 100644
index 0000000..0ad2603
Binary files /dev/null and b/out/production/Competitive Programming/D6_k_reverse_in_a_queue.class differ
diff --git a/out/production/Competitive Programming/D6_manipulation_of_strings.class b/out/production/Competitive Programming/D6_manipulation_of_strings.class
new file mode 100644
index 0000000..ff5f395
Binary files /dev/null and b/out/production/Competitive Programming/D6_manipulation_of_strings.class differ
diff --git a/out/production/Competitive Programming/D6_queue_using_linkedlist$MyQueue.class b/out/production/Competitive Programming/D6_queue_using_linkedlist$MyQueue.class
new file mode 100644
index 0000000..4a8084d
Binary files /dev/null and b/out/production/Competitive Programming/D6_queue_using_linkedlist$MyQueue.class differ
diff --git a/out/production/Competitive Programming/D6_queue_using_linkedlist$QueueNode.class b/out/production/Competitive Programming/D6_queue_using_linkedlist$QueueNode.class
new file mode 100644
index 0000000..e7e6542
Binary files /dev/null and b/out/production/Competitive Programming/D6_queue_using_linkedlist$QueueNode.class differ
diff --git a/out/production/Competitive Programming/D6_queue_using_linkedlist.class b/out/production/Competitive Programming/D6_queue_using_linkedlist.class
new file mode 100644
index 0000000..84a199a
Binary files /dev/null and b/out/production/Competitive Programming/D6_queue_using_linkedlist.class differ
diff --git a/out/production/Competitive Programming/D6_remove_to_make_smallest.class b/out/production/Competitive Programming/D6_remove_to_make_smallest.class
new file mode 100644
index 0000000..f9d1535
Binary files /dev/null and b/out/production/Competitive Programming/D6_remove_to_make_smallest.class differ
diff --git a/out/production/Competitive Programming/D6_reversal_of_queue.class b/out/production/Competitive Programming/D6_reversal_of_queue.class
new file mode 100644
index 0000000..48b4ab6
Binary files /dev/null and b/out/production/Competitive Programming/D6_reversal_of_queue.class differ
diff --git a/out/production/Competitive Programming/D6_stack_using_linkedlist$MyStack.class b/out/production/Competitive Programming/D6_stack_using_linkedlist$MyStack.class
new file mode 100644
index 0000000..607fb3e
Binary files /dev/null and b/out/production/Competitive Programming/D6_stack_using_linkedlist$MyStack.class differ
diff --git a/out/production/Competitive Programming/D6_stack_using_linkedlist$StackNode.class b/out/production/Competitive Programming/D6_stack_using_linkedlist$StackNode.class
new file mode 100644
index 0000000..dfc0647
Binary files /dev/null and b/out/production/Competitive Programming/D6_stack_using_linkedlist$StackNode.class differ
diff --git a/out/production/Competitive Programming/D6_stack_using_linkedlist.class b/out/production/Competitive Programming/D6_stack_using_linkedlist.class
new file mode 100644
index 0000000..d776ed2
Binary files /dev/null and b/out/production/Competitive Programming/D6_stack_using_linkedlist.class differ
diff --git a/out/production/Competitive Programming/D7_are_linked_lists_identical$Node.class b/out/production/Competitive Programming/D7_are_linked_lists_identical$Node.class
new file mode 100644
index 0000000..940c7de
Binary files /dev/null and b/out/production/Competitive Programming/D7_are_linked_lists_identical$Node.class differ
diff --git a/out/production/Competitive Programming/D7_are_linked_lists_identical.class b/out/production/Competitive Programming/D7_are_linked_lists_identical.class
new file mode 100644
index 0000000..2b33673
Binary files /dev/null and b/out/production/Competitive Programming/D7_are_linked_lists_identical.class differ
diff --git a/out/production/Competitive Programming/D7_function_time.class b/out/production/Competitive Programming/D7_function_time.class
new file mode 100644
index 0000000..35937af
Binary files /dev/null and b/out/production/Competitive Programming/D7_function_time.class differ
diff --git a/out/production/Competitive Programming/D7_killing_process.class b/out/production/Competitive Programming/D7_killing_process.class
new file mode 100644
index 0000000..0528bfb
Binary files /dev/null and b/out/production/Competitive Programming/D7_killing_process.class differ
diff --git a/out/production/Competitive Programming/D7_making_parentheses_valid.class b/out/production/Competitive Programming/D7_making_parentheses_valid.class
new file mode 100644
index 0000000..0deaf50
Binary files /dev/null and b/out/production/Competitive Programming/D7_making_parentheses_valid.class differ
diff --git a/out/production/Competitive Programming/D7_nearmost_left_smaller_number.class b/out/production/Competitive Programming/D7_nearmost_left_smaller_number.class
new file mode 100644
index 0000000..5994a4e
Binary files /dev/null and b/out/production/Competitive Programming/D7_nearmost_left_smaller_number.class differ
diff --git a/out/production/Competitive Programming/D7_next_greater_circular.class b/out/production/Competitive Programming/D7_next_greater_circular.class
new file mode 100644
index 0000000..b442a9d
Binary files /dev/null and b/out/production/Competitive Programming/D7_next_greater_circular.class differ
diff --git a/out/production/Competitive Programming/D7_next_greater_in_other.class b/out/production/Competitive Programming/D7_next_greater_in_other.class
new file mode 100644
index 0000000..f2238b7
Binary files /dev/null and b/out/production/Competitive Programming/D7_next_greater_in_other.class differ
diff --git a/out/production/Competitive Programming/D7_operations_in_queue.class b/out/production/Competitive Programming/D7_operations_in_queue.class
new file mode 100644
index 0000000..72be478
Binary files /dev/null and b/out/production/Competitive Programming/D7_operations_in_queue.class differ
diff --git a/out/production/Competitive Programming/D7_parsing_ternary_expression.class b/out/production/Competitive Programming/D7_parsing_ternary_expression.class
new file mode 100644
index 0000000..43c86e0
Binary files /dev/null and b/out/production/Competitive Programming/D7_parsing_ternary_expression.class differ
diff --git a/out/production/Competitive Programming/D7_queue_using_array$MyQueue.class b/out/production/Competitive Programming/D7_queue_using_array$MyQueue.class
new file mode 100644
index 0000000..7300ded
Binary files /dev/null and b/out/production/Competitive Programming/D7_queue_using_array$MyQueue.class differ
diff --git a/out/production/Competitive Programming/D7_queue_using_array.class b/out/production/Competitive Programming/D7_queue_using_array.class
new file mode 100644
index 0000000..813962d
Binary files /dev/null and b/out/production/Competitive Programming/D7_queue_using_array.class differ
diff --git a/out/production/Competitive Programming/D7_queue_using_stacks$queUsingStack.class b/out/production/Competitive Programming/D7_queue_using_stacks$queUsingStack.class
new file mode 100644
index 0000000..5298172
Binary files /dev/null and b/out/production/Competitive Programming/D7_queue_using_stacks$queUsingStack.class differ
diff --git a/out/production/Competitive Programming/D7_queue_using_stacks.class b/out/production/Competitive Programming/D7_queue_using_stacks.class
new file mode 100644
index 0000000..d797fb2
Binary files /dev/null and b/out/production/Competitive Programming/D7_queue_using_stacks.class differ
diff --git a/out/production/Competitive Programming/D7_remove_digits_that_are_repeated.class b/out/production/Competitive Programming/D7_remove_digits_that_are_repeated.class
new file mode 100644
index 0000000..be47eb5
Binary files /dev/null and b/out/production/Competitive Programming/D7_remove_digits_that_are_repeated.class differ
diff --git a/out/production/Competitive Programming/D7_rotten_tomatoes$Helper.class b/out/production/Competitive Programming/D7_rotten_tomatoes$Helper.class
new file mode 100644
index 0000000..01b8b6a
Binary files /dev/null and b/out/production/Competitive Programming/D7_rotten_tomatoes$Helper.class differ
diff --git a/out/production/Competitive Programming/D7_rotten_tomatoes.class b/out/production/Competitive Programming/D7_rotten_tomatoes.class
new file mode 100644
index 0000000..ae430f7
Binary files /dev/null and b/out/production/Competitive Programming/D7_rotten_tomatoes.class differ
diff --git a/out/production/Competitive Programming/D7_score_of_the_string.class b/out/production/Competitive Programming/D7_score_of_the_string.class
new file mode 100644
index 0000000..a76c98a
Binary files /dev/null and b/out/production/Competitive Programming/D7_score_of_the_string.class differ
diff --git a/out/production/Competitive Programming/D7_sorted_stack.class b/out/production/Competitive Programming/D7_sorted_stack.class
new file mode 100644
index 0000000..d0b31dc
Binary files /dev/null and b/out/production/Competitive Programming/D7_sorted_stack.class differ
diff --git a/out/production/Competitive Programming/D7_stack_implementation_with_two_queues.class b/out/production/Competitive Programming/D7_stack_implementation_with_two_queues.class
new file mode 100644
index 0000000..95943c1
Binary files /dev/null and b/out/production/Competitive Programming/D7_stack_implementation_with_two_queues.class differ
diff --git a/out/production/Competitive Programming/D7_stack_using_array$MyStack.class b/out/production/Competitive Programming/D7_stack_using_array$MyStack.class
new file mode 100644
index 0000000..e22290d
Binary files /dev/null and b/out/production/Competitive Programming/D7_stack_using_array$MyStack.class differ
diff --git a/out/production/Competitive Programming/D7_stack_using_array.class b/out/production/Competitive Programming/D7_stack_using_array.class
new file mode 100644
index 0000000..c461910
Binary files /dev/null and b/out/production/Competitive Programming/D7_stack_using_array.class differ
diff --git a/out/production/Competitive Programming/D7_stack_validation.class b/out/production/Competitive Programming/D7_stack_validation.class
new file mode 100644
index 0000000..a28664e
Binary files /dev/null and b/out/production/Competitive Programming/D7_stack_validation.class differ
diff --git a/out/production/Competitive Programming/D7_valid_braces.class b/out/production/Competitive Programming/D7_valid_braces.class
new file mode 100644
index 0000000..708bf32
Binary files /dev/null and b/out/production/Competitive Programming/D7_valid_braces.class differ
diff --git a/out/production/Competitive Programming/D8_Notebandi.class b/out/production/Competitive Programming/D8_Notebandi.class
new file mode 100644
index 0000000..a621253
Binary files /dev/null and b/out/production/Competitive Programming/D8_Notebandi.class differ
diff --git a/out/production/Competitive Programming/D8_Rat_in_jungle.class b/out/production/Competitive Programming/D8_Rat_in_jungle.class
new file mode 100644
index 0000000..76a1330
Binary files /dev/null and b/out/production/Competitive Programming/D8_Rat_in_jungle.class differ
diff --git a/out/production/Competitive Programming/D8_double_pair_array.class b/out/production/Competitive Programming/D8_double_pair_array.class
new file mode 100644
index 0000000..fa16872
Binary files /dev/null and b/out/production/Competitive Programming/D8_double_pair_array.class differ
diff --git a/out/production/Competitive Programming/D8_find_duplicate_in_system.class b/out/production/Competitive Programming/D8_find_duplicate_in_system.class
new file mode 100644
index 0000000..6db5a4b
Binary files /dev/null and b/out/production/Competitive Programming/D8_find_duplicate_in_system.class differ
diff --git a/out/production/Competitive Programming/D8_help_pepman.class b/out/production/Competitive Programming/D8_help_pepman.class
new file mode 100644
index 0000000..50ef366
Binary files /dev/null and b/out/production/Competitive Programming/D8_help_pepman.class differ
diff --git a/out/production/Competitive Programming/D8_incomplete_array.class b/out/production/Competitive Programming/D8_incomplete_array.class
new file mode 100644
index 0000000..61836c0
Binary files /dev/null and b/out/production/Competitive Programming/D8_incomplete_array.class differ
diff --git a/out/production/Competitive Programming/D8_ipo$CapitalComparator.class b/out/production/Competitive Programming/D8_ipo$CapitalComparator.class
new file mode 100644
index 0000000..28607e9
Binary files /dev/null and b/out/production/Competitive Programming/D8_ipo$CapitalComparator.class differ
diff --git a/out/production/Competitive Programming/D8_ipo$ProfitComparator.class b/out/production/Competitive Programming/D8_ipo$ProfitComparator.class
new file mode 100644
index 0000000..7a63274
Binary files /dev/null and b/out/production/Competitive Programming/D8_ipo$ProfitComparator.class differ
diff --git a/out/production/Competitive Programming/D8_ipo$Project.class b/out/production/Competitive Programming/D8_ipo$Project.class
new file mode 100644
index 0000000..3dd74b7
Binary files /dev/null and b/out/production/Competitive Programming/D8_ipo$Project.class differ
diff --git a/out/production/Competitive Programming/D8_ipo.class b/out/production/Competitive Programming/D8_ipo.class
new file mode 100644
index 0000000..b9ec036
Binary files /dev/null and b/out/production/Competitive Programming/D8_ipo.class differ
diff --git a/out/production/Competitive Programming/D8_is_isogram.class b/out/production/Competitive Programming/D8_is_isogram.class
new file mode 100644
index 0000000..343b37b
Binary files /dev/null and b/out/production/Competitive Programming/D8_is_isogram.class differ
diff --git a/out/production/Competitive Programming/D9_check_AP.class b/out/production/Competitive Programming/D9_check_AP.class
new file mode 100644
index 0000000..e2644e0
Binary files /dev/null and b/out/production/Competitive Programming/D9_check_AP.class differ
diff --git a/out/production/Competitive Programming/D9_completing_tasks.class b/out/production/Competitive Programming/D9_completing_tasks.class
new file mode 100644
index 0000000..c4d2766
Binary files /dev/null and b/out/production/Competitive Programming/D9_completing_tasks.class differ
diff --git a/out/production/Competitive Programming/D9_is_frequency_equal.class b/out/production/Competitive Programming/D9_is_frequency_equal.class
new file mode 100644
index 0000000..fc2f515
Binary files /dev/null and b/out/production/Competitive Programming/D9_is_frequency_equal.class differ
diff --git a/out/production/Competitive Programming/D9_pair_sum_divisibility.class b/out/production/Competitive Programming/D9_pair_sum_divisibility.class
new file mode 100644
index 0000000..f88db48
Binary files /dev/null and b/out/production/Competitive Programming/D9_pair_sum_divisibility.class differ
diff --git a/out/production/Competitive Programming/D9_sweets_festival.class b/out/production/Competitive Programming/D9_sweets_festival.class
new file mode 100644
index 0000000..644f8ea
Binary files /dev/null and b/out/production/Competitive Programming/D9_sweets_festival.class differ
diff --git a/out/production/Competitive Programming/GFG_01_Ugly_Numbers.class b/out/production/Competitive Programming/GFG_01_Ugly_Numbers.class
new file mode 100644
index 0000000..e6d4fe6
Binary files /dev/null and b/out/production/Competitive Programming/GFG_01_Ugly_Numbers.class differ
diff --git a/out/production/Competitive Programming/GFG_02_Super_Ugly_Numbers.class b/out/production/Competitive Programming/GFG_02_Super_Ugly_Numbers.class
new file mode 100644
index 0000000..f88ba8a
Binary files /dev/null and b/out/production/Competitive Programming/GFG_02_Super_Ugly_Numbers.class differ
diff --git a/out/production/Competitive Programming/GFG_03_Max_Size_ISub_Matrix_with_all_1s_in_binary_matrix.class b/out/production/Competitive Programming/GFG_03_Max_Size_ISub_Matrix_with_all_1s_in_binary_matrix.class
new file mode 100644
index 0000000..bfe264b
Binary files /dev/null and b/out/production/Competitive Programming/GFG_03_Max_Size_ISub_Matrix_with_all_1s_in_binary_matrix.class differ
diff --git a/out/production/Competitive Programming/GFG_04_Longest_Increasng_Sequence.class b/out/production/Competitive Programming/GFG_04_Longest_Increasng_Sequence.class
new file mode 100644
index 0000000..9e5728f
Binary files /dev/null and b/out/production/Competitive Programming/GFG_04_Longest_Increasng_Sequence.class differ
diff --git a/out/production/Competitive Programming/Helper.class b/out/production/Competitive Programming/Helper.class
new file mode 100644
index 0000000..f74a9c9
Binary files /dev/null and b/out/production/Competitive Programming/Helper.class differ
diff --git a/out/production/Competitive Programming/IB_Iterative_PostOrder$node.class b/out/production/Competitive Programming/IB_Iterative_PostOrder$node.class
new file mode 100644
index 0000000..aa42bfb
Binary files /dev/null and b/out/production/Competitive Programming/IB_Iterative_PostOrder$node.class differ
diff --git a/out/production/Competitive Programming/IB_Iterative_PostOrder.class b/out/production/Competitive Programming/IB_Iterative_PostOrder.class
new file mode 100644
index 0000000..f3a0791
Binary files /dev/null and b/out/production/Competitive Programming/IB_Iterative_PostOrder.class differ
diff --git a/out/production/Competitive Programming/IB_Vertical_Order_Traversal.class b/out/production/Competitive Programming/IB_Vertical_Order_Traversal.class
new file mode 100644
index 0000000..306ff50
Binary files /dev/null and b/out/production/Competitive Programming/IB_Vertical_Order_Traversal.class differ
diff --git a/out/production/Competitive Programming/InterviewBIT_Inversions.class b/out/production/Competitive Programming/InterviewBIT_Inversions.class
new file mode 100644
index 0000000..481303e
Binary files /dev/null and b/out/production/Competitive Programming/InterviewBIT_Inversions.class differ
diff --git a/out/production/Competitive Programming/InterviewBit_Min_Step_Infinite_Grid.class b/out/production/Competitive Programming/InterviewBit_Min_Step_Infinite_Grid.class
new file mode 100644
index 0000000..399bcae
Binary files /dev/null and b/out/production/Competitive Programming/InterviewBit_Min_Step_Infinite_Grid.class differ
diff --git a/out/production/Competitive Programming/META-INF/Competitive Programming.kotlin_module b/out/production/Competitive Programming/META-INF/Competitive Programming.kotlin_module
new file mode 100644
index 0000000..8fb6019
Binary files /dev/null and b/out/production/Competitive Programming/META-INF/Competitive Programming.kotlin_module differ
diff --git a/out/production/Competitive Programming/Node.class b/out/production/Competitive Programming/Node.class
new file mode 100644
index 0000000..d01e8bc
Binary files /dev/null and b/out/production/Competitive Programming/Node.class differ
diff --git a/out/production/Competitive Programming/TNode.class b/out/production/Competitive Programming/TNode.class
new file mode 100644
index 0000000..3f6f8b9
Binary files /dev/null and b/out/production/Competitive Programming/TNode.class differ
diff --git a/out/production/Competitive Programming/TreeNode.class b/out/production/Competitive Programming/TreeNode.class
new file mode 100644
index 0000000..4c5ee7c
Binary files /dev/null and b/out/production/Competitive Programming/TreeNode.class differ
diff --git a/out/production/Competitive Programming/sample.class b/out/production/Competitive Programming/sample.class
new file mode 100644
index 0000000..068657a
Binary files /dev/null and b/out/production/Competitive Programming/sample.class differ