diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000..6b19b25
Binary files /dev/null and b/.DS_Store differ
diff --git a/FCFS/fcfs.py b/Algorithm/FCFS/fcfs.py
similarity index 100%
rename from FCFS/fcfs.py
rename to Algorithm/FCFS/fcfs.py
diff --git a/FCFS/question.txt b/Algorithm/FCFS/question.txt
similarity index 100%
rename from FCFS/question.txt
rename to Algorithm/FCFS/question.txt
diff --git a/Algorithm/Floodfill/Problem_statement.txt b/Algorithm/Floodfill/Problem_statement.txt
new file mode 100644
index 0000000..f36d41a
--- /dev/null
+++ b/Algorithm/Floodfill/Problem_statement.txt
@@ -0,0 +1,28 @@
+For those who don’t like regular images, ASCII Maps Inc. has created maps that are fully printable ASCII characters. Each map is a rectangular grid of lowercase English letters, where each letter stands for various locations. In particular, ‘w’ stands for water and the other 25 letters represent various different land locations. For this problem, we are interested in counting the number of bodies of water on a given ASCII map. A body of water is a maximal set of contiguous grid squares on the ASCII map where each square in the body of water shares a boundary with at least one other square in the body of water. Thus, for two grid squares to be part of the same body of water, one must be above, below, to the left, or to the right of the other grid square.
+Input
+The first line of input consists of two space separated integers, r (1=r=50) and c (1=c=50), the number of rows and columns, respectively for the input map. The next r lines will each contain c lowercase English letters, representing the corresponding row of the input map.
+
+Output
+On a line by itself, output the number of bodies of water in the input map.
+
+Sample test case 1:
+
+Input:
+5 6
+waaaww
+wawawc
+bbbbwc
+wwwwww
+dddddd
+
+Output:
+3
+
+Sample test case 2:
+Input:
+2 8
+wxwxwxwx
+xwxwxwxw
+
+Output:
+8
diff --git a/Algorithm/Floodfill/solution.java b/Algorithm/Floodfill/solution.java
new file mode 100644
index 0000000..a043c94
--- /dev/null
+++ b/Algorithm/Floodfill/solution.java
@@ -0,0 +1,53 @@
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class water {
+public static void main(String[] args){
+Scanner kb=new Scanner(System.in);
+System.out.println("Enter the dimensions of the map:");
+int n=kb.nextInt();
+int m=kb.nextInt();
+System.out.println("Enter the map:");
+char[][] x=new char[n][m];
+for(int i=0;i<n;i++)
+x[i]=kb.next().toCharArray();
+String str="";
+int count=0;
+for(int i=0;i<n;i++){
+for(int k=0;k<m;k++){
+if(x[i][k]!='#'&&x[i][k]=='w'){
+fillGrid(x, i, k);
+display(x);
+count++;
+System.out.println(count);
+}
+}
+}
+if(count==1)
+System.out.println("\nThere is "+count+" body of water.");
+else
+System.out.println("\nThere are "+count+" bodies of water.");
+}
+public static void fillGrid(char[][] arr, int r, int c) {
+if (inBounds(arr,r,c)&&arr[r][c] == 'w'){
+arr[r][c] = '#';
+fillGrid(arr,r + 1, c);
+fillGrid(arr,r - 1, c);
+fillGrid(arr,r, c + 1);
+fillGrid(arr,r, c - 1);
+}
+}
+
+public static boolean inBounds(char[][] arr, int r, int c) {
+return r>=0&&r<arr.length&&c>=0&&c<arr[0].length;
+}
+
+public static void display(char[][] arr){
+System.out.println("\nGrid: ");
+for (int i = 0; i < arr.length; i++){
+for (int j = 0; j < arr[i].length; j++)
+System.out.print(arr[i][j]);
+System.out.println();
+}
+}
+}
diff --git a/Algorithm/Floodfill/solution.py b/Algorithm/Floodfill/solution.py
new file mode 100644
index 0000000..319d3f7
--- /dev/null
+++ b/Algorithm/Floodfill/solution.py
@@ -0,0 +1,54 @@
+# Python3 program to implement 
+# flood fill algorithm 
+
+# Dimentions of paint screen 
+M = 8
+N = 8
+
+# A recursive function to replace 
+# previous color 'prevC' at '(x, y)' 
+# and all surrounding pixels of (x, y) 
+# with new color 'newC' and 
+def floodFillUtil(screen, x, y, prevC, newC): 
+	
+	# Base cases 
+	if (x < 0 or x >= M or y < 0 or
+		y >= N or screen[x][y] != prevC or
+		screen[x][y] == newC): 
+		return
+
+	# Replace the color at (x, y) 
+	screen[x][y] = newC 
+
+	# Recur for north, east, south and west 
+	floodFillUtil(screen, x + 1, y, prevC, newC) 
+	floodFillUtil(screen, x - 1, y, prevC, newC) 
+	floodFillUtil(screen, x, y + 1, prevC, newC) 
+	floodFillUtil(screen, x, y - 1, prevC, newC) 
+
+# It mainly finds the previous color on (x, y) and 
+# calls floodFillUtil() 
+def floodFill(screen, x, y, newC): 
+	prevC = screen[x][y] 
+	floodFillUtil(screen, x, y, prevC, newC) 
+
+# Driver Code 
+screen = [[1, 1, 1, 1, 1, 1, 1, 1], 
+		[1, 1, 1, 1, 1, 1, 0, 0], 
+		[1, 0, 0, 1, 1, 0, 1, 1], 
+		[1, 2, 2, 2, 2, 0, 1, 0], 
+		[1, 1, 1, 2, 2, 0, 1, 0], 
+		[1, 1, 1, 2, 2, 2, 2, 0], 
+		[1, 1, 1, 1, 1, 2, 1, 1], 
+		[1, 1, 1, 1, 1, 2, 2, 1]] 
+
+x = 4
+y = 4
+newC = 3
+floodFill(screen, x, y, newC) 
+
+print ("Updated screen after call to floodFill:") 
+for i in range(M): 
+	for j in range(N): 
+		print(screen[i][j], end = ' ') 
+	print() 
diff --git a/Algorithm/Josephus's Problem/josephus.java b/Algorithm/Josephus's Problem/josephus.java
new file mode 100644
index 0000000..437582a
--- /dev/null
+++ b/Algorithm/Josephus's Problem/josephus.java	
@@ -0,0 +1,21 @@
+import java.io.*;
+import java.util.Scanner; 
+  
+class Josephus { 
+  
+static int josephus(int n, int k) 
+{ 
+if (n == 1) 
+    return 1; 
+else
+    return (josephus(n - 1, k) + k-1) % n + 1; 
+} 
+  
+  public static void main(String[] args) 
+{ 
+	Scanner s = new Scnner(System.in);
+int n = s.nextInt(); 
+int k = s.nextInt(); 
+System.out.println("The chosen place is " + josephus(n, k)); 
+} 
+} 
\ No newline at end of file
diff --git a/Algorithm/Josephus's Problem/question.txt b/Algorithm/Josephus's Problem/question.txt
new file mode 100644
index 0000000..b90a2be
--- /dev/null
+++ b/Algorithm/Josephus's Problem/question.txt	
@@ -0,0 +1,5 @@
+There are n people standing in a circle waiting to be executed. The counting out begins at some point in the circle and proceeds around the circle in a fixed direction. In each step, a certain number of people are skipped and the next person is executed. The elimination proceeds around the circle (which is becoming smaller and smaller as the executed people are removed), until only the last person remains, who is given freedom. Given the total number of persons n and a number k which indicates that k-1 persons are skipped and kth person is killed in circle. The task is to choose the place in the initial circle so that you are the last one remaining and so survive.
+
+Example, if n = 5 and k = 2, then the safe position is 3. Firstly, the person at position 2 is killed, then person at position 4 is killed, then person at position 1 is killed. Finally, the person at position 5 is killed. So the person at position 3 survives.
+
+If n = 7 and k = 3, then the safe position is 4. The persons at positions 3, 6, 2, 7, 5, 1 are killed in order, and person at position 4 survives.
\ No newline at end of file
diff --git a/Algorithm/Kadane's Algorithm/kadane.c b/Algorithm/Kadane's Algorithm/kadane.c
new file mode 100644
index 0000000..4b19327
--- /dev/null
+++ b/Algorithm/Kadane's Algorithm/kadane.c	
@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <limits.h>
+
+int maxSubarraySum(int a[], int l) {
+	int max = INT_MIN, max_here = 0;
+
+	for (int i = 0; i < l; i++) {
+		max_here = max_here + a[i];
+		if (max < max_here) max = max_here;
+		if (max_here < 0) max_here = 0;
+	}
+
+	return max;
+}
+
+// int maxSubarraySum(int a[], int l) {
+// 	int max = a[0], max_here = a[0];
+
+// 	for (int i = 0; i < l; i++) {
+// 		if (max_here > 0) max_here += a[i];
+// 		else max_here = a[i];
+// 		if (max_here > max) max = max_here;
+// 	}
+
+// 	return max;
+// }
+
+int main(int argc, char *argv[]) {
+	int arr[] = {-2, -3, 4, -1, -2, 1, 5, -3};
+	int l = sizeof(arr) / sizeof(int);
+
+	int m = maxSubarraySum(arr, l);
+
+	printf("%d is the max subarray sum\n", m);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/Algorithm/Kadane's Algorithm/kadane.cpp b/Algorithm/Kadane's Algorithm/kadane.cpp
new file mode 100644
index 0000000..0101507
--- /dev/null
+++ b/Algorithm/Kadane's Algorithm/kadane.cpp	
@@ -0,0 +1,27 @@
+#include<iostream>
+#include <bits/stdc++.h>
+using namespace std;
+
+int maxSubarraySum(vector<int> a, int l) {
+	int max = INT_MIN, max_here = 0;
+
+	for (int i = 0; i < l; i++) {
+		max_here = max_here + a[i];
+		if (max < max_here) max = max_here;
+		if (max_here < 0) max_here = 0;
+	}
+
+	return max;
+}
+
+
+int main() {
+	vector<int> arr({-2, -3, 4, -1, -2, 1, 5, -3});
+	int l = arr.size();
+
+	int m = maxSubarraySum(arr, l);
+
+	cout<<m<<" is the max subarray sum\n";
+
+	return 0;
+}
diff --git a/Algorithm/Kadane's Algorithm/kadane.py b/Algorithm/Kadane's Algorithm/kadane.py
new file mode 100644
index 0000000..1c8ceea
--- /dev/null
+++ b/Algorithm/Kadane's Algorithm/kadane.py	
@@ -0,0 +1,21 @@
+def maxSubarraySum(a,  l):
+	_max = -999999
+	max_here = 0
+	for i in range(l): 
+		max_here = max_here + a[i]
+		if (_max < max_here):
+		 _max = max_here
+		if (max_here < 0):
+		 max_here = 0
+	
+
+	return _max
+
+
+if __name__ == '__main__': 
+	arr=[-2, -3, 4, -1, -2, 1, 5, -3]
+	l=len(arr)
+	m = maxSubarraySum(arr, l)
+	print(m," is the max subarray sum")
+
+
diff --git a/Algorithm/Kadane's Algorithm/problem.txt b/Algorithm/Kadane's Algorithm/problem.txt
new file mode 100644
index 0000000..1f05316
--- /dev/null
+++ b/Algorithm/Kadane's Algorithm/problem.txt	
@@ -0,0 +1,5 @@
+Problem:
+Find out the maximum continuous subarray sum in linear time
+
+Solution:
+Kadane's algorithm can calculate the maximum subarray sum in linear time
diff --git a/Algorithm/hot_potato/hot_potato.cpp b/Algorithm/hot_potato/hot_potato.cpp
new file mode 100644
index 0000000..46f73b7
--- /dev/null
+++ b/Algorithm/hot_potato/hot_potato.cpp
@@ -0,0 +1,193 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+template<class Item>
+class LinearList{
+       private:
+              int MaxSize;
+              Item *element;    // 1D dynamic array
+              int len;
+       public:
+              /* Default constructor. 
+               * Should create an empty list that not contain any elements*/
+              LinearList()
+              {
+                     element=nullptr;
+                     len=0;
+              };
+
+              /* This constructor should create a list containing MaxSize elements. You can intialize the elements with any values.*/
+              LinearList(const int& MaxListSize)
+              {
+                     MaxSize=MaxListSize;
+                     element = new Item[MaxSize];
+                     len=0;
+                     /*for(int i=0;i<MaxSize;i++)
+                     {
+                            cout << element[i] << endl;
+                     }*/
+
+              };
+
+              /* Destructor. 
+               * Must free all the memory contained by the list */
+              ~LinearList(){};
+
+              /* Indexing operator.
+               * It should behave the same way array indexing does. i.e,
+               * LinearList L;
+               * L[0] should refer to the first element;
+               * L[1] to the second element and so on.
+               * */
+              Item& operator[](const int& i)
+              {
+                     return element[i];
+              }; //return i'th element of list
+              
+              /* Returns true if the list is empty, false otherwise.
+               * */
+              bool isEmpty()
+              {
+                     if(len==0)
+                     {
+                            return true;
+                     }
+                     else
+                     {
+                            return false;
+                     }
+              };
+
+              /* Returns the actual length (number of elements) in the list.
+               * */
+              int  length()
+              {
+                     return len;
+              };     
+
+              /* Returns the maximum size of the list.
+               * */
+              int  maxSize()
+              {
+                     return maxSize;
+              };
+
+              /* Returns the k-th element of the list. 
+               * */
+              Item  returnListElement(const int k)
+              {
+                     return element[k-1];
+              };
+              /* Set x to the k-th element and 
+               * return true if k-th element is present otherwise return false.
+               * */
+              bool find(const int k, Item& x)
+              {
+                     if(x==element[k-1])
+                     {
+                            return true;
+                     }
+                     else
+                     {
+                            
+                            return false;
+                     }
+              };
+
+              /* Search for x and
+               * return the position if found, else return 0.
+               * */
+              int  search(Item& x)
+              {
+                     for(int i=0;i<len;i++)
+                     {
+                            if(element[i]==x)
+                            {
+                                   return i+1;
+                            }
+                     }
+                     return 0;
+
+              };
+
+              /* Set x to the k-th element and delete that k-th element.
+               * */
+              void  deleteElement(const int  k, Item& x)
+              {
+                     x=element[k-1];
+                     for(int i=k;i<len;i++)
+                     {
+                            element[i-1]=element[i];
+                     }
+                     len=len-1;
+              };
+
+              /* Insert x after k-th element.
+               * */
+              void  insert(const int  k, Item& x)
+              {
+                     for(int i=len;i>k;i--)
+                     {
+                            element[i]=element[i-1];
+                     }
+                     element[k]=x;
+                     len=len+1;
+              };
+
+                                   
+};
+
+int main()
+{
+  LinearList<int> a(250);
+  int k,n,i,j,temp;
+  cout << "Enter number of children: ";
+  cin >> n;
+  cout << "Enter elimination rule: ";
+  cin >> i;
+  for(j=0;j<n;j++)
+  {
+    temp=j+1;
+    a.insert(j,temp);
+  }
+  for(j=0;j<n;j++)
+  {
+    cout << a[j] << " ";
+  }
+  cout << endl;
+  j=1;
+  k=0;
+  while(1)
+  {
+    if(a.length()==1)
+    {
+      break;
+    }
+    if(j%i!=0)
+    {
+      a.deleteElement(1,temp);
+      a.insert(a.length(),temp);
+      j++;
+    }
+    else
+    {
+      /*cout << j << " " << i << endl;
+      for(k=0;k<a.length();k++)
+      {
+        cout << a[k] << " ";
+      }
+      cout << endl;*/
+      a.deleteElement(1,temp);
+      cout << "person at position " << temp << " is removed" << endl;
+      j++;
+    }
+
+  }
+  cout << "Hence person at position ";
+  for(j=0;j<a.length();j++)
+  {
+    cout << a[j] << " ";
+  }
+  cout << "survives." << endl;
+
+}
\ No newline at end of file
diff --git a/Algorithm/hot_potato/question.txt b/Algorithm/hot_potato/question.txt
new file mode 100644
index 0000000..23714b4
--- /dev/null
+++ b/Algorithm/hot_potato/question.txt
@@ -0,0 +1,22 @@
+Hot Potato (Josephus problem):
+In this game children line up in a circle and pass an item from neighbor to neighbor as
+fast as they can. At a certain point (say after a round) in the game, the action is stopped
+and the child who has the item (the potato) is removed from the circle. Play continues
+until only one child is left.
+
+(a) Players : Let there are n children
+(b) Elimination Rule : Every i th child will be removed after a round .
+
+Devise a winning strategy, it mean that one can choose a strategy to be the last person
+left who will be declared as the winner.
+
+Input Data and Format
+• Enter number of children : n
+• Elimination Rule : i
+
+
+Expected Output for Correct and Incorrect Inputs
+Return: winning strategy i.e. a safe position s for some given values of n and i.
+
+Example : If n = 7 and i = 3, then the safe position is s = 4. The persons at positions 3,
+6, 2, 7, 5, 1 are removed in order, and person at position 4 survives.
diff --git a/Algorithm/nQueen/Question.txt b/Algorithm/nQueen/Question.txt
new file mode 100644
index 0000000..8e50ad1
--- /dev/null
+++ b/Algorithm/nQueen/Question.txt
@@ -0,0 +1,10 @@
+The N Queen is the problem of placing N chess queens on an N×N chessboard so
+that no two queens attack each other. For example, following is a solution 
+for 4 Queen problem.
+The expected output is a binary matrix which has Qs for the blocks where 
+queens are placed and Xs where queens are not placed. 
+EXAMPLE:
+X  X  Q  X 
+Q  X  X  X
+X  X  X  Q
+X  Q  X  X  
\ No newline at end of file
diff --git a/Algorithm/nQueen/nQueen.cpp b/Algorithm/nQueen/nQueen.cpp
new file mode 100644
index 0000000..505b926
--- /dev/null
+++ b/Algorithm/nQueen/nQueen.cpp
@@ -0,0 +1,90 @@
+
+#include <iostream>
+using namespace std;
+
+char board[30][30];
+
+void printBoard(char arr[][30], int n) {
+    for (int r = 0; r < n; ++r) {
+        for (int c = 0; c < n; ++c) {
+            cout << arr[r][c] << " " ;
+        }
+        cout << endl;
+    }
+}
+
+void initialiseBoard(int n) {
+    for (int r = 0; r < n; ++r) {
+        for (int c = 0; c < n; ++c) {
+            board[r][c] = 'X';
+        }
+    }
+}
+
+bool canPlace(char board[][30], int N, int x, int y)
+{
+    //check the row if aqueen already exists
+    for (int r = 0; r < N; ++r)
+    {
+        if (board[r][y] == 'Q') 
+            return false;
+    }
+
+    int rInc[] = { -1, +1, +1, -1};
+    int cInc[] = { -1, +1, -1, +1};
+     //check diagonal if queen already exists
+    for (int dir = 0; dir < 4; ++dir)
+    {
+        int rowAdd = rInc[dir];
+        int colAdd = cInc[dir];
+        int r = x + rowAdd;
+        int c = y + colAdd;
+        //check that r c is within the board
+        while (r >= 0 && r < N && c >= 0 && c < N)
+        {
+            if (board[r][c] == 'Q')
+             return false;
+            r = r + rowAdd;
+            c = c + colAdd;
+        }
+    }
+    return true;
+}
+
+bool nqueen(int r, int n)
+{
+    if (r == n)//base case if all queens are placed 
+    {
+        return true;
+    }
+    //for every column, use hit and trial by placing a queen in the each cell of curr Row
+    for (int c = 0; c < n; ++c)
+    {
+        int x = r;
+        int y = c;
+        //check if queen can be placed on board[i][c]
+        if (canPlace(board, n, x, y)==true)
+        {
+            board[x][y] = 'Q'; //place queen in each column
+            bool isSuccessful = nqueen(r + 1, n);   //recursion to place rest of queens
+            if (isSuccessful == true)
+             return true;
+            board[x][y] = 'X';   //else unmark the cell or backtrack
+        }
+    }
+    return false; //if queen cannot be placed in any row in this column then return false
+}
+
+int main()
+{
+    int n;
+    cin >> n;
+
+    initialiseBoard(n);//initialse all the board with X
+    bool isSuccessful = nqueen(0, n);
+
+    if (isSuccessful) printBoard(board, n);
+    else cout << "Sorry man! You need to have a larger board!\n";
+
+    return 0;
+}
diff --git a/Array/Biggest_Sum_5_Consecutives_Integers/Biggest_Sum_5_Consecutives_Integers b/Array/Biggest_Sum_5_Consecutives_Integers/Biggest_Sum_5_Consecutives_Integers
new file mode 100644
index 0000000..b526a8c
--- /dev/null
+++ b/Array/Biggest_Sum_5_Consecutives_Integers/Biggest_Sum_5_Consecutives_Integers
@@ -0,0 +1,19 @@
+What's the biggest sum you can get from adding 5 consecutives integers in a array?
+
+Example:
+	Array = [1, 3, -2, 4, -9, 1, 4, 7]
+	Possibles Sums:
+		1 + 3 + (-2) + 4 + (-9) = -3
+		3 + (-2) + 4 + (-9) + 1 = -3
+		(-2) + 4 + (-9) + 1 + 4 = -2
+		4 + (-9) + 1 + 4 + 7 	=  7
+	
+	So the biggest Sum is 7.
+	
+What's the biggest sum of 5 consecutives integers of the array below?
+
+Array = [1, 3, -5, 8, -9, 13, -2, -3, 8, 4, 3, 6, 1, 2, -2, -4, 8, -4, 1, 8, 2, 1, 3, 1, 2, 3,
+		7, 8, -9, 5, 4, 3, 2, 4, 1, 2, 6, 6, 7, -15, 9, 7, 8, 16, -10, 1, 2, 6, 6, 4, -5, 2, 2
+		3, 6, 7, 8, 1, 2, 3, 3, 4, 5, 6, 1, -5,7, -9, 10, 1, 3, 4, 8, 7, 6, 4, 1, 1, 2, 3, 1]
+
+PS: There may or may not have different sequences that has the same sum.
diff --git a/Array/Biggest_Sum_5_Consecutives_Integers/solution.c b/Array/Biggest_Sum_5_Consecutives_Integers/solution.c
new file mode 100644
index 0000000..4a395d4
--- /dev/null
+++ b/Array/Biggest_Sum_5_Consecutives_Integers/solution.c
@@ -0,0 +1,23 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(){
+    int i;
+    int size = 81; //SIZE OF THE ARRAY
+    int sum;
+    int biggestSum;
+    int array[]  =  {1, 3, -5, 8, -9, 13, -2, -3, 8, 4, 3, 6, 1, 2, -2, -4, 8, -4, 1, 8, 2, 1, 3, 1, 2, 3, 7, 8, -9, 5, 4, 3, 2, 4, 1, 2, 6, 6, 7, -15, 9, 7, 8, 16, -10, 1, 2, 6, 6, 4, -5, 2, 2, 3, 6, 7, 8, 1, 2, 3, 3, 4, 5, 6, 1, -5, 7, -9, 10, 1, 3, 4, 8, 7, 6, 4, 1, 1, 2, 3, 1};
+    
+    //FIRST SUM
+    sum = array[0] + array[1] + array[2] + array[3] + array[4];
+    biggestSum = sum;
+
+    //OTHER SUMS
+    for(i = 1; i < (size - 4); i++){ //THERE ARE (size - 4) POSSIBLE SUMS, BUT WE ALREADY MADE 1, SO i STARTS AT 1
+        sum = sum - array[i - 1] + array[i + 4]; //REMOVE THE FIRST OF THE OLD SUM, AND ADD THE NEW INTEGER
+        if(sum > biggestSum){
+            biggestSum = sum;
+        }
+    }
+    printf("biggestSum = %d\n", biggestSum); //PRINT THE RESULT
+}
\ No newline at end of file
diff --git a/Array/Circle Coloring/1408A.cpp b/Array/Circle Coloring/1408A.cpp
new file mode 100644
index 0000000..d526a08
--- /dev/null
+++ b/Array/Circle Coloring/1408A.cpp	
@@ -0,0 +1,52 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int main()
+{
+	while()
+    {
+        int n;
+        cin>>n;
+        std::vector<int> a(n), b(n), c(n), ans;
+
+        for(int i=0; i<n; i++)
+        {
+            cin>>a[i];
+        }
+        for(int i=0; i<n; i++)
+        {
+            cin>>b[i];
+        }
+        for(int i=0; i<n; i++)
+        {
+            cin>>c[i];
+        }
+        ans.push_back(a[0]);
+
+        for(int i=1; i<n; i++)
+        {
+            if(i == (n-1))
+            {
+                if(ans[ans.size()-1] != a[i] && a[i] != ans[0])
+                    ans.push_back(a[i]);
+                else if(ans[ans.size()-1] != b[i] && b[i] != ans[0])
+                    ans.push_back(b[i]);
+                else if(ans[ans.size()-1] != c[i] && c[i] != ans[0])
+                    ans.push_back(c[i]);
+            }
+            else if(ans[ans.size()-1] != a[i])
+                ans.push_back(a[i]);
+            
+            else if(ans[ans.size()-1] != b[i])
+                ans.push_back(b[i]);
+            
+            else if(ans[ans.size()-1] != c[i])
+                ans.push_back(c[i]);
+        }
+        for(auto i : ans)
+            cout<<i<<" ";
+        cout<<endl;
+    }
+	return 0;
+}
diff --git a/Array/Circle Coloring/question 1408A.txt b/Array/Circle Coloring/question 1408A.txt
new file mode 100644
index 0000000..d412d68
--- /dev/null
+++ b/Array/Circle Coloring/question 1408A.txt	
@@ -0,0 +1,82 @@
+		                                             		CIRCLE COLORING				
+                                                                      time limit per test1 second
+                                                                      memory limit per test256 megabytes
+                                                                      inputstandard input
+                                                                      outputstandard output
+
+You are given three sequences: a1,a2,…,an; b1,b2,…,bn; c1,c2,…,cn.
+
+For each i, ai≠bi, ai≠ci, bi≠ci.
+
+Find a sequence p1,p2,…,pn, that satisfy the following conditions:
+
+pi∈{ai,bi,ci}
+pi≠p(imodn)+1.
+In other words, for each element, you need to choose one of the three possible values, such that no two adjacent elements (where we consider elements i,i+1 adjacent for i<n and also elements 1 and n) will have equal value.
+
+It can be proved that in the given constraints solution always exists. You don't need to minimize/maximize anything, you need to find any proper sequence.
+
+Input
+The first line of input contains one integer t (1≤t≤100): the number of test cases.
+
+The first line of each test case contains one integer n (3≤n≤100): the number of elements in the given sequences.
+
+The second line contains n integers a1,a2,…,an (1≤ai≤100).
+
+The third line contains n integers b1,b2,…,bn (1≤bi≤100).
+
+The fourth line contains n integers c1,c2,…,cn (1≤ci≤100).
+
+It is guaranteed that ai≠bi, ai≠ci, bi≠ci for all i.
+
+Output
+For each test case, print n integers: p1,p2,…,pn (pi∈{ai,bi,ci}, pi≠pimodn+1).
+
+If there are several solutions, you can print any.
+
+Example
+inputCopy
+5
+3
+1 1 1
+2 2 2
+3 3 3
+4
+1 2 1 2
+2 1 2 1
+3 4 3 4
+7
+1 3 3 1 1 1 1
+2 4 4 3 2 2 4
+4 2 2 2 4 4 2
+3
+1 2 1
+2 3 3
+3 1 2
+10
+1 1 1 2 2 2 3 3 3 1
+2 2 2 3 3 3 1 1 1 2
+3 3 3 1 1 1 2 2 2 3
+outputCopy
+1 2 3
+1 2 1 2
+1 3 4 3 2 4 2
+1 3 2
+1 2 3 1 2 3 1 2 3 2
+Note
+In the first test case p=[1,2,3].
+
+It is a correct answer, because:
+
+p1=1=a1, p2=2=b2, p3=3=c3
+p1≠p2, p2≠p3, p3≠p1
+All possible correct answers to this test case are: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1].
+
+In the second test case p=[1,2,1,2].
+
+In this sequence p1=a1, p2=a2, p3=a3, p4=a4. Also we can see, that no two adjacent elements of the sequence are equal.
+
+In the third test case p=[1,3,4,3,2,4,2].
+
+In this sequence p1=a1, p2=a2, p3=b3, p4=b4, p5=b5, p6=c6, p7=c7. Also we can see, that no two adjacent elements of the sequence are equal.
+
diff --git a/Array/Hourglass in Array/Hourglass in Array.txt b/Array/Hourglass in Array/Hourglass in Array.txt
new file mode 100644
index 0000000..7360172
--- /dev/null
+++ b/Array/Hourglass in Array/Hourglass in Array.txt	
@@ -0,0 +1,59 @@
+Given a 6x6 2D Array, arr:
+
+1 1 1 0 0 0
+0 1 0 0 0 0
+1 1 1 0 0 0
+0 0 0 0 0 0
+0 0 0 0 0 0
+0 0 0 0 0 0
+An hourglass in A is a subset of values with indices falling in this pattern in arr's graphical representation:
+
+a b c
+  d
+e f g
+
+There are 16 hourglasses in . An hourglass sum is the sum of an hourglass' values. Calculate the hourglass sum for every hourglass in arr, then print the maximum hourglass sum. The array will always be 6x6.
+
+Example
+
+arr =
+-9 -9 -9  1 1 1 
+ 0 -9  0  4 3 2
+-9 -9 -9  1 2 3
+ 0  0  8  6 6 0
+ 0  0  0 -2 0 0
+ 0  0  1  2 4 0
+
+The 16 hourglass sums are:
+
+-63, -34, -9, 12, 
+-10,   0, 28, 23, 
+-27, -11, -2, 10, 
+  9,  17, 25, 18
+The highest hourglass sum is 28 from the hourglass beginning at row 1, column 2:
+
+0 4 3
+  1
+8 6 6
+Note: If you have already solved the Java domain's Java 2D Array challenge, you may wish to skip this challenge.
+
+Function Description:
+
+Complete the function hourglassSum in the editor below.
+
+hourglassSum has the following parameter(s):
+
+int arr[6][6]: an array of integers
+Returns
+
+int: the maximum hourglass sum
+
+Input Format
+Each of the 6 lines of inputs arr[i] contains 6 space-separated integers arr[i][j].
+
+Constraints
+-9 <= arr[i][j] <= 9
+0 <= i,j <= 5
+
+Output Format
+Print the largest (maximum) hourglass sum found in arr.
\ No newline at end of file
diff --git a/Array/Hourglass in Array/Solution.cpp b/Array/Hourglass in Array/Solution.cpp
new file mode 100644
index 0000000..9c54bb4
--- /dev/null
+++ b/Array/Hourglass in Array/Solution.cpp	
@@ -0,0 +1,58 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// Complete the hourglassSum function below.
+int hourglassSum(vector<vector<int>> arr) {
+
+    int sum[16]={0};
+    int a[36];
+    static int r=0,x=0;
+
+    for(int i=0;i<6;i++){
+        for(int j=0;j<6;j++,r++){
+            a[r]=arr[i][j];
+        }
+    }
+
+
+    for(int i=0;i<22;i++,x++){
+        sum[x]=a[i]+a[i+1]+a[i+2]+a[i+7]+a[i+12]+a[i+13]+a[i+14];
+        if(i==3 || i==9 || i==15)
+            i+=2;
+        cout << sum[x] << " ";
+    }
+
+    int large = sum[0];
+
+    for(int i=1;i<16;i++){
+        if(large<sum[i])
+            large = sum[i];
+    }
+
+    return large;
+}
+
+int main()
+{
+    ofstream fout(getenv("OUTPUT_PATH"));
+
+    vector<vector<int>> arr(6);
+    for (int i = 0; i < 6; i++) {
+        arr[i].resize(6);
+
+        for (int j = 0; j < 6; j++) {
+            cin >> arr[i][j];
+        }
+
+        cin.ignore(numeric_limits<streamsize>::max(), '\n');
+    }
+
+    int result = hourglassSum(arr);
+
+    fout << result << "\n";
+
+    fout.close();
+
+    return 0;
+}
\ No newline at end of file
diff --git a/Lily's Homework/Question.txt b/Array/Lily's Homework/Question.txt
similarity index 98%
rename from Lily's Homework/Question.txt
rename to Array/Lily's Homework/Question.txt
index 502c95c..39f207f 100644
--- a/Lily's Homework/Question.txt	
+++ b/Array/Lily's Homework/Question.txt	
@@ -1,11 +1,11 @@
-Consider an array of  distinct integers, arr = [a[0], a[1], ..., a[n-1]]. George can swap any two elements of the array any number of times. An array is beautiful if the sum of |arr[i] - arr[i-1]|among 0< i < n is minimal.
-
-Given the array , determine and return the minimum number of swaps that should be performed in order to make the array beautiful.
-
-For example, arr = [7, 15, 12, 3]. One minimal array is [3, 7, 12, 15]. To get there, George performed the following swaps:
-
-Swap      Result
-      [7, 15, 12, 3]
-3 7   [3, 15, 12, 7]
-7 15  [3, 7, 12, 15]
+Consider an array of  distinct integers, arr = [a[0], a[1], ..., a[n-1]]. George can swap any two elements of the array any number of times. An array is beautiful if the sum of |arr[i] - arr[i-1]|among 0< i < n is minimal.
+
+Given the array , determine and return the minimum number of swaps that should be performed in order to make the array beautiful.
+
+For example, arr = [7, 15, 12, 3]. One minimal array is [3, 7, 12, 15]. To get there, George performed the following swaps:
+
+Swap      Result
+      [7, 15, 12, 3]
+3 7   [3, 15, 12, 7]
+7 15  [3, 7, 12, 15]
 It took 2 swaps to make the array beautiful. This is minimal among the choice of beautiful arrays possible.
\ No newline at end of file
diff --git a/Lily's Homework/solution.py b/Array/Lily's Homework/solution.py
similarity index 96%
rename from Lily's Homework/solution.py
rename to Array/Lily's Homework/solution.py
index 8b29419..7783d49 100644
--- a/Lily's Homework/solution.py	
+++ b/Array/Lily's Homework/solution.py	
@@ -1,26 +1,26 @@
-def lilysHomework(arr):
-    m = {}
-    for i in range(len(arr)):
-        m[arr[i]] = i
-    sorted_arr = sorted(arr)
-    res = 0
-    for i in range(len(arr)):
-        if(arr[i] != sorted_arr[i]):
-            res += 1
-            x = m[sorted_arr[i]]
-            m[ arr[i] ] = m[ sorted_arr[i]]
-            arr[i],arr[x] = sorted_arr[i],arr[i]
-    return res
-
-if __name__ == '__main__':
-    fptr = open(os.environ['OUTPUT_PATH'], 'w')
-
-    n = int(input())
-
-    arr = list(map(int, input().rstrip().split()))
-
-    result = min(lilysHomework(list(arr)), lilysHomework(list(arr[::-1])))
-
-    fptr.write(str(result) + '\n')
-
-    fptr.close()
+def lilysHomework(arr):
+    m = {}
+    for i in range(len(arr)):
+        m[arr[i]] = i
+    sorted_arr = sorted(arr)
+    res = 0
+    for i in range(len(arr)):
+        if(arr[i] != sorted_arr[i]):
+            res += 1
+            x = m[sorted_arr[i]]
+            m[ arr[i] ] = m[ sorted_arr[i]]
+            arr[i],arr[x] = sorted_arr[i],arr[i]
+    return res
+
+if __name__ == '__main__':
+    fptr = open(os.environ['OUTPUT_PATH'], 'w')
+
+    n = int(input())
+
+    arr = list(map(int, input().rstrip().split()))
+
+    result = min(lilysHomework(list(arr)), lilysHomework(list(arr[::-1])))
+
+    fptr.write(str(result) + '\n')
+
+    fptr.close()
diff --git a/Array/Mislove Has Lost an Array/Question.txt b/Array/Mislove Has Lost an Array/Question.txt
new file mode 100644
index 0000000..23182ac
--- /dev/null
+++ b/Array/Mislove Has Lost an Array/Question.txt	
@@ -0,0 +1,17 @@
+Mislove had an array a1, a2, ⋯, an of n positive integers, but he has lost it. He only remembers the following facts about it:
+
+1)The number of different numbers in the array is not less than l and is not greater than r.
+2)For each array's element ai either ai=1 or ai is even and there is a number ai/2 in the array.
+
+For example, if n=5, l=2, r=3 then an array could be [1,2,2,4,4] or [1,1,1,1,2]; but it couldn't be [1,2,2,4,8] because this array contains 4 different numbers; it couldn't be [1,2,2,3,3] because 3 is odd and isn't equal to 1; and it couldn't be [1,1,2,2,16] because there is a number 16 in the array but there isn't a number 16/2=8.
+
+According to these facts, he is asking you to count the minimal and the maximal possible sums of all elements in an array. 
+
+Input-1
+4 2 2
+Output
+5 7
+Input-2
+5 1 5
+Output
+5 31
diff --git a/Array/Mislove Has Lost an Array/Solution.cpp b/Array/Mislove Has Lost an Array/Solution.cpp
new file mode 100644
index 0000000..841440f
--- /dev/null
+++ b/Array/Mislove Has Lost an Array/Solution.cpp	
@@ -0,0 +1,26 @@
+#include<bits/stdc++.h>
+using namespace std;
+int main()
+{
+    long long int i,mini=1,mine=0,maxi=1,maxo=0,n,s,e;
+    cin>>n>>s>>e;
+    
+    for(i=1;i<=s-1;i++)
+    {
+        mini=2*mini;
+        mine+=mini;
+    }
+mine+=n-s+1;
+ 
+for(i=1;i<=e-1;i++)
+{
+    maxi=2*maxi;
+    maxo+=maxi;
+}
+maxo+=1;
+
+ 
+maxo+=(n-e)*(maxi);
+cout<<mine<<" "<<maxo;
+    return 0;
+}
diff --git a/Array/Omar and Candies/Problem Statement.txt b/Array/Omar and Candies/Problem Statement.txt
new file mode 100644
index 0000000..4e3391e
--- /dev/null
+++ b/Array/Omar and Candies/Problem Statement.txt	
@@ -0,0 +1,24 @@
+Omar can get as many candies as he wants but all of them must be of the same type. Find the candy having the biggest quantity in the store so that Omar can have maximum number of candies.
+
+
+Input Format:
+
+The first line of the input will be a single integer T, the number of test cases (1 <= T <= 100). Followed by the test cases, each test case is described in one line which contains a non-empty string which consists of up to 100 letters, each letter is a lower case English letter (from 'a' to 'z'). This string represents all candies in the store, each candy is described using 1 character, so if the string is "abac" this means the store contains 2 candies of type 'a', 1 candy of type 'b' and 1 candy of type 'c'.
+
+
+Output Format:
+
+For each test case, print a single line which contains a single integer representing the maximum number of candies that Omar can get followed by a space then a letter which represents the kind of that candy. If there are multiple candies with the same number, print the one which occurs relatively first in the English alphabet.
+
+
+Sample Input:
+3
+abac
+abc
+zzz
+
+
+Sample Output:
+2 a
+1 a
+3 z
diff --git a/Array/Omar and Candies/Solution.c b/Array/Omar and Candies/Solution.c
new file mode 100644
index 0000000..ac37faf
--- /dev/null
+++ b/Array/Omar and Candies/Solution.c	
@@ -0,0 +1,28 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+
+int main()
+{
+  int t;
+  scanf("%d",&t);
+  while(t--){
+  char str[100];
+  scanf("%s",str);
+  int i;
+  int *arr = (int*)calloc(26,sizeof(int));
+  for(i=0;i<strlen(str);i++){
+    arr[str[i]-97]++;
+  }
+  int max=arr[0],c=0;
+  for(i=1;i<26;i++)
+  {
+    if(arr[i]>max){
+      max = arr[i];
+      c=i;
+    }
+  }
+  printf("%d %c\n",max,c+97);
+}
+  return 0;
+}
diff --git a/Array/Philosophers_Stone/question.txt b/Array/Philosophers_Stone/question.txt
new file mode 100644
index 0000000..f2474d3
--- /dev/null
+++ b/Array/Philosophers_Stone/question.txt
@@ -0,0 +1,30 @@
+
+
+One of the secret chambers in Hogwarts is full of philosopher’s stones. The floor of the chamber is covered by h × w square tiles, where there are h rows of tiles from front (first row) to back (last row) and w columns of tiles from left to right. Each tile has 1 to 100 stones on it. Harry has to grab as many philosopher’s stones as possible, subject to the following restrictions:
+
+    He starts by choosing any tile in the first row, and collects the philosopher’s stones on that tile. Then, he moves to a tile in the next row, collects the philosopher’s stones on the tile, and so on until he reaches the last row.
+    When he moves from one tile to a tile in the next row, he can only move to the tile just below it or diagonally to the left or right.
+
+Given the values of h and w, and the number of philosopher’s stones on each tile, write a program to compute the maximum possible number of philosopher’s stones Harry can grab in one single trip from the first row to the last row.
+Input
+
+The first line consists of a single integer T, the number of test cases. In each of the test cases, the first line has two integers. The first integer h (1 <= h <= 100) is the number of rows of tiles on the floor. The second integer w (1 <= w <= 100) is the number of columns of tiles on the floor. Next, there are h lines of inputs. The i-th line of these, specifies the number of philosopher’s stones in each tile of the i-th row from the front. Each line has w integers, where each integer m (0 <= m <= 100) is the number of philosopher’s stones on that tile. The integers are separated by a space character.
+Output
+
+The output should consist of T lines, (1 <= T <= 100), one for each test case. Each line consists of a single integer, which is the maximum possible number of philosopher’s stones Harry can grab, in one single trip from the first row to the last row for the corresponding test case.
+Example
+
+Input:
+1
+6 5
+3 1 7 4 2
+2 1 3 1 1
+1 2 2 1 8
+2 2 1 5 3
+2 1 4 4 4
+5 2 7 5 1
+
+Output:
+32
+
+//7+1+8+5+4+7=32
diff --git a/Array/Philosophers_Stone/solution.cpp b/Array/Philosophers_Stone/solution.cpp
new file mode 100644
index 0000000..f3cc8e7
--- /dev/null
+++ b/Array/Philosophers_Stone/solution.cpp
@@ -0,0 +1,29 @@
+#include<bits/stdc++.h>
+using namespace std;
+int main(void)
+{
+  int t;
+  cin>>t;
+  while(t--)
+  {
+    int r,c;
+    cin>>r>>c;
+    int arr[r][c+2]={0};
+    arr[0][c+1]=0;
+
+    for(int i=0;i<r;i++)
+     for(int j=1;j<=c;j++)
+       cin>>arr[i][j];
+
+    for(int i=r-2;i>=0;i--)
+     for(int j=1;j<=c;j++)
+       arr[i][j]+=max((arr[i+1][j-1]),max(arr[i+1][j],arr[i+1][j+1]));
+
+    int max = INT_MIN;
+    for(int i=1;i<=c;i++)
+     if(arr[0][i]>max)
+       max = arr[0][i];
+
+    cout<<max<<"\n";
+  }
+}
diff --git a/Array/Phone price/solution.cpp b/Array/Phone price/solution.cpp
new file mode 100644
index 0000000..2c58c78
--- /dev/null
+++ b/Array/Phone price/solution.cpp	
@@ -0,0 +1,39 @@
+#include<iostream>
+using namespace std;
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;int a[n];
+
+        for(int i=0;i<n;i++){
+            cin>>a[i];
+        }
+
+        int j=1;int good =1;int cnt=0;int t=0;
+
+        for(int i=1;i<n;i++){
+                if(i>=6)t++;
+            for(j=i-1;j>=t;j--){
+
+                if(a[j]>a[i]){
+                cnt=1;}
+
+                else {
+                cnt=0;
+                break;}
+
+            }
+
+            if(cnt==1)
+            good++;
+
+        }
+
+        cout<<good<<endl;
+    }
+
+
+}
diff --git a/Array/Phone price/statement.txt b/Array/Phone price/statement.txt
new file mode 100644
index 0000000..ae00b8d
--- /dev/null
+++ b/Array/Phone price/statement.txt	
@@ -0,0 +1,34 @@
+Chef wants to buy a new phone, but he is not willing to spend a lot of money. Instead, he checks the price of his chosen model everyday and waits for the price to drop to an acceptable value. So far, he has observed the price for N days (numbere 1 through N); for each valid i, the price on the i-th day was Pi dollars.
+
+On each day, Chef considers the price of the phone to be good if it is strictly smaller than all the prices he has observed during the previous five days. If there is no record of the price on some of the previous five days (because Chef has not started checking the price on that day yet), then Chef simply ignores that previous day ― we could say that he considers the price on that day to be infinite.
+
+Now, Chef is wondering ― on how many days has he considered the price to be good? Find the number of these days.
+
+Input
+The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
+The first line of each test case contains a single integer N.
+The second line contains N space-separated integers P1,P2,…,PN.
+
+Output
+For each test case, print a single line containing one integer ― the number of days with a good price.
+
+Constraints
+1≤T≤100
+7≤N≤100
+350≤Pi≤750 for each valid i
+
+Subtasks
+
+Subtask #1 (30 points): N=7
+Subtask #2 (70 points): original constraints
+
+Example Input
+1
+7
+375 750 723 662 647 656 619
+
+Example Output
+2
+
+Explanation
+Example case 1: Chef considers the price to be good on day 1, because he has not observed any prices on the previous days. The prices on days 2,3,4,5,6 are not considered good because they are greater than the price on day 1. Finally, the price on day 7 is considered good because it is smaller than all of the prices on days 2,3,4,5,6.
\ No newline at end of file
diff --git a/Array/Rotate Array/Question.txt b/Array/Rotate Array/Question.txt
new file mode 100644
index 0000000..2152d32
--- /dev/null
+++ b/Array/Rotate Array/Question.txt	
@@ -0,0 +1 @@
+We have to rotate the elements of the given array k times to the right.
\ No newline at end of file
diff --git a/Array/Rotate Array/solution.kt b/Array/Rotate Array/solution.kt
new file mode 100644
index 0000000..0d58479
--- /dev/null
+++ b/Array/Rotate Array/solution.kt	
@@ -0,0 +1,23 @@
+internal class Solution {
+  fun rotate(nums:IntArray, k:Int) {
+    k = k % nums.size
+    val count = 0
+    val start = 0
+    while (count < nums.size)
+    {
+      val current = start
+      val prev = nums[start]
+      do
+      {
+        val next = (current + k) % nums.size
+        val temp = nums[next]
+        nums[next] = prev
+        prev = temp
+        current = next
+        count++
+      }
+      while (start != current)
+      start++
+    }
+  }
+}
\ No newline at end of file
diff --git a/Array/Sieve of Eratosthenes/Question.txt b/Array/Sieve of Eratosthenes/Question.txt
new file mode 100644
index 0000000..d210b3f
--- /dev/null
+++ b/Array/Sieve of Eratosthenes/Question.txt	
@@ -0,0 +1,20 @@
+A prime number is a positive number, which is divisible by exactly two different integers.
+In this problem your job is to print all primes smaller than or equal to a certain integer n (0 < n < 10000000).
+
+Input
+First line of the input file contains a single integer C (0 < C ≤ 500000) that indicates the total number
+of inputs. Each of the next C lines contains one integer n (0 < n < 10000000).
+
+Output
+For each line of input except the first line produce one line of output containing all the primes smaller than or equal to n.
+
+Sample Input
+3
+10
+20
+30
+
+Sample Output
+2 3 5 7 
+2 3 5 7 11 13 17 19
+2 3 5 7 11 13 17 19 23 29
\ No newline at end of file
diff --git a/Array/Sieve of Eratosthenes/Solution.cpp b/Array/Sieve of Eratosthenes/Solution.cpp
new file mode 100644
index 0000000..f25d4e3
--- /dev/null
+++ b/Array/Sieve of Eratosthenes/Solution.cpp	
@@ -0,0 +1,37 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+long long maxValue = 10000000;
+
+vector<bool> sieve(long long n) {
+    vector<bool> prime;
+    prime.assign(n+1, true);
+
+    prime[0] = prime[1] = false;
+
+    for(int i=2; i<n+1; i++)
+        if(prime[i])
+            for(int j=i*2; j<n+1; j+=i)
+                prime[j] = false;
+    
+    return prime;
+}
+
+int main() {
+    int cases, n;
+    vector<bool> prime = sieve(maxValue);
+
+    scanf("%d", &cases);
+
+    while(cases-- > 0) {
+        scanf("%d", &n);
+        
+        for(int i=2; i<n+1; i++)
+            if(prime[i])
+                printf("%d ", i);
+
+        printf("\n");
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/Array/TRUEDARE/QUESTION.txt b/Array/TRUEDARE/QUESTION.txt
new file mode 100644
index 0000000..a97ff54
--- /dev/null
+++ b/Array/TRUEDARE/QUESTION.txt
@@ -0,0 +1,79 @@
+Ram and Shyam are playing a game of Truth and Dare. In this game, Shyam will ask Ram to perform tasks of two types:
+
+Truth task: Ram has to truthfully answer a question.
+Dare task: Ram has to perform a given task.
+Each task is described by an integer. (If a truth task and a dare task are described by the same integer, they are still different tasks.) You are given four lists of tasks:
+
+Tr,1,Tr,2,…,Tr,tr: the truth tasks Ram can perform.
+Dr,1,Dr,2,…,Dr,dr: the dare tasks Ram can perform.
+Ts,1,Ts,2,…,Ts,ts: the truth tasks Shyam can ask Ram to perform.
+Ds,1,Ds,2,…,Ds,ds: the dare tasks Shyam can ask Ram to perform.
+Note that the elements of these lists are not necessarily distinct, each task may be repeated any number of times in each list.
+
+Shyam wins the game if he can find a task Ram cannot perform. Ram wins if he performs all tasks Shyam asks him to. Find the winner of the game.
+
+Let's take an example where Ram can perform truth tasks 3, 2 and 5 and dare tasks 2 and 100, and Shyam can give him truth tasks 2 and 3 and a dare task 100. We can see that whichever truth or dare tasks Shyam asks Ram to perform, Ram can easily perform them, so he wins. However, if Shyam can give him dare tasks 3 and 100, then Ram will not be able to perform dare task 3, so Shyam wins.
+
+Input
+The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
+The first line of each test case contains a single integer tr.
+The second line contains tr space-separated integers Tr,1,Tr,2,…,Tr,tr.
+The third line contains a single integer dr.
+The fourth line contains dr space-separated integers Dr,1,Dr,2,…,Dr,dr.
+The fifth line contains a single integer ts.
+The sixth line contains ts space-separated integers Ts,1,Ts,2,…,Ts,ts.
+The seventh line contains a single integer ds.
+The eighth line contains ds space-separated integers Ds,1,Ds,2,…,Ds,ds.
+Output
+For each test case, print a single line containing the string "yes" if Ram wins the game or "no" otherwise.
+
+Constraints
+1≤T≤100
+1≤tr,dr,ts,ds≤100
+1≤Tr,i≤100 for each valid i
+1≤Dr,i≤100 for each valid i
+1≤Ts,i≤100 for each valid i
+1≤Ds,i≤100 for each valid i
+Example Input
+4
+2
+1 2
+3
+1 3 2
+1
+2
+2
+3 2
+2
+1 2
+3
+1 3 2
+1
+2
+3
+3 2 4
+3
+3 2 5
+2
+2 100
+1
+2
+1
+100
+2
+1 2
+3
+1 3 2
+1
+2
+3
+3 2 2
+Example Output
+yes
+no
+yes
+yes
+Explanation
+Example case 1: Ram's truth tasks are [1,2] and his dare tasks are [1,3,2]. Shyam's truth tasks are [2] and his dare tasks are [3,2]. Ram can perform all tasks Shyam gives him.
+
+Example case 2: Ram's truth tasks are [1,2] and his dare tasks are [1,3,2]. Shyam's truth tasks are [2] and his dare tasks are [3,2,4]. If Shyam asks Ram to perform dare task 4, Ram will not be able to do it.
diff --git a/Array/TRUEDARE/SOLUTION.txt b/Array/TRUEDARE/SOLUTION.txt
new file mode 100644
index 0000000..a82eb0c
--- /dev/null
+++ b/Array/TRUEDARE/SOLUTION.txt
@@ -0,0 +1,75 @@
+#include<iostream>
+using namespace std;
+int main()
+{
+    int t,a,i,j,c,e,g,x,y;
+    cin>>t;
+    while(t>0)
+    { x=0;
+      y=0;
+        cin>>a;
+        int b[a];
+        for( i=0;i<a;i++)
+        cin>>b[i];
+
+        cin>>c;
+        int d[c];
+        for( i=0; i<c;i++)
+        cin>>d[i];
+
+        cin>>e;
+        int f[e];
+        for(i=0;i<e;i++)
+        cin>>f[i];
+
+        cin>>g;
+        int h[g];
+        for(i=0;i<g;i++)
+        cin>>h[i];
+
+        for(i=0;i<e;i++)
+        {
+
+          for(j=0;j<a;j++)
+           {
+               if(f[i]==b[j])
+              {++x;
+              break;
+            }
+        }
+
+        }
+
+           for(i=0;i<g;i++)
+        {
+
+          for(j=0;j<c;j++)
+           {
+               if(h[i]==d[j])
+              {
+
+               ++y;
+               break;
+            }
+        }
+        }
+
+       {
+
+        if(x==e)
+
+        {
+            if(y==g)
+            cout<<"yes"<<endl;
+            else
+            cout<<"no"<<endl;
+       }
+       else
+        cout<<"no"<<endl;
+
+    }
+   --t;
+    }
+        return 0;
+    }
+
diff --git a/Array/White-Sheet/White-Sheet.txt b/Array/White-Sheet/White-Sheet.txt
new file mode 100644
index 0000000..57d317d
--- /dev/null
+++ b/Array/White-Sheet/White-Sheet.txt
@@ -0,0 +1,54 @@
+There is a white sheet of paper lying on a rectangle table. The sheet is a rectangle with its sides parallel to the sides of the table. If you will take a look from above and assume that the bottom left corner of the table has coordinates (0,0), and coordinate axes are left and bottom sides of the table, then the bottom left corner of the white sheet has coordinates (x1,y1), and the top right — (x2,y2).
+After that two black sheets of paper are placed on the table. Sides of both black sheets are also parallel to the sides of the table. Coordinates of the bottom left corner of the first black sheet are (x3,y3), and the top right — (x4,y4). Coordinates of the bottom left corner of the second black sheet are (x5,y5), and the top right — (x6,y6).
+  
+
+Determine if some part of the white sheet can be seen from the above after the two black sheets are placed. The part of the white sheet can be seen if there is at least one point lying not strictly inside the white sheet and strictly outside of both black sheets.
+Input
+The first line of the input contains four integers x1,y1,x2,y2 (0≤x1<x2≤106,0≤y1<y2≤106) — coordinates of the bottom left and the top right corners of the white sheet.
+The second line of the input contains four integers (0≤x3<x4≤106,0≤y3<y4≤106) — coordinates of the bottom left and the top right corners of the first black sheet.
+The third line of the input contains four integers (0≤x5<x6≤106,0≤y5<y6≤106) — coordinates of the bottom left and the top right corners of the second black sheet.
+The sides of each sheet of paper are parallel (perpendicular) to the coordinate axes.
+Output
+If some part of the white sheet can be seen from the above after the two black sheets are placed, print "YES" (without quotes). Otherwise print "NO".
+input
+2 2 4 4
+1 1 3 5
+3 1 5 5
+
+
+Output
+NO
+
+
+input
+3 3 7 5
+0 0 4 6
+0 0 7 4
+
+
+output
+YES
+
+
+input
+
+
+5 2 10 5
+3 1 7 6
+8 1 11 7
+
+
+output
+YES
+
+
+input
+
+
+0 0 1000000 1000000
+0 0 499999 1000000
+500000 0 1000000 1000000
+
+
+output
+YES
\ No newline at end of file
diff --git a/Array/White-Sheet/code.cpp b/Array/White-Sheet/code.cpp
new file mode 100644
index 0000000..2100d7d
--- /dev/null
+++ b/Array/White-Sheet/code.cpp
@@ -0,0 +1,57 @@
+//https://codeforces.com/contest/1216/problem/C
+//587-Div 3-C
+#include<bits/stdc++.h>
+using namespace std;
+
+typedef long long int ll;
+
+
+int main()
+{
+	ios::sync_with_stdio(false);
+	cin.tie(0);
+	cout.tie(0);
+
+	ll x11,x12,y11,y12;
+	ll x21,x22,y21,y22;
+	ll x31,x32,y31,y32;
+
+	ll area = 0;
+
+	cin>>x11>>y11>>x12>>y12;
+	cin>>x21>>y21>>x22>>y22;
+	cin>>x31>>y31>>x32>>y32;
+
+	area = abs(x11-x12)*abs(y11-y12);
+	x21 = max(x11,x21);
+	y21 = max(y11,y21);
+	x22 = min(x12,x22);
+	y22 = min(y12,y22);
+	x31 = max(x11,x31);
+	y31 = max(y11,y31);
+	x32 = min(x12,x32);
+	y32 = min(y12,y32);
+	ll a1,a2,b1,b2;
+	if(x21 < x22 && y21 < y22) area -= abs(x21-x22)*abs(y21-y22);
+	if(x31 < x32 && y31 < y32) area -= abs(x31-x32)*abs(y31-y32);
+	if((x21<x31 && x22>x31) || (x21<x32 && x22>x32))
+	{
+		if((y21 < y31 && y22 > y31) || (y21 < y32 && y22 > y32))
+		{
+			ll narea = 0;
+
+		}
+	}
+
+	a1 = max(x21,x31);
+	b1 = max(y21,y31);
+	a2 = min(x22,x32);
+	b2 = min(y22,y32);
+
+	if(a1 < a2 && b1 < b2)	area += abs(a2-a1)*abs(b2-b1);
+
+	if(area > 0)	cout<<"YES\n";
+	else			cout<<"NO\n";
+
+	return 0;
+}
\ No newline at end of file
diff --git a/Array/triplet_problem/question.txt b/Array/triplet_problem/question.txt
new file mode 100644
index 0000000..b1417a8
--- /dev/null
+++ b/Array/triplet_problem/question.txt
@@ -0,0 +1 @@
+Find a triplet such that sum of two equals to third element in an array.
diff --git a/Array/triplet_problem/solution.c b/Array/triplet_problem/solution.c
new file mode 100644
index 0000000..69ac10c
--- /dev/null
+++ b/Array/triplet_problem/solution.c
@@ -0,0 +1,48 @@
+#include<stdio.h>
+
+void sort(int a[],int);
+void findtriplet(int a[],int n)
+{
+ sort(a,n);
+ for(int k=n-1;k>=0;k--)
+ {
+  int i=0,j=k-1;
+  while(i<j)
+  {
+    if(a[k] == a[i]+a[j])
+    {
+      printf("%d %d %d\n",a[i],a[j],a[k]);
+      return;
+    }
+    else if(a[k] > (a[i]+a[j]))
+       i++;
+    else 
+       j--;
+  }
+ }
+ printf("No such triplet exists\n");
+}
+
+void sort(int a[],int n)
+{
+ for(int i=0;i<n-1;i++)
+ {
+   for(int j=0;j<=n-1-i;j++)
+   {
+     if(a[j] > a[j+1])
+     { 
+      int t;
+      t = a[j];
+      a[j] = a[j+1];
+      a[j+1] = t;
+     }
+   }
+ }
+}
+
+int main()
+{
+ int a[9] = {5,32,1,7,10,50,15,21,2};
+ findtriplet(a,9);
+ return 0;
+}
diff --git a/Backtracking/Generate_parenthesis/Generate_Parenthesis.cpp b/Backtracking/Generate_parenthesis/Generate_Parenthesis.cpp
new file mode 100644
index 0000000..0b6a580
--- /dev/null
+++ b/Backtracking/Generate_parenthesis/Generate_Parenthesis.cpp
@@ -0,0 +1,31 @@
+#include <bits/stdc++.h>
+using namespace std;
+void Generate_Parenthesis(int open, int close, vector<string> &ans, string s)
+{
+    if (close == 0)
+    {
+        ans.push_back(s);
+        return;
+    }
+    if (open)
+    {
+        string temp = s;
+        temp += '(';
+        Generate_Parenthesis(open - 1, close, ans, temp);
+    }
+    if (close > open)
+    {
+        string temp = s;
+        temp += ')';
+        Generate_Parenthesis(open, close - 1, ans, temp);
+    }
+}
+int main()
+{
+    int n;
+    cin >> n;
+    vector<string> ans;
+    Generate_Parenthesis(n, n, ans, "");
+    for (int i = 0; i < ans.size(); i++)
+        cout << ans[i] << endl;
+}
\ No newline at end of file
diff --git a/Backtracking/Generate_parenthesis/Question.txt b/Backtracking/Generate_parenthesis/Question.txt
new file mode 100644
index 0000000..9012c1d
--- /dev/null
+++ b/Backtracking/Generate_parenthesis/Question.txt
@@ -0,0 +1,7 @@
+Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
+
+Sample Input
+n = 3
+
+Sample Output
+["((()))","(()())","(())()","()(())","()()()"]
\ No newline at end of file
diff --git a/Backtracking/SudokuSolver/Question.txt b/Backtracking/SudokuSolver/Question.txt
new file mode 100644
index 0000000..eadd651
--- /dev/null
+++ b/Backtracking/SudokuSolver/Question.txt
@@ -0,0 +1,20 @@
+Given a partially filled NxN 2D array, the goal is to assign digits (from 1 to 9) 
+to the empty cells (cells assigned O value) so that every row, column,and subgrid 
+of size 3×3 contains exactly one instance of the digits from 1 to 9. We provide the 
+value of N and a partially filled sudoku as input.
+
+Sample Input: 
+4
+3 4 1 0 0 2 0 0 0 0 2 0 0 1 4 3
+
+Sample Output:
+==============
+3 4 1 0 
+0 2 0 0 
+0 0 2 0 
+0 1 4 3 
+==============
+3 4 1 2 
+1 2 3 4 
+4 3 2 1 
+2 1 4 3 
diff --git a/Backtracking/SudokuSolver/sudokuSolver.cpp b/Backtracking/SudokuSolver/sudokuSolver.cpp
new file mode 100644
index 0000000..5013019
--- /dev/null
+++ b/Backtracking/SudokuSolver/sudokuSolver.cpp
@@ -0,0 +1,100 @@
+#include <iostream>
+#include <cmath>
+using namespace std;
+
+void print2D(int arr[][20], int M, int N) {
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            cout << arr[i][j] << " ";
+        }
+        cout << endl;
+    }
+}
+
+bool myfixed[20][20] = {};
+
+void input2D_soduku(int arr[][20], int M, int N)
+{
+    for (int i = 0; i < M; ++i)
+    {
+        for (int j = 0; j < N; ++j)
+        {
+            cin >> arr[i][j];
+            if (arr[i][j] != 0) myfixed[i][j] = true;  //so that our entry does not change
+        }
+    }
+}
+
+bool canPlace(int board[][20], int N, int x, int y, int num)
+{
+    //check along row && col
+    for (int i = 0; i < N; ++i)
+    {
+        if (board[x][i] == num) return false;   //check along row
+        if (board[i][y] == num) return false;   //check along col
+    }
+
+    //check in the box
+    int rootN = sqrt(N);
+    int boxRow = x / rootN;
+    int boxCol = y / rootN;
+    int startRow = boxRow * rootN;
+    int startCol = boxCol * rootN;
+
+    for (int r = startRow; r < startRow + rootN; ++r)
+    {
+        for (int c = startCol; c < startCol + rootN; ++c)
+        {
+            if (board[r][c] == num) return false;
+        }
+    }
+
+    return true;
+}
+
+
+bool solveSudoku(int board[][20], int N, int x, int y)
+{
+    if (x == N && y == 0) return true;   //we have reached row 4 ---->sudoku over
+
+    if (y == N) return solveSudoku(board, N, x + 1, 0);//stop y to go to column4-->goto nxt row
+
+    if (myfixed[x][y]) return solveSudoku(board, N, x , y + 1);
+
+    for (int num = 1; num <= N; ++num)
+    {
+        if (canPlace(board, N, x, y, num) == true)
+        {
+            board[x][y] = num;
+            bool isSuccessful = solveSudoku(board, N, x , y + 1);  //recursion for nxt columns
+            if (isSuccessful) return true;
+            else board[x][y] = 0;
+        }
+    }
+    return false;
+}
+
+int main()
+{
+    int board[20][20] = {};
+
+    int N;
+    cin >> N;
+    input2D_soduku(board, N, N);
+    for(int i=0;i<N;i++){
+        for(int j=0;j<N;j++){
+              cin>>board[i][j];
+        }
+    }
+    cout << "==============\n";
+
+    print2D(board, N, N);
+    
+    cout << "==============\n";
+
+    solveSudoku(board, N, 0, 0);
+
+    print2D(board, N, N);
+    
+}
+
diff --git a/Armstrong No/armstrongnum.c b/Basic Math/Armstrong No/armstrongnum.c
similarity index 100%
rename from Armstrong No/armstrongnum.c
rename to Basic Math/Armstrong No/armstrongnum.c
diff --git a/Basic Math/Average/Average-Question.txt b/Basic Math/Average/Average-Question.txt
new file mode 100644
index 0000000..2087165
--- /dev/null
+++ b/Basic Math/Average/Average-Question.txt	
@@ -0,0 +1,81 @@
+Problem Name: Average
+
+You are given a sequence of integers a1, a2, ..., aN. An element ak is said to be an average element if there are indices i, j (with i ≠ j) such that ak = (ai + aj) / 2.
+
+In the sequence
+
+3  7  10  22  17  15
+
+for i=1, j=5 and k=3, we get ak = (ai + aj)/2. Thus a3 = 10 is an average element in this sequence. You can check that a3 is the only average element in this sequence.
+
+Consider the sequence
+
+3  7  10  3  18
+
+With i=1, j=4 and k=1 we get ak = (ai +aj)/2. Thus a1=3 is an average element. We could also choose i=1, j=4 and k=4 and get ak=(ai +aj)/2. You can check that a1 and a4 are the only average elements of this sequence.
+
+On the other hand, the sequence
+
+3  8  11  17  30
+
+has no average elements.
+
+Your task is to count the number of average elements in the given sequence.
+
+Input format
+
+The first line contains a single integer N indicating the number of elements in the sequence. This is followed by N lines containing one integer each (Line i+1 contains ai). (You may assume that ai + aj would not exceed MAXINT for any i and j).
+
+Output format
+
+The output must consist of a single line containing a single integer k indicating the number of average elements in the given sequence.
+
+Test Data:
+
+You may assume that N ≤ 10000. Further, you may assume that in 30% of the inputs N ≤ 200 and that in 60% of the inputs N ≤ 5000.
+
+Example:
+
+We illustrate the input and output format using the above examples:
+
+Sample Input 1:
+
+6
+3
+7
+10
+17
+22
+15
+
+Sample Output 1:
+
+1
+
+Sample Input 2:
+
+5
+3
+7
+10
+3
+18
+
+Sample Output 2:
+
+2
+
+Sample Input 3;
+
+5
+3
+8
+11
+17
+30
+
+Sample Output 3:
+
+0
+PROBLEM 2 avgBasics
+Create a program to calculate the average of some integers taken input from user. 
diff --git a/Basic Math/Average/Solution.cpp b/Basic Math/Average/Solution.cpp
new file mode 100644
index 0000000..eb8767c
--- /dev/null
+++ b/Basic Math/Average/Solution.cpp	
@@ -0,0 +1,56 @@
+#include<iostream>
+#include<algorithm>
+int arr[100000];
+using namespace std;
+int main()
+{
+        int n;
+        cin>>n;
+        for(int h=0;h<n;h++)
+        cin>>arr[h];
+        sort(arr,arr+n);
+        int count=0;
+        for(int i=0;i<n;i++)
+        {
+                if(arr[i]==arr[i-1] || arr[i]==arr[i+1])
+                count++;
+                else
+                {
+                        int l=i-1,h=i+1;
+                        while(l>=0 && h<n)
+                        {
+                                int sum=arr[l]+arr[h];
+                                if(sum==arr[i]*2)
+                                {count++;break;}
+                                else if(sum<arr[i]*2)
+                                ++h;
+                                else
+                                --l;
+                        }
+                }
+        }
+        cout<<count<<endl;
+        return 0;
+}
+
+
+avgBasic Solution:
+//Let's take the average of any 5 numbers
+#include <iostream>
+
+using namespace std;
+int main()
+{int x;
+float total=0;
+int num=0;
+
+
+while (num<5){
+ cin>>x;
+ total=total+x;
+ num=num+1;
+}
+float avgBasic= total/num;
+cout<<avgBasic;
+return 0;
+}
diff --git a/Basic Math/Counting-Change-Combinations/counting.txt b/Basic Math/Counting-Change-Combinations/counting.txt
new file mode 100644
index 0000000..e7aba7c
--- /dev/null
+++ b/Basic Math/Counting-Change-Combinations/counting.txt	
@@ -0,0 +1,13 @@
+Write a function that counts how many different ways you can make change for an amount of money, given an array of coin denominations. For example, there are 3 ways to give change for 4 if you have coins with denomination 1 and 2:
+
+1+1+1+1, 1+1+2, 2+2.
+The order of coins does not matter:
+
+1+1+2 == 2+1+1
+Also, assume that you have an infinite amount of coins.
+
+Your function should take an amount to change and an array of unique denominations for the coins:
+
+  countChange(4, [1,2]) // => 3
+  countChange(10, [5,2,3]) // => 4
+  countChange(11, [5,7]) //  => 0
\ No newline at end of file
diff --git a/Basic Math/Counting-Change-Combinations/solution.js b/Basic Math/Counting-Change-Combinations/solution.js
new file mode 100644
index 0000000..fcb7e85
--- /dev/null
+++ b/Basic Math/Counting-Change-Combinations/solution.js	
@@ -0,0 +1,24 @@
+let countChange = function(money, coins) {
+  if (coins.length === 0) {
+      return 0;
+  }
+
+  coins = coins.slice(0).sort();
+  let result = 0,
+      largestCoin = coins.pop(),
+      maxCount = 0;
+  let maxRemain = money % largestCoin;
+
+  if (maxRemain === 0) {
+      result++;
+      maxCount = money / largestCoin - 1;
+  } else {
+      maxCount = (money - maxRemain) / largestCoin;
+  }
+
+  for (let i = maxCount; i >= 0; i--) {
+      result += countChange(money - largestCoin * i, coins);
+  }
+
+  return result;
+}
\ No newline at end of file
diff --git a/Basic Math/Divisibility_Check/Question.txt b/Basic Math/Divisibility_Check/Question.txt
new file mode 100644
index 0000000..e063616
--- /dev/null
+++ b/Basic Math/Divisibility_Check/Question.txt	
@@ -0,0 +1,7 @@
+You are given an array of integers. Check whether there exists a number in this array which is divisible by all other numbers in this array. Output 1, if such a number exists, and 0 otherwise.
+
+Input
+The only line of the input contains a list of space-separated integers ai (1 ≤ ai ≤ 100) — elements of the array. The size of the array is between 2 and 10, inclusive. Note that the size of the array is not given explicitly!
+
+Output
+Output 1 if there exists element of this array which is divisible by all other elements of the array, and 0 otherwise.
\ No newline at end of file
diff --git a/Basic Math/Divisibility_Check/Solution.cpp b/Basic Math/Divisibility_Check/Solution.cpp
new file mode 100644
index 0000000..4f6298d
--- /dev/null
+++ b/Basic Math/Divisibility_Check/Solution.cpp	
@@ -0,0 +1,48 @@
+#include<bits/stdc++.h>
+using namespace std;
+int main()
+{
+	char amp[100];
+	cin.getline(amp,99,'\n');
+	int len=strlen(amp);
+
+
+	int arr[10]={0};
+
+	int count=0,i=0;
+	int start=0;
+	for(int l=start;l<=len;l++)
+	{
+
+		if(amp[l]==' ' || amp[l]=='\0')
+		{
+			//cout<<"hi "<<l<<" "<<start<<" ";
+			count++;
+			for(int m=l-1,n=0;m>=start;m--,n++)
+			{
+				arr[i]+= (amp[m]-'0')*pow(10,n);
+
+			}
+
+			if(l==len)
+				break;
+		i++;	
+		start=l+1;
+		}
+
+	}
+	
+	sort(arr,arr+count);
+	int ans=1;
+	for(int a=count-2;a>=0;a--)
+	{
+		if(arr[count-1]%arr[a]!=0)
+		{
+			ans=0;
+			break;
+		}
+	}
+
+	cout<<ans;
+	return 0;
+}
\ No newline at end of file
diff --git a/Basic Math/Divisible Sum Pairs/Problem Description.txt b/Basic Math/Divisible Sum Pairs/Problem Description.txt
new file mode 100644
index 0000000..1ffa981
--- /dev/null
+++ b/Basic Math/Divisible Sum Pairs/Problem Description.txt	
@@ -0,0 +1,2 @@
+You are given an array of n integers, ar = [ar[0], ar[1], ... , ar[n-1]], and a positive integer k. Find and print the number of
+(i,j) pairs where i < j and ar[i]+ar[j] is divisible by k.
diff --git a/Basic Math/Divisible Sum Pairs/solution.js b/Basic Math/Divisible Sum Pairs/solution.js
new file mode 100644
index 0000000..7c65521
--- /dev/null
+++ b/Basic Math/Divisible Sum Pairs/solution.js	
@@ -0,0 +1,12 @@
+function divisibleSumPairs(n, k, ar) {
+    let count =0;
+    for(let i=0; i<n; i++){
+        for(let j=i+1; j< n; j++){
+            if( (ar[i]+ar[j]) % k === 0){
+                count++;
+            }
+        }
+    }
+    return count;
+
+}
diff --git a/Basic Math/Fizz Buzz/c#_solution.cs b/Basic Math/Fizz Buzz/c#_solution.cs
new file mode 100644
index 0000000..dd025df
--- /dev/null
+++ b/Basic Math/Fizz Buzz/c#_solution.cs	
@@ -0,0 +1,30 @@
+using System;
+
+namespace FizzBuzz
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            for (int i = 1; i <= 100; i++)
+            {
+                if (i % 15 == 0)
+                {
+                    Console.WriteLine("FizzBuzz");
+                }
+                else if (i % 3 == 0)
+                {
+                    Console.WriteLine("Fizz");
+                }
+                else if (i % 5 == 0)
+                {
+                    Console.WriteLine("Buzz");
+                }
+                else
+                {
+                    Console.WriteLine(i);
+                }
+            }
+        }
+    }
+}
diff --git a/Basic Math/Fizz Buzz/dart_solution.dart b/Basic Math/Fizz Buzz/dart_solution.dart
new file mode 100644
index 0000000..65bf16f
--- /dev/null
+++ b/Basic Math/Fizz Buzz/dart_solution.dart	
@@ -0,0 +1,13 @@
+main() {
+  for (int i = 1; i <= 100; i++) {
+    if (i % 15 == 0) {
+      print('fizzbuzz');
+    } else if (i % 5 == 0) {
+      print('buzz');
+    } else if (i % 3 == 0) {
+      print('fizz');
+    } else {
+      print(i);
+    }
+  }
+}
diff --git a/Basic Math/Fizz Buzz/fizzbuzz.c b/Basic Math/Fizz Buzz/fizzbuzz.c
new file mode 100644
index 0000000..387cf17
--- /dev/null
+++ b/Basic Math/Fizz Buzz/fizzbuzz.c	
@@ -0,0 +1,12 @@
+#include<stdio.h>
+void main()
+{
+    int i;
+    for(i=1;i<=100;i++)
+    {
+        if(i%3!=0 && i%5!=0) printf("%d\n", i);
+        if(i%3 == 0 && i%5!=0)printf("Fizz\n");
+        if(i%5 == 0 && i%3!=0)printf("Buzz\n");
+        if(i%5 == 0 && i%3==0)printf("FizzBuzz\n");
+    }
+}
diff --git a/Basic Math/Fizz Buzz/fizzbuzz.cpp b/Basic Math/Fizz Buzz/fizzbuzz.cpp
new file mode 100644
index 0000000..4d6c904
--- /dev/null
+++ b/Basic Math/Fizz Buzz/fizzbuzz.cpp	
@@ -0,0 +1,16 @@
+#include <iostream>
+using namespace std;
+int main()
+{
+    for(int i=1;i<=100;i++){
+        if((i%3 == 0) && (i%5==0))
+            cout<<"FizzBuzz\n";
+        else if(i%3 == 0)
+            cout<<"Fizz\n";
+        else if(i%5 == 0)
+            cout<<"Buzz\n";
+        else
+            cout<<i<<"\n";
+     }
+    return 0;
+}
diff --git a/Basic Math/Fizz Buzz/instructions.txt b/Basic Math/Fizz Buzz/instructions.txt
new file mode 100644
index 0000000..f70346d
--- /dev/null
+++ b/Basic Math/Fizz Buzz/instructions.txt	
@@ -0,0 +1,3 @@
+Fizzbuzz
+
+Given 100 numbers, replace any number divisible by three with the word "fizz", any number divisible by five with the word "buzz", and any number divisible by fifteen with the word "fizzbuzz".
diff --git a/Basic Math/Fizz Buzz/javascript_solution.js b/Basic Math/Fizz Buzz/javascript_solution.js
new file mode 100644
index 0000000..0efeb3c
--- /dev/null
+++ b/Basic Math/Fizz Buzz/javascript_solution.js	
@@ -0,0 +1,10 @@
+for (var i=1; i <= 100; i++){
+  if (i % 3 == 0 && i% 5 == 0)
+    console.log("fizzbuzz");
+  else if (i % 3 == 0)
+    console.log("fizz");
+  else if (i % 5 == 0)
+    console.log("buzz");
+  else
+    console.log(i);
+}
diff --git a/Basic Math/Fizz Buzz/php_solution.php b/Basic Math/Fizz Buzz/php_solution.php
new file mode 100644
index 0000000..c3e1489
--- /dev/null
+++ b/Basic Math/Fizz Buzz/php_solution.php	
@@ -0,0 +1,13 @@
+<?php
+for ($i = 1; $i <= 100; $i++)
+{
+    if (!($i % 15))
+        echo "fizzbuzz\n";
+    else if (!($i % 3))
+        echo "fizz\n";
+    else if (!($i % 5))
+        echo "buzz\n";
+    else
+        echo "$i\n";
+}
+?>
diff --git a/Basic Math/Fizz Buzz/python_solution.py b/Basic Math/Fizz Buzz/python_solution.py
new file mode 100644
index 0000000..a770bbf
--- /dev/null
+++ b/Basic Math/Fizz Buzz/python_solution.py	
@@ -0,0 +1,9 @@
+for x in range(1, 100):
+    if (x % 15 == 0):
+        print "fizzbuzz"
+    elif x % 3 == 0:
+        print "fizz"
+    elif x % 5 == 0:
+        print "buzz"
+    else:
+        print x
diff --git a/Basic Math/Fizz Buzz/ruby_solution.rb b/Basic Math/Fizz Buzz/ruby_solution.rb
new file mode 100644
index 0000000..1d4bfee
--- /dev/null
+++ b/Basic Math/Fizz Buzz/ruby_solution.rb	
@@ -0,0 +1,14 @@
+counter = 0
+
+while counter < 100
+counter += 1
+  if (counter % 3 == 0) && (counter % 5 == 0)
+    puts("Fizz Buzz")
+  elsif counter % 3 == 0
+    puts("Fizz")
+  elsif (counter % 5 == 0)
+    puts("Buzz")
+  else puts(counter)
+  end
+end
+break
diff --git a/Basic Math/Is prime/problem.txt b/Basic Math/Is prime/problem.txt
new file mode 100644
index 0000000..7357bc2
--- /dev/null
+++ b/Basic Math/Is prime/problem.txt	
@@ -0,0 +1,9 @@
+Implement a function that determines if a given positive integer is a prime or not.
+
+Example
+
+For n = 47, the output should be
+isPrime(n) = true;
+
+For n = 4, the output should be
+isPrime(n) = false;
\ No newline at end of file
diff --git a/Basic Math/Is prime/solution.hs b/Basic Math/Is prime/solution.hs
new file mode 100644
index 0000000..05b33bc
--- /dev/null
+++ b/Basic Math/Is prime/solution.hs	
@@ -0,0 +1 @@
+isPrime n = length (filter (==0) (map (mod n) [1..n])) == 2 
\ No newline at end of file
diff --git a/Basic Math/Is prime/solution.js b/Basic Math/Is prime/solution.js
new file mode 100644
index 0000000..292a44a
--- /dev/null
+++ b/Basic Math/Is prime/solution.js	
@@ -0,0 +1,12 @@
+function isPrime(n) {
+    if(n<2) return false
+    let prime = true
+    for (let i = 2; i*i<= n; i++) {
+        if( n%i == 0) {
+            prime = false
+            break
+        }
+    }
+
+    return prime
+}
diff --git a/Basic Math/Least_Common_Multiple/LCM.cbl b/Basic Math/Least_Common_Multiple/LCM.cbl
new file mode 100644
index 0000000..ab35774
--- /dev/null
+++ b/Basic Math/Least_Common_Multiple/LCM.cbl	
@@ -0,0 +1,78 @@
+       IDENTIFICATION DIVISION.
+
+       PROGRAM-ID.LCM.
+
+       ENVIRONMENT DIVISION.
+
+       DATA DIVISION.
+
+       WORKING-STORAGE SECTION.
+
+       01 ARRAY.
+       02 A PIC 9(5) OCCURS 10 TIMES.
+       77 N PIC 9(2) VALUE 2.
+       77 I PIC 9(2).
+       77 J PIC 9(2).
+       77 Q PIC 9(3).
+       77 R PIC 9(3).
+       77 K PIC 9(5).
+       77 B PIC 9(3) VALUE 0.
+       77 C PIC 9(3) VALUE 0.
+       77 D PIC 9(3) VALUE 0.
+       77 P PIC Z(5)9.
+       01 num PIC 999 VALUE 0.
+       01 num2 PIC 999 VALUE 0.
+       01 chickens PIC 999 VALUE 0.
+       01 dogs PIC 999 VALUE 0.
+       01 total PIC 999 VALUE 0.
+       01 result PIC 99 VALUE 0.
+       01 result1 PIC 999 VALUE 0.
+       01 result2 PIC 999 VALUE 0.
+       01 count1 PIC 999 VALUE 0.
+
+       PROCEDURE DIVISION.
+
+       MAIN-PARA.
+           DISPLAY "ENTER " N " NUMBERS".
+           PERFORM X-PARA VARYING I FROM 1 BY 1 UNTIL I > N.
+           PERFORM Y-PARA VARYING I FROM B BY 1 UNTIL C = N.
+           MOVE K TO P.
+           DISPLAY "THE LCM IS " P.
+
+           DISPLAY "Enter Number of Head".
+           ACCEPT num.
+           DISPLAY "Enter number of legs".
+           ACCEPT num2.
+           PERFORM headleg-PARA.
+           if count1 equals 2 DISPLAY "NONE"
+           STOP RUN.
+
+       X-PARA.
+           ACCEPT A(I).
+           IF (B < A(I))
+           MOVE A(I) TO B.
+
+       Y-PARA.
+           MOVE 0 TO C.
+           COMPUTE D = D + 1.
+           PERFORM Z-PARA VARYING J FROM 1 BY 1 UNTIL J > N.
+
+       Z-PARA.
+           COMPUTE K = B * D.
+           DIVIDE K BY A(J) GIVING Q REMAINDER R.
+           IF (R = 0)
+           COMPUTE C = C + 1.
+
+       headleg-PARA.
+           PERFORM VARYING chickens FROM 0 BY 1 UNTIL chickens >= num
+           COMPUTE dogs = num - chickens
+           COMPUTE result =2 * chickens
+           COMPUTE result1 =4 * dogs
+           COMPUTE result2 = result + result1
+           IF result2 EQUALS num2
+               DISPLAY "[", chickens,",",dogs,"]"
+               SET count1 to 1
+           ELSE IF count1 equals to 1 set count1 to 1
+           else set count1 to 2
+           END-IF
+           END-PERFORM.
diff --git a/Basic Math/Least_Common_Multiple/Problem.txt b/Basic Math/Least_Common_Multiple/Problem.txt
new file mode 100644
index 0000000..83e009c
--- /dev/null
+++ b/Basic Math/Least_Common_Multiple/Problem.txt	
@@ -0,0 +1,6 @@
+## Problem:
+
+The LCM of two integers n1 and n2 is the smallest positive integer that is perfectly 
+divisible by both n1 and n2 (without a remainder). For example: the LCM of 72 and 120 is 360.
+
+write a program written in COBOL that will compute the LCM of 2 numbers
diff --git a/Basic Math/Number to Words/number_to_words.CPP b/Basic Math/Number to Words/number_to_words.CPP
new file mode 100644
index 0000000..94e3047
--- /dev/null
+++ b/Basic Math/Number to Words/number_to_words.CPP	
@@ -0,0 +1,62 @@
+//Converts any number between 0-9999 (inclusive) to words 
+//till 4 digits only
+
+#include<conio.h>
+#include<iostream.h>
+
+void words(int n, int c, int r)
+{
+  if(n==0 && c==1)
+  {
+     cout<<"Zero"<<endl;
+     return;
+  }
+  if(!r)
+     return;
+
+  char singled[][10]={"one","two","three","four","five","six","seven","eight","nine"};
+  char ones[][20]={"eleven","twelve","thirteen"};
+  char doubled[][10]={"ten","twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"};
+ // char threed[][10]={"hunderd","thousand"};
+
+  switch(c)
+  {
+     case 1: cout<<" "<<singled[r-1];
+	     break;
+     case 2: if(n>=20 || n==10)
+	     {
+	       cout<<" "<<doubled[r%10-1];
+	       words(n/10,c-1,r/10);
+	     }
+	     else if(n>=14)
+	       cout<<" "<<singled[r%10-1]<<"teen";
+	     else
+	       cout<<" "<<ones[n%10-1];
+	     break;
+     case 3: words(n,1,r%10);
+	     cout<<" "<<"hundred";
+	     words(n%100,c-1,r/10);
+	     break;
+     case 4: words(n,1,r%10);
+	     cout<<" "<<"thousand";
+	     words(n%1000,c-1,r/10);
+	     break;
+  }
+}
+void main()
+{
+  clrscr();
+  cout<<"Enter a number: ";
+  int n;
+  cin>>n;
+  int n1=n;
+  int count=0, rev=0;
+  while(n1!=0)
+  {
+    rev=rev*10+(n1%10);
+    count++;
+    n1=n1/10;
+  }
+  words(n,count,rev);
+  getch();
+}
\ No newline at end of file
diff --git a/Basic Math/Number to Words/problem_definition.txt b/Basic Math/Number to Words/problem_definition.txt
new file mode 100644
index 0000000..0e39580
--- /dev/null
+++ b/Basic Math/Number to Words/problem_definition.txt	
@@ -0,0 +1,4 @@
+Write code to convert a given number into words. 
+For example, 
+if “1234� is given as input
+output should be “one thousand two hundred thirty four�.
\ No newline at end of file
diff --git a/Basic Math/Octal Decimal Calculator/Octal Decimal Calculator.txt b/Basic Math/Octal Decimal Calculator/Octal Decimal Calculator.txt
new file mode 100644
index 0000000..0ff00e0
--- /dev/null
+++ b/Basic Math/Octal Decimal Calculator/Octal Decimal Calculator.txt	
@@ -0,0 +1,9 @@
+Given an octal number it is required to convert to decimal and print it on the console
+
+Example:
+
+The octal number 567 is entered.
+
+The system calculates the equivalent number in decimal that is 375 and prints it on the console
+
+The decimal number for octal 567 is: 357
\ No newline at end of file
diff --git a/Basic Math/Octal Decimal Calculator/OctalDecimalCalculator.java b/Basic Math/Octal Decimal Calculator/OctalDecimalCalculator.java
new file mode 100644
index 0000000..dac72a3
--- /dev/null
+++ b/Basic Math/Octal Decimal Calculator/OctalDecimalCalculator.java	
@@ -0,0 +1,43 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class OctalDecimalCalculator {
+
+    private static int BASE_8 = 8;
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private static final String RESULT_TEMPLATE = "The decimal number for octal %s is: %s";
+
+    public static void main(String[] args){
+
+        System.out.println("Please input octal number to convert");
+        try {
+            String octal = br.readLine();
+            String decimal = convertOctalToDecimal(Integer.parseInt(octal));
+
+            System.out.println(String.format(RESULT_TEMPLATE, octal, decimal));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    public static String convertOctalToDecimal(int octal){
+        int result = 0;
+        String tmp =  String.valueOf(octal);
+        int count = 0;
+        int multiple;
+        String caracter;
+        for (int i = tmp.length(); i > 0; i--) {
+            caracter = tmp.substring(i-1, i);
+            multiple = (int) Math.pow(BASE_8, count);
+            int value = (Integer.parseInt(caracter) * multiple);
+            count = count + 1;
+            result += value;
+
+        }
+
+        return String.valueOf(result);
+    }
+
+}
diff --git a/Basic Math/Odd or Even Game/.idea/Odd or Even Game.iml b/Basic Math/Odd or Even Game/.idea/Odd or Even Game.iml
new file mode 100644
index 0000000..68d86b9
--- /dev/null
+++ b/Basic Math/Odd or Even Game/.idea/Odd or Even Game.iml	
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.6 (cursoemvideo)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="TestRunnerService">
+    <option name="PROJECT_TEST_RUNNER" value="Unittests" />
+  </component>
+</module>
\ No newline at end of file
diff --git a/Basic Math/Odd or Even Game/.idea/misc.xml b/Basic Math/Odd or Even Game/.idea/misc.xml
new file mode 100644
index 0000000..191aa28
--- /dev/null
+++ b/Basic Math/Odd or Even Game/.idea/misc.xml	
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.6 (cursoemvideo)" project-jdk-type="Python SDK" />
+</project>
\ No newline at end of file
diff --git a/Basic Math/Odd or Even Game/.idea/modules.xml b/Basic Math/Odd or Even Game/.idea/modules.xml
new file mode 100644
index 0000000..88a00c5
--- /dev/null
+++ b/Basic Math/Odd or Even Game/.idea/modules.xml	
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Odd or Even Game.iml" filepath="$PROJECT_DIR$/.idea/Odd or Even Game.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/Basic Math/Odd or Even Game/.idea/vcs.xml b/Basic Math/Odd or Even Game/.idea/vcs.xml
new file mode 100644
index 0000000..6c0b863
--- /dev/null
+++ b/Basic Math/Odd or Even Game/.idea/vcs.xml	
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/Basic Math/Odd or Even Game/.idea/workspace.xml b/Basic Math/Odd or Even Game/.idea/workspace.xml
new file mode 100644
index 0000000..1a68506
--- /dev/null
+++ b/Basic Math/Odd or Even Game/.idea/workspace.xml	
@@ -0,0 +1,182 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="8c90baa2-a62a-44cc-9982-f18a94110d1f" name="Default Changelist" comment="">
+      <change afterPath="$PROJECT_DIR$/.idea/Odd or Even Game.iml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/.idea/misc.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/.idea/modules.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/.idea/vcs.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/OddEvenGame.txt" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/oddEvenGame.py" afterDir="false" />
+    </list>
+    <option name="EXCLUDED_CONVERTED_TO_IGNORED" value="true" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="FileEditorManager">
+    <leaf>
+      <file pinned="false" current-in-tab="false">
+        <entry file="file://$PROJECT_DIR$/OddEvenGame.txt">
+          <provider selected="true" editor-type-id="text-editor">
+            <state relative-caret-position="24">
+              <caret line="1" selection-start-line="1" selection-end-line="1" />
+            </state>
+          </provider>
+        </entry>
+      </file>
+      <file pinned="false" current-in-tab="true">
+        <entry file="file://$PROJECT_DIR$/oddEvenGame.py">
+          <provider selected="true" editor-type-id="text-editor">
+            <state relative-caret-position="389">
+              <caret line="24" lean-forward="true" selection-start-line="24" selection-end-line="24" />
+            </state>
+          </provider>
+        </entry>
+      </file>
+    </leaf>
+  </component>
+  <component name="FileTemplateManagerImpl">
+    <option name="RECENT_TEMPLATES">
+      <list>
+        <option value="Python Script" />
+      </list>
+    </option>
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/.." />
+  </component>
+  <component name="IdeDocumentHistory">
+    <option name="CHANGED_PATHS">
+      <list>
+        <option value="$PROJECT_DIR$/OddEvenGame.txt" />
+        <option value="$PROJECT_DIR$/oddEvenGame.py" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectFrameBounds" extendedState="6">
+    <option name="x" value="205" />
+    <option name="y" value="27" />
+    <option name="width" value="1161" />
+    <option name="height" value="636" />
+  </component>
+  <component name="ProjectLevelVcsManager" settingsEditedManually="true">
+    <ConfirmationsSetting value="2" id="Add" />
+  </component>
+  <component name="ProjectView">
+    <navigator proportions="" version="1">
+      <foldersAlwaysOnTop value="true" />
+    </navigator>
+    <panes>
+      <pane id="Scope" />
+      <pane id="ProjectPane">
+        <subPane>
+          <expand>
+            <path>
+              <item name="Odd or Even Game" type="b2602c69:ProjectViewProjectNode" />
+              <item name="Odd or Even Game" type="462c0819:PsiDirectoryNode" />
+            </path>
+          </expand>
+          <select />
+        </subPane>
+      </pane>
+    </panes>
+  </component>
+  <component name="PropertiesComponent">
+    <property name="SHARE_PROJECT_CONFIGURATION_FILES" value="true" />
+    <property name="last_opened_file_path" value="$PROJECT_DIR$" />
+    <property name="settings.editor.selected.configurable" value="com.jetbrains.python.configuration.PyActiveSdkModuleConfigurable" />
+  </component>
+  <component name="RunDashboard">
+    <option name="ruleStates">
+      <list>
+        <RuleState>
+          <option name="name" value="ConfigurationTypeDashboardGroupingRule" />
+        </RuleState>
+        <RuleState>
+          <option name="name" value="StatusDashboardGroupingRule" />
+        </RuleState>
+      </list>
+    </option>
+  </component>
+  <component name="RunManager">
+    <configuration name="oddEvenGame" type="PythonConfigurationType" factoryName="Python" temporary="true">
+      <module name="Odd or Even Game" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/oddEvenGame.py" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
+    <recent_temporary>
+      <list>
+        <item itemvalue="Python.oddEvenGame" />
+      </list>
+    </recent_temporary>
+  </component>
+  <component name="SvnConfiguration">
+    <configuration />
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="8c90baa2-a62a-44cc-9982-f18a94110d1f" name="Default Changelist" comment="" />
+      <created>1569982199373</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1569982199373</updated>
+    </task>
+    <servers />
+  </component>
+  <component name="ToolWindowManager">
+    <frame x="67" y="25" width="1299" height="743" extended-state="6" />
+    <layout>
+      <window_info id="Favorites" side_tool="true" />
+      <window_info content_ui="combo" id="Project" order="0" visible="true" weight="0.24940991" />
+      <window_info id="Structure" order="1" side_tool="true" weight="0.25" />
+      <window_info anchor="bottom" id="Version Control" />
+      <window_info anchor="bottom" id="Python Console" />
+      <window_info anchor="bottom" id="Terminal" />
+      <window_info anchor="bottom" id="Event Log" side_tool="true" />
+      <window_info anchor="bottom" id="Message" order="0" />
+      <window_info anchor="bottom" id="Find" order="1" />
+      <window_info anchor="bottom" id="Run" order="2" weight="0.32996634" />
+      <window_info anchor="bottom" id="Debug" order="3" weight="0.4" />
+      <window_info anchor="bottom" id="Cvs" order="4" weight="0.25" />
+      <window_info anchor="bottom" id="Inspection" order="5" weight="0.4" />
+      <window_info anchor="bottom" id="TODO" order="6" />
+      <window_info anchor="right" id="Commander" internal_type="SLIDING" order="0" type="SLIDING" weight="0.4" />
+      <window_info anchor="right" id="Ant Build" order="1" weight="0.25" />
+      <window_info anchor="right" content_ui="combo" id="Hierarchy" order="2" weight="0.25" />
+    </layout>
+  </component>
+  <component name="editorHistoryManager">
+    <entry file="file://$PROJECT_DIR$/OddEvenGame.txt">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="24">
+          <caret line="1" selection-start-line="1" selection-end-line="1" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/oddEvenGame.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="389">
+          <caret line="24" lean-forward="true" selection-start-line="24" selection-end-line="24" />
+        </state>
+      </provider>
+    </entry>
+  </component>
+</project>
\ No newline at end of file
diff --git a/Basic Math/Odd or Even Game/OddEvenGame.txt b/Basic Math/Odd or Even Game/OddEvenGame.txt
new file mode 100644
index 0000000..8756e4a
--- /dev/null
+++ b/Basic Math/Odd or Even Game/OddEvenGame.txt	
@@ -0,0 +1 @@
+Play againt the pc an Odd and Even game.
diff --git a/Basic Math/Odd or Even Game/oddEvenGame.py b/Basic Math/Odd or Even Game/oddEvenGame.py
new file mode 100644
index 0000000..77f4465
--- /dev/null
+++ b/Basic Math/Odd or Even Game/oddEvenGame.py	
@@ -0,0 +1,24 @@
+import random
+chose = int(input("Type 1-Odd or 2-Even: "))
+number = int(input("Type your number (between 0 or 5: "))
+
+pcnumber = random.randint(0, 5)
+
+result = number + pcnumber
+
+if result % 2 == 0 and chose == 1:
+    print(f"You selected {chose}")
+    print(f"My number: {pcnumber} and your number: {number}")
+    print("I won! Try again!")
+elif result % 2 == 0 and chose == 2:
+    print(f"You selected {chose}")
+    print(f"My number: {pcnumber} and your number: {number}")
+    print("You won! Well done!")
+elif result % 2 == 1 and chose == 1:
+    print(f"You selected {chose}")
+    print(f"My number: {pcnumber} and your number: {number}")
+    print("I won! Try again!")
+else:
+    print(f"You selected {chose}")
+    print(f"My number: {pcnumber} and your number: {number}")
+    print("You won! Well done!")
diff --git a/Basic Math/PROXY/question.txt b/Basic Math/PROXY/question.txt
new file mode 100644
index 0000000..aeecadd
--- /dev/null
+++ b/Basic Math/PROXY/question.txt	
@@ -0,0 +1,33 @@
+Chef is a brilliant university student that does not attend lectures because he believes that they are boring and coding is life! However, his university follows certain rules and regulations, and a student may only take an exam for a course if he has attended at least 75% of lectures for this course.
+
+Since you are Chef's best friend, you want to help him reach the attendance he needs to take exams. Unfortunately, Chef is still focused on his code and refuses to attend more lectures, so the only option is to have some of his friends mark him as present by proxy. This trick is well-known in the university, but only few have the talent to pull it off.
+
+In a certain course, there is exactly one lesson per day over the course of D days (numbered 1 through D). You are given a string S with length D describing the lessons Chef attended — for each valid i, the i-th character of this string is either 'A' if Chef was absent on day i or 'P' if Chef was actually present on day i.
+
+For each day d when Chef is absent, one of Chef's friends can mark him as present by proxy on this day only if he was present (if he was really present, not just marked as present) on at least one of the previous two days, i.e. days d−1 and d−2, and on at least one of the following two days, i.e. days d+1 and d+2. However, it is impossible to mark him as present by proxy on the first two days and the last two days.
+
+Find the minimum number of times Chef has to be marked as present by proxy so that his attendance becomes at least 75% (0.75). Chef's attendance is number of days when he was marked as present, either by proxy or by actually being present, divided by D.
+
+Input
+The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
+The first line of each test case contains a single integer D.
+The second line contains a single string S with length D.
+
+Output
+For each test case, print a single line containing one integer — the minimum number of times Chef needs to be marked as present by proxy, or −1 if it is impossible to make Chef achieve 75% attendance.
+
+Constraints
+1≤T≤200
+1≤D≤1,000
+S contains only characters 'A' and 'P'
+Subtasks
+Subtask #1 (100 points): original constraints
+
+Example Input
+1
+9
+PAAPPAPPP
+Example Output
+1
+Explanation
+Example case 1: With a proxy on the third day, the attendance string is "PAPPPAPPP". Now, Chef's attendance is at least 75%, so the minimum number of times Chef needs to be marked as present by proxy is 1.
\ No newline at end of file
diff --git a/Basic Math/PROXY/solution.cpp b/Basic Math/PROXY/solution.cpp
new file mode 100644
index 0000000..9eb5c92
--- /dev/null
+++ b/Basic Math/PROXY/solution.cpp	
@@ -0,0 +1,49 @@
+#include<iostream>
+using namespace std;
+
+float att(int act,int cnt,int d){
+    float t = (double)cnt/d;
+     if(t>=0.75)
+       cout<<cnt-act<<endl;
+    return t;
+}
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int d,cnt=0,i=0,flag=0;
+        cin>>d;
+              char s[d];
+              cin >> s;
+
+
+        //count of present
+        for(i=0;i<d;i++){
+            if(s[i]=='P')
+            cnt++;
+        }
+
+        int act = cnt;
+
+           
+                
+            if(att(act,cnt,d)<0.75){
+            for(i=2;i<d-2;i++){
+                if((s[i]=='A') && (s[i-1]=='P' || s[i-2]=='P') && (s[i+1]=='P' || s[i+2]=='P'))
+                {
+                    cnt++;
+                    if(att(act,cnt,d)>=0.75){
+                        flag=1;
+                        break;
+                    }
+                  
+                }
+            }
+            if(flag==0)
+            cout<<-1<<endl;
+            }
+            
+    }
+    return 0;
+}
diff --git a/Basic Math/Prime_gen/Prime Generator(prime_gen) b/Basic Math/Prime_gen/Prime Generator(prime_gen)
new file mode 100644
index 0000000..ca6de20
--- /dev/null
+++ b/Basic Math/Prime_gen/Prime Generator(prime_gen)	
@@ -0,0 +1,3 @@
+Prime Generator(prime_gen)
+
+Question/purpose. This program generates primes numbers.
\ No newline at end of file
diff --git a/Basic Math/Prime_gen/prime_gen.cpp b/Basic Math/Prime_gen/prime_gen.cpp
new file mode 100644
index 0000000..e41f4ae
--- /dev/null
+++ b/Basic Math/Prime_gen/prime_gen.cpp	
@@ -0,0 +1,39 @@
+    #include<iostream>
+    #include<cmath>
+     
+    using namespace std;
+     
+    int main()
+    {
+       int n, status = 1, num = 3, count, c;
+     
+       cout << "Enter the number of Prime numbers to be generated\n";
+       cin >> n;
+     
+       if ( n >= 1 )
+       {
+          cout << "First " << n <<" Prime numbers are :-" << endl;
+          cout << 2 << endl;
+       }
+     
+       for ( count = 2 ; count <=n ;  )
+       {
+          for ( c = 2 ; c <= (int)sqrt(num) ; c++ )
+          {
+             if ( num%c == 0 )
+             {
+                status = 0;
+                break;
+             }
+          }
+          if ( status != 0 )
+          {
+             cout << num << endl;
+             count++;
+          }
+          status = 1;
+          num++;
+       }        
+       
+       return 0;
+    }
\ No newline at end of file
diff --git a/Basic Math/Save the Prisoner!/question.txt b/Basic Math/Save the Prisoner!/question.txt
new file mode 100644
index 0000000..0d33d53
--- /dev/null
+++ b/Basic Math/Save the Prisoner!/question.txt	
@@ -0,0 +1,60 @@
+A jail has a number of prisoners and a number of treats to pass out to them. Their jailer decides the fairest way to divide the treats is to seat the prisoners around a circular table in sequentially numbered chairs. A chair number will be drawn from a hat. Beginning with the prisoner in that chair, one candy will be handed to each prisoner sequentially around the table until all have been distributed.
+
+The jailer is playing a little joke, though. The last piece of candy looks like all the others, but it tastes awful. Determine the chair number occupied by the prisoner who will receive that candy.
+
+For example, there are 4  prisoners and 6  pieces of candy. The prisoners arrange themselves in seats numbered 1 to 4. Let's suppose two is drawn from the hat. Prisoners receive candy at positions 2,3,4,1,2,3. The prisoner to be warned sits in chair number 3.
+
+Function Description
+
+Complete the saveThePrisoner function in the editor below. It should return an integer representing the chair number of the prisoner to warn.
+
+saveThePrisoner has the following parameter(s):
+
+n: an integer, the number of prisoners
+m: an integer, the number of sweets
+s: an integer, the chair number to begin passing out sweets from
+Input Format
+
+The first line contains an integer, t, denoting the number of test cases.
+The next t lines each contain 3 space-separated integers:
+-n : the number of prisoners
+-m : the number of sweets
+-s : the chair number to start passing out treats at
+
+Constraints
+- 1<=t<=100
+- 1<=n<=1000000000
+- 1<=m<=1000000000
+- 1<=s<=n
+Output Format
+
+For each test case, print the chair number of the prisoner who receives the awful treat on a new line.
+
+Sample Input 0
+
+2
+5 2 1
+5 2 2
+Sample Output 0
+
+2
+3
+Explanation 0
+
+In first query, there are n=5 prisoners and m=2 sweets. Distribution starts at seat number s=1. Prisoners in seats numbered 1 and 2 get sweets. Warn prisoner 2.
+In the second query, distribution starts at seat 2 so prisoners in seats 2 and 3 get sweets. Warn prisoner 3.
+
+Sample Input 1
+
+2
+7 19 2
+3 7 3
+Sample Output 1
+
+6
+3
+Explanation 1
+
+In the first test case, there are n=7 prisoners, m=19 sweets and they are passed out starting at chair s=2. The candies go all around twice and there are 5 more candies passed to each prisoner from seat 2 to seat 6.
+
+In the second test case, there are n=3 prisoners, m=7 candies and they are passed out starting at seat s=3. They go around twice, and there is one more to pass out to the prisoner at seat 3.
diff --git a/Basic Math/Save the Prisoner!/solution.cpp b/Basic Math/Save the Prisoner!/solution.cpp
new file mode 100644
index 0000000..42768a6
--- /dev/null
+++ b/Basic Math/Save the Prisoner!/solution.cpp	
@@ -0,0 +1,20 @@
+#include<bits/stdc++.h>
+using namespace std;
+int main()
+{
+    int t,n,m,s;
+    cin>>t;
+    while(t>0)
+    {
+        cin>>n>>m>>s;
+        s=s+m%n -1;
+        if(m%n==0)
+        s=s+n;
+        if(s>n)
+        s=s%n;
+        cout<<s<<endl;
+        t--;
+    }
+    return 0;
+}
+
diff --git a/Sherlock-and-the-beast/Sherlock-and-the-beast-problem.md b/Basic Math/Sherlock-and-the-beast/Sherlock-and-the-beast-problem.md
similarity index 100%
rename from Sherlock-and-the-beast/Sherlock-and-the-beast-problem.md
rename to Basic Math/Sherlock-and-the-beast/Sherlock-and-the-beast-problem.md
diff --git a/Sherlock-and-the-beast/solution.cpp b/Basic Math/Sherlock-and-the-beast/solution.cpp
similarity index 94%
rename from Sherlock-and-the-beast/solution.cpp
rename to Basic Math/Sherlock-and-the-beast/solution.cpp
index 3e7dff3..166e378 100644
--- a/Sherlock-and-the-beast/solution.cpp
+++ b/Basic Math/Sherlock-and-the-beast/solution.cpp	
@@ -1,66 +1,66 @@
-#include <bits/stdc++.h>
-
-using namespace std;
-
-
-// Complete the decentNumber function below.
-
-void decent(int digits)
-{
-    int flag=0;
-
-    if(digits==4 || digits==7 || digits<3)
-        flag=0;
-    else if(digits==5)
-    {
-        flag=1;
-        cout<<"33333\n";
-        
-    } 
-    else if(digits%3 ==0)
-    {
-        flag=1;
-        //(no. of times, what needs to be printed)
-        cout<<string(digits,'5')<<"\n";
-        
-    }
-
-    else if(digits>=8)
-    {
-        
-        int remain3,remain5,temp;
-  
-            temp=digits%3;
-            flag=1;
-        if(temp==1)
-        {
-            remain5=digits-10;
-            remain3=10;
-        }
-        else if(temp==2)
-        {
-            remain5=digits-5;
-            remain3=5;
-        }
-        
-        cout<<string(remain5,'5')<<string(remain3,'3')<<"\n";
-    }
-        
-
-    if(flag==0)
-        cout<<"-1\n";
-
-        
-}
-
-int main()
-{
-    int cases,input;
-    cin>>cases;
-    while(cases-->0)
-    {
-        cin>>input;
-        decent(input);
-    }
-    return 0;
+#include <bits/stdc++.h>
+
+using namespace std;
+
+
+// Complete the decentNumber function below.
+
+void decent(int digits)
+{
+    int flag=0;
+
+    if(digits==4 || digits==7 || digits<3)
+        flag=0;
+    else if(digits==5)
+    {
+        flag=1;
+        cout<<"33333\n";
+        
+    } 
+    else if(digits%3 ==0)
+    {
+        flag=1;
+        //(no. of times, what needs to be printed)
+        cout<<string(digits,'5')<<"\n";
+        
+    }
+
+    else if(digits>=8)
+    {
+        
+        int remain3,remain5,temp;
+  
+            temp=digits%3;
+            flag=1;
+        if(temp==1)
+        {
+            remain5=digits-10;
+            remain3=10;
+        }
+        else if(temp==2)
+        {
+            remain5=digits-5;
+            remain3=5;
+        }
+        
+        cout<<string(remain5,'5')<<string(remain3,'3')<<"\n";
+    }
+        
+
+    if(flag==0)
+        cout<<"-1\n";
+
+        
+}
+
+int main()
+{
+    int cases,input;
+    cin>>cases;
+    while(cases-->0)
+    {
+        cin>>input;
+        decent(input);
+    }
+    return 0;
 }
\ No newline at end of file
diff --git a/Basic Math/The Additionator/The Additionator.txt b/Basic Math/The Additionator/The Additionator.txt
new file mode 100644
index 0000000..59a741e
--- /dev/null
+++ b/Basic Math/The Additionator/The Additionator.txt	
@@ -0,0 +1,20 @@
+The Additionator - 
+
+The first line contains an integer 1≤N≤100000 (The number of addition problems). The next N lines will each contain two space-separated integers whose absolute value is less than 1000000000 (numbers to add)
+
+Output N lines of one integer each, the solutions to the addition problems in order.
+
+Example:
+
+IN
+
+3
+4 2
+-1 -1000
+9 10
+
+OUT
+
+6
+-1001
+19
diff --git a/Basic Math/The Additionator/solution.java b/Basic Math/The Additionator/solution.java
new file mode 100644
index 0000000..d5a160f
--- /dev/null
+++ b/Basic Math/The Additionator/solution.java	
@@ -0,0 +1,14 @@
+import java.util.*;
+
+public class Main {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+
+        int N = in.nextInt();
+        for (int i = 0; i < N; i++) {
+            int a = in.nextInt();
+            int b = in.nextInt();
+            System.out.println(a + b);
+        }
+    }
+}
diff --git a/The Prime Game/Problem_statement.txt b/Basic Math/The Prime Game/Problem_statement.txt
similarity index 99%
rename from The Prime Game/Problem_statement.txt
rename to Basic Math/The Prime Game/Problem_statement.txt
index 050d2b2..062ec10 100644
--- a/The Prime Game/Problem_statement.txt	
+++ b/Basic Math/The Prime Game/Problem_statement.txt	
@@ -1,9 +1,9 @@
-Manasa loves the nim game, in which there are n buckets, each having Ai balls. Two players play alternately. Each turn consists of removing some non-zero number of balls from one of the bucket. A player with lack of moves looses. But, Manasa having played it so many times, she gets bored one day. So she wants to change the rules of the game. She loves prime numbers, so she makes a new rule: any player can only remove a prime number of balls from a bucket. But there are infinite number prime numbers. So to keep the game simple, a player can only remove x balls from a bucket if x belongs to the set 
-
-S = {2, 3, 5, 7, 11, 13}
-
-The whole game can now be described as follows:
-
-There are  buckets, and the  bucket contains  balls. A player can choose a bucket and remove  balls from that bucket where  belongs to . A player loses if there are no more available moves.
-
+Manasa loves the nim game, in which there are n buckets, each having Ai balls. Two players play alternately. Each turn consists of removing some non-zero number of balls from one of the bucket. A player with lack of moves looses. But, Manasa having played it so many times, she gets bored one day. So she wants to change the rules of the game. She loves prime numbers, so she makes a new rule: any player can only remove a prime number of balls from a bucket. But there are infinite number prime numbers. So to keep the game simple, a player can only remove x balls from a bucket if x belongs to the set 
+
+S = {2, 3, 5, 7, 11, 13}
+
+The whole game can now be described as follows:
+
+There are  buckets, and the  bucket contains  balls. A player can choose a bucket and remove  balls from that bucket where  belongs to . A player loses if there are no more available moves.
+
 Manasa plays the first move against Sandy. Who will win if both of them play optimally?
\ No newline at end of file
diff --git a/The Prime Game/Solution.py b/Basic Math/The Prime Game/Solution.py
similarity index 96%
rename from The Prime Game/Solution.py
rename to Basic Math/The Prime Game/Solution.py
index 7ec6413..4238403 100644
--- a/The Prime Game/Solution.py	
+++ b/Basic Math/The Prime Game/Solution.py	
@@ -1,12 +1,12 @@
-s = [0, 0, 1, 1, 2, 2, 3, 3, 4]
-t = int(input())
-for ti in range(t):
-    n = int(input())
-    a = [int(ai) for ai in input().strip().split(" ")]
-    ans = 0
-    for i in range(n):
-        ans = ans^s[int(a[i]%len(s))]
-    if(ans>0):
-        print("Manasa")
-    else:
-        print("Sandy")
+s = [0, 0, 1, 1, 2, 2, 3, 3, 4]
+t = int(input())
+for ti in range(t):
+    n = int(input())
+    a = [int(ai) for ai in input().strip().split(" ")]
+    ans = 0
+    for i in range(n):
+        ans = ans^s[int(a[i]%len(s))]
+    if(ans>0):
+        print("Manasa")
+    else:
+        print("Sandy")
diff --git a/Basic Math/When to take medicine/problem_statement.txt b/Basic Math/When to take medicine/problem_statement.txt
new file mode 100644
index 0000000..94ded94
--- /dev/null
+++ b/Basic Math/When to take medicine/problem_statement.txt	
@@ -0,0 +1,7 @@
+                                                                                                             When to take medicine 
+
+All submissions for this problem are available.You visit a doctor on a date given in the format yyyy:mm:dd. Your doctor suggests you to take pills every alternate day starting from that day. You being a forgetful person are pretty sure won’t be able to remember the last day you took the medicine and would end up in taking the medicines on wrong days.
+
+So you come up with the idea of taking medicine on the dates whose day is odd or even depending on whether dd is odd or even. Calculate the number of pills you took on right time before messing up for the first time.
+
+
diff --git a/Basic Math/When to take medicine/when to take medicine_answer.txt b/Basic Math/When to take medicine/when to take medicine_answer.txt
new file mode 100644
index 0000000..8a41287
--- /dev/null
+++ b/Basic Math/When to take medicine/when to take medicine_answer.txt	
@@ -0,0 +1,70 @@
+Language-c++
+
+
+Solution-
+
+#include <iostream>
+using namespace std;
+int get_year(long int year,int month,int day);
+int main() 
+{
+	// your code goes here
+	int test;
+	cin>>test;
+	while(test!=0)
+	{  int month,day;
+	   long int year;
+	  char a,b;
+	  cin>>year>>a>>month>>b>>day;
+	   int answer=get_year(year,month,day);
+	    cout<<answer<<endl;
+	    test--;
+	    
+	}
+	return 0;
+}
+
+int get_year(long int year,int month,int day)
+{   bool leap_year=false;
+     int answer{0};
+     
+    
+     if((year%4==0 && year%100!=0) ||year%400==0)
+        leap_year=true;
+    
+     for(;;)
+    {
+        bool odd=day%2;
+        
+        if(month ==1 ||month ==3 ||month ==5 ||month ==7 ||month ==8 ||
+    month ==10 ||month ==12)
+    { 
+         answer+=((31-day)/2) + 1;
+               break;
+        
+    }else if(month ==4 ||month ==6 ||month ==9 ||month ==11)
+    {    
+            answer+=((30-day)/2) + 1;
+               
+               ((odd)?day=1:day=2);
+               month++;
+               continue;
+    }else
+    {   
+        if(leap_year)
+        {    
+            answer+=((29-day)/2) + 1;
+               break;
+        }else
+        {
+            answer+=((28-day)/2) + 1;
+               
+              ((odd)?day=1:day=2);
+              month++;
+              continue;
+        }
+    
+    }
+    }
+    return answer;
+}
diff --git a/find_factorial_of_a_number/find_factorial_of_a_number.txt b/Basic Math/find_factorial_of_a_number/find_factorial_of_a_number.txt
similarity index 100%
rename from find_factorial_of_a_number/find_factorial_of_a_number.txt
rename to Basic Math/find_factorial_of_a_number/find_factorial_of_a_number.txt
diff --git a/find_factorial_of_a_number/solution.cpp b/Basic Math/find_factorial_of_a_number/solution.cpp
similarity index 100%
rename from find_factorial_of_a_number/solution.cpp
rename to Basic Math/find_factorial_of_a_number/solution.cpp
diff --git a/project_euler problem12/Highly divisible triangular number.cpp b/Basic Math/project_euler problem12/Highly divisible triangular number.cpp
similarity index 100%
rename from project_euler problem12/Highly divisible triangular number.cpp
rename to Basic Math/project_euler problem12/Highly divisible triangular number.cpp
diff --git a/project_euler problem12/problem b/Basic Math/project_euler problem12/problem
similarity index 100%
rename from project_euler problem12/problem
rename to Basic Math/project_euler problem12/problem
diff --git a/Basic Program/A. Team/A.Team.cpp b/Basic Program/A. Team/A.Team.cpp
new file mode 100644
index 0000000..05dfbeb
--- /dev/null
+++ b/Basic Program/A. Team/A.Team.cpp	
@@ -0,0 +1,24 @@
+#include <iostream>
+
+int main()
+{
+  //Creation of vars
+	int n, a, b, c, count = 0;
+  //Take in input for n lines
+	std::cin >> n;
+  //Loop for n
+	for (int i = 0; i < n; i++)
+	{
+    //Take in user input
+		std::cin >> a;
+		std::cin >> b;
+		std::cin >> c;
+    //If more than 2 are sure then they will do the problem
+		if (a + b + c >= 2)
+    //Increase problem count
+			count++;
+	}
+  //Return problem count
+	std::cout << count;
+	return 0;
+}
diff --git a/Basic Program/A. Team/A.Team.txt b/Basic Program/A. Team/A.Team.txt
new file mode 100644
index 0000000..f7d38b4
--- /dev/null
+++ b/Basic Program/A. Team/A.Team.txt	
@@ -0,0 +1,34 @@
+A. Team [https://codeforces.com/contest/231/problem/A]
+
+
+One day three best friends Petya, Vasya and Tonya decided to form a team and take part in programming contests. Participants are usually offered several problems during programming contests. Long before the start the friends decided that they will implement a problem if at least two of them are sure about the solution. Otherwise, the friends won't write the problem's solution.
+
+This contest offers n problems to the participants. For each problem we know, which friend is sure about the solution. Help the friends find the number of problems for which they will write a solution.
+
+Input
+The first input line contains a single integer n (1 ≤ n ≤ 1000) — the number of problems in the contest. Then n lines contain three integers each, each integer is either 0 or 1. If the first number in the line equals 1, then Petya is sure about the problem's solution, otherwise he isn't sure. The second number shows Vasya's view on the solution, the third number shows Tonya's view. The numbers on the lines are separated by spaces.
+
+Output
+Print a single integer — the number of problems the friends will implement on the contest.
+
+Examples
+INPUT
+3
+1 1 0
+1 1 1
+1 0 0
+OUTPUT
+2
+
+INPUT
+2
+1 0 0
+0 1 1
+OUTPUT
+1
+
+Note
+In the first sample Petya and Vasya are sure that they know how to solve the first problem and all three of them know how to solve the second problem. That means that they will write solutions for these problems. Only Petya is sure about the solution for the third problem, but that isn't enough, so the friends won't take it.
+
+In the second sample the friends will only implement the second problem, as Vasya and Tonya are sure about the solution.
+
diff --git a/Basic Program/CollatzConjecture/CollatzConjecture.txt b/Basic Program/CollatzConjecture/CollatzConjecture.txt
new file mode 100644
index 0000000..799a6b3
--- /dev/null
+++ b/Basic Program/CollatzConjecture/CollatzConjecture.txt	
@@ -0,0 +1,24 @@
+Collatz Conjecture
+
+The Collatz Conjecture says that if you take any number and follow the following steps, you will never be stuck in a loop.
+
+If the number is even -> number = number/2;
+If the number is odd -> number = 3*number + 1;
+
+If you continue to do this, at some point your number will be equal to 1.
+
+Example: number = 26
+	1 Step - number = 26/2 = 13
+	2 Step - number = 13*3 + 1 = 40
+	3 Step - number = 40/2 = 20
+	4 Step - number = 20/2 = 10
+	5 Step - number = 10/2 = 5
+	6 Step - number = 3*5 + 1 = 16
+	7 Step - number = 16/2 = 8
+	8 Step - number = 8/2 = 4
+	9 Step - number = 4/2 = 2
+	10 Step - number = 2/2 = 1
+
+For the number 26, 10 steps are needed, create a solution that calculates the number of steps for a given N number,
+and the biggest value the number had during the steps.
+	
diff --git a/Basic Program/CollatzConjecture/solution.c b/Basic Program/CollatzConjecture/solution.c
new file mode 100644
index 0000000..0f667da
--- /dev/null
+++ b/Basic Program/CollatzConjecture/solution.c	
@@ -0,0 +1,23 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(){
+    long int N = 26; //CALCULATING FOR N = 26
+    long int biggestValue = 0;
+    long int steps = 0;
+
+    while(N != 1){
+        if(N%2 == 0){
+            N = N/2;
+        }else{
+            N = N*3 + 1;
+        }
+        if(N>biggestValue){
+            biggestValue = N;
+        }
+        steps++;
+    }
+
+    printf("Number of Steps: %ld BiggestValue: %ld", steps, biggestValue);
+
+}
\ No newline at end of file
diff --git a/EncoderProblem/Encoder.java b/Basic Program/EncoderProblem/Encoder.java
similarity index 100%
rename from EncoderProblem/Encoder.java
rename to Basic Program/EncoderProblem/Encoder.java
diff --git a/EncoderProblem/problem.txt b/Basic Program/EncoderProblem/problem.txt
similarity index 100%
rename from EncoderProblem/problem.txt
rename to Basic Program/EncoderProblem/problem.txt
diff --git a/Basic Program/Leap Year/instructions.txt b/Basic Program/Leap Year/instructions.txt
new file mode 100644
index 0000000..47ee92e
--- /dev/null
+++ b/Basic Program/Leap Year/instructions.txt	
@@ -0,0 +1,11 @@
+Leap
+Given a year, report if it is a leap year.
+
+The tricky thing here is that a leap year in the Gregorian calendar occurs:
+
+on every year that is evenly divisible by 4
+  except every year that is evenly divisible by 100
+    unless the year is also evenly divisible by 400
+For example, 1997 is not a leap year, but 1996 is. 1900 is not a leap year, but 2000 is.
+
+If your language provides a method in the standard library that does this look-up, pretend it doesn't exist and implement it yourself.
diff --git a/Basic Program/Leap Year/ruby_solution.rb b/Basic Program/Leap Year/ruby_solution.rb
new file mode 100644
index 0000000..d5051d8
--- /dev/null
+++ b/Basic Program/Leap Year/ruby_solution.rb	
@@ -0,0 +1,8 @@
+def leap(year)
+  puts year %400 == 0 || year %4 == 0 && !(year %100 == 0)
+end
+
+leap(1996) #expect true
+leap(2000) #expect true
+leap(2015) #expect false
+leap(1800) #expect false
diff --git a/Basic Program/Sleep_In/sleep_in.py b/Basic Program/Sleep_In/sleep_in.py
new file mode 100644
index 0000000..efa6144
--- /dev/null
+++ b/Basic Program/Sleep_In/sleep_in.py	
@@ -0,0 +1,7 @@
+"""The parameter weekday is True if it is a weekday, and the parameter vacation is True if we are on vacation. We sleep in if it is not a weekday or we're on vacation. 
+Return True if we sleep in."""
+
+def sleep_in(weekday, vacation):
+  if not weekday or vacation:
+    return True
+  return False
diff --git a/Basic Program/how-can-create-a-hackthoberfest-infinite-loop-in-python/hacktoberfest-loop.txt b/Basic Program/how-can-create-a-hackthoberfest-infinite-loop-in-python/hacktoberfest-loop.txt
new file mode 100644
index 0000000..4af699a
--- /dev/null
+++ b/Basic Program/how-can-create-a-hackthoberfest-infinite-loop-in-python/hacktoberfest-loop.txt	
@@ -0,0 +1,13 @@
+Question:
+
+This is a random beginner question, to start the #HacktoberFest 2019 with a random pr 
+
+How can I create a hackthoberfest infinity loop in Python?
+
+Easy!
+
+You need to use while function.
+
+When ypu learning Python functions, teachers explains you that if while function it's true and it's not a break in the code, then the while converts into a infinite loop.
+
+So, this is a easy simple example to show you what is named an infinite loop in Python.
\ No newline at end of file
diff --git a/Basic Program/how-can-create-a-hackthoberfest-infinite-loop-in-python/infinity-hscktoberfest-loop.py b/Basic Program/how-can-create-a-hackthoberfest-infinite-loop-in-python/infinity-hscktoberfest-loop.py
new file mode 100644
index 0000000..f17eefd
--- /dev/null
+++ b/Basic Program/how-can-create-a-hackthoberfest-infinite-loop-in-python/infinity-hscktoberfest-loop.py	
@@ -0,0 +1,2 @@
+while True:
+    print("Hacktober Fest 2019")
diff --git a/Aggressive Cows Spoj/problem statement.txt b/Binary Search/Aggressive Cows Spoj/problem statement.txt
similarity index 100%
rename from Aggressive Cows Spoj/problem statement.txt
rename to Binary Search/Aggressive Cows Spoj/problem statement.txt
diff --git a/Aggressive Cows Spoj/solution1.cpp b/Binary Search/Aggressive Cows Spoj/solution1.cpp
similarity index 100%
rename from Aggressive Cows Spoj/solution1.cpp
rename to Binary Search/Aggressive Cows Spoj/solution1.cpp
diff --git a/Aggressive Cows Spoj/solution2.cpp b/Binary Search/Aggressive Cows Spoj/solution2.cpp
similarity index 100%
rename from Aggressive Cows Spoj/solution2.cpp
rename to Binary Search/Aggressive Cows Spoj/solution2.cpp
diff --git a/Binary Search/binary_search/binary_search.txt b/Binary Search/binary_search/binary_search.txt
new file mode 100644
index 0000000..352fb59
--- /dev/null
+++ b/Binary Search/binary_search/binary_search.txt	
@@ -0,0 +1,3 @@
+Binary search
+
+Question- Given a sorted array of numbers and a number, find if the given number exists in the array in O(nlogn) time and O(1) space.
\ No newline at end of file
diff --git a/Binary Search/binary_search/bs.class b/Binary Search/binary_search/bs.class
new file mode 100644
index 0000000..31b1966
Binary files /dev/null and b/Binary Search/binary_search/bs.class differ
diff --git a/Binary Search/binary_search/bs.ctxt b/Binary Search/binary_search/bs.ctxt
new file mode 100644
index 0000000..487f1ee
--- /dev/null
+++ b/Binary Search/binary_search/bs.ctxt	
@@ -0,0 +1,7 @@
+#BlueJ class context
+comment0.target=bs
+comment1.params=arr\ n
+comment1.target=boolean\ binary_search(int[],\ int)
+comment2.params=args
+comment2.target=void\ main(java.lang.String[])
+numComments=3
diff --git a/Binary Search/binary_search/bs.java b/Binary Search/binary_search/bs.java
new file mode 100644
index 0000000..c5eb9f4
--- /dev/null
+++ b/Binary Search/binary_search/bs.java	
@@ -0,0 +1,29 @@
+class bs
+{
+    public boolean binary_search(int arr[], int n)
+    {
+        int right;int left; int mid;
+        right= arr.length;
+        left=0;
+        do{
+            mid= (right+left)/2;
+            if(arr[mid]==n)
+            return true;
+            if(arr[mid]>n)
+            right= mid-1;
+            else
+            left= mid+1;
+           }while((arr[mid]!=n)&&(left!=right));
+           return false;
+    }
+    public static void main(String args[])
+    {
+        bs obj = new bs();
+        int a[]={1,2,3,4,5};
+        int n= 5;
+        if(obj.binary_search(a,n))
+        System.out.println("Element found");
+        else
+        System.out.println("Element is not present");
+    }
+}
diff --git a/Binary Search/binary_search/solution.cpp b/Binary Search/binary_search/solution.cpp
new file mode 100644
index 0000000..09ecfb5
--- /dev/null
+++ b/Binary Search/binary_search/solution.cpp	
@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+#include <iostream>
+using namespace std;
+
+bool binarySearch(vector <int> arr,int ele)
+{
+	int l=0;
+	int r=arr.size()-1;
+	while(l<=r)
+	{
+		int m=(l+r)/2;
+		if(arr[m]==ele)
+			return true;
+		else{
+			if(arr[m]<ele)
+				l=m+1;
+			else r=m-1;
+			}
+	}
+	
+	return false;
+}
+
+int main()
+{               
+				vector<int> arr({1,2,3,4,5});
+				int ele=1;
+				if(binarySearch(arr,ele))
+					cout<<"Exists"<<endl;
+				else cout<<"Doesn't exist"<<endl;
+                return 0;
+}
diff --git a/Binary Search/binary_search/solution.py b/Binary Search/binary_search/solution.py
new file mode 100644
index 0000000..4398fdd
--- /dev/null
+++ b/Binary Search/binary_search/solution.py	
@@ -0,0 +1,22 @@
+def binarySearch(arr,ele):
+	l=0
+	r=len(arr)-1
+	while(l<=r):
+		m=(l+r)//2
+		if(arr[m]==ele):
+			return True
+		else:
+			if(arr[m]<ele):
+				l=m+1
+			else:
+				r=m-1
+	return False
+
+if __name__ == '__main__':
+	#sorted array
+	arr=[1,2,3,4,5]
+
+	if(binarySearch(arr,1)):
+		print("Exists")
+	else:
+		print("Doesnt exist")
diff --git a/Bitwise Operation/ZOMCAV/ZOMCAV.txt b/Bitwise Operation/ZOMCAV/ZOMCAV.txt
new file mode 100644
index 0000000..a5c7423
--- /dev/null
+++ b/Bitwise Operation/ZOMCAV/ZOMCAV.txt	
@@ -0,0 +1,39 @@
+The solution given along is written solely by the author and using it anywhere else without prior written permission might result in legal actions taken against the guilty person
+
+
+
+
+
+There are N caves in a row, numbered 1 through N. For each valid i, the radiation power in the i-th cave is Ci. Originally, the radiation level in each cave was 0. Then, for each valid i, the radiation power in cave i increased the radiation levels in the caves i-Ci,…,i+Ci inclusive (if they exist) by 1, so all the caves are radioactive now.
+
+Radiation is not the only problem, though. There are also N zombies with health levels H1,H2,…,HN. You want to kill all of them by getting them to the caves in such a way that there is exactly one zombie in each cave. A zombie dies in a cave if and only if the radiation level in that cave is equal to the health level of the zombie. Is it possible to kill all the zombies?
+
+Input
+The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
+The first line of each test case contains a single integer N.
+The second line contains N space-separated integers C1,C2,…,CN.
+The third line contains N space-separated integers H1,H2,…,HN.
+Output
+For each test case, print a single line containing the string "YES" if it is possible to kill all the zombies or "NO" if it is impossible (without quotes).
+
+Constraints
+1=T=100
+1=N=105
+1=Ci,Hi=109 for each valid i
+Subtasks
+Subtask #1 (30 points): 1=N=1,000
+Subtask #2 (70 points): original constraints
+
+Example Input
+2
+5
+1 2 3 4 5
+1 2 3 4 5
+5
+1 2 3 4 5
+5 4 3 4 5
+Example Output
+NO
+YES
+Explanation
+In both example test cases, the final radiation levels in the caves are (5,5,4,4,3). For example, the radiation power in cave 1 increased the radiation levels in caves 1 and 2 (there is no cave 0) by 1, and the radiation power in cave 4 increased the radiation levels in all caves by 1.
\ No newline at end of file
diff --git a/Bitwise Operation/ZOMCAV/codechef.class b/Bitwise Operation/ZOMCAV/codechef.class
new file mode 100644
index 0000000..2b81a21
Binary files /dev/null and b/Bitwise Operation/ZOMCAV/codechef.class differ
diff --git a/Bitwise Operation/ZOMCAV/codechef.ctxt b/Bitwise Operation/ZOMCAV/codechef.ctxt
new file mode 100644
index 0000000..6a90e1f
--- /dev/null
+++ b/Bitwise Operation/ZOMCAV/codechef.ctxt	
@@ -0,0 +1,5 @@
+#BlueJ class context
+comment0.target=codechef
+comment1.params=args
+comment1.target=void\ main(java.lang.String[])
+numComments=2
diff --git a/Bitwise Operation/ZOMCAV/codechef.java b/Bitwise Operation/ZOMCAV/codechef.java
new file mode 100644
index 0000000..81d3c2a
--- /dev/null
+++ b/Bitwise Operation/ZOMCAV/codechef.java	
@@ -0,0 +1,78 @@
+import java.util.*;
+import java.io.*;
+class codechef
+{
+    public static void main(String args[])throws IOException
+    {
+        BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
+        int t= Integer.parseInt(br.readLine());
+        for(int phi=0; phi<t;phi++)
+        {
+            int n= Integer.parseInt(br.readLine());
+            String ra= br.readLine();
+            String zo= br.readLine();
+            
+            int radpow[]= new int[n];
+            
+            int starting[]= new int[n];
+            
+            for(int i=0;i<n;i++)
+            {
+                starting[i]=0;
+            }
+            
+                
+            
+            StringTokenizer st = new StringTokenizer(ra);
+            
+            int cou=0;
+            
+            while(st.hasMoreTokens())
+            {
+                long val = Long.parseLong(st.nextToken());
+                
+                int start= (int)Math.max(0, cou-val);
+                int stop=  (int)(cou+val+1);
+                
+                
+                cou++;
+                
+                
+                starting[start]+=1;
+                if(stop<=n-1)
+                starting[stop]-=1;
+               
+                
+            }
+            
+            
+            
+            
+            cou=0;
+            for(int i=0;i<n;i++)
+            {
+                cou+=starting[i];
+                if(cou<0)
+                cou=0;
+                radpow[i]+=cou;
+            }
+            
+            
+            
+            
+            StringTokenizer newst= new StringTokenizer(zo);
+
+            long xor=0;
+            for(int i=0;i<n;i++)
+            {
+                xor= (xor^radpow[i])^Long.parseLong(newst.nextToken());
+            }
+      
+            if(xor==0)
+           System.out.println("YES");
+           else
+           System.out.println("NO");
+        }
+    }
+}
+           
\ No newline at end of file
diff --git a/0-1 Knapsack Problem/Question.txt b/Dynamic Programming/0-1 Knapsack Problem/Question.txt
similarity index 100%
rename from 0-1 Knapsack Problem/Question.txt
rename to Dynamic Programming/0-1 Knapsack Problem/Question.txt
diff --git a/0-1 Knapsack Problem/Solution.c b/Dynamic Programming/0-1 Knapsack Problem/Solution.c
similarity index 100%
rename from 0-1 Knapsack Problem/Solution.c
rename to Dynamic Programming/0-1 Knapsack Problem/Solution.c
diff --git a/Dynamic Programming/Buy-and-Sell-Stock-for-Maximum-Profit/buyAndSellStock.py b/Dynamic Programming/Buy-and-Sell-Stock-for-Maximum-Profit/buyAndSellStock.py
new file mode 100644
index 0000000..729a2a8
--- /dev/null
+++ b/Dynamic Programming/Buy-and-Sell-Stock-for-Maximum-Profit/buyAndSellStock.py	
@@ -0,0 +1,40 @@
+'''
+Ref: https://www.geeksforgeeks.org/maximum-profit-by-buying-and-selling-a-share-at-most-k-times/
+
+'''
+# Python program to maximize the profit 
+# by doing at most k transactions 
+# given stock prices for n days 
+  
+# Function to find out maximum profit by 
+# buying & selling a share atmost k times  
+# given stock price of n days 
+def maxProfit(prices, n, k): 
+      
+    # Bottom-up DP approach 
+    profit = [[0 for i in range(k + 1)] 
+                 for j in range(n)] 
+      
+    # Profit is zero for the first 
+    # day and for zero transactions 
+    for i in range(1, n): 
+          
+        for j in range(1, k + 1): 
+            max_so_far = 0
+              
+            for l in range(i): 
+                max_so_far = max(max_so_far, prices[i] -
+                            prices[l] + profit[l][j - 1]) 
+                              
+            profit[i][j] = max(profit[i - 1][j], max_so_far) 
+      
+    return profit[n - 1][k] 
+  
+# Driver code 
+k = 2
+prices = [10, 22, 5, 75, 65, 80] 
+n = len(prices) 
+  
+print("Maximum profit is:", 
+       maxProfit(prices, n, k)) 
+  
diff --git a/Dynamic Programming/Buy-and-Sell-Stock-for-Maximum-Profit/problem-statement.txt b/Dynamic Programming/Buy-and-Sell-Stock-for-Maximum-Profit/problem-statement.txt
new file mode 100644
index 0000000..3d45433
--- /dev/null
+++ b/Dynamic Programming/Buy-and-Sell-Stock-for-Maximum-Profit/problem-statement.txt	
@@ -0,0 +1,9 @@
+Ref: https://www.geeksforgeeks.org/maximum-profit-by-buying-and-selling-a-share-at-most-k-times/
+
+
+In share trading, a buyer buys shares and sells on a future date. Given the stock price of n days, the trader is allowed to make at most k transactions, where a new transaction can only start after the previous transaction is complete, find out the maximum profit that a share trader could have made.
+
+There are various versions of the problem. If we are allowed to buy and sell only once, then we can use Maximum difference between two elements algorithm. If we are allowed to make at most 2 transactions, we can follow approach discussed here. 
+
+In this case, we are only allowed to make at max k transactions. The problem can be solved by using dynamic programming.
+
diff --git a/Dynamic Programming/Bytelandian-gold-coins/instructions.txt b/Dynamic Programming/Bytelandian-gold-coins/instructions.txt
new file mode 100644
index 0000000..74c2c86
--- /dev/null
+++ b/Dynamic Programming/Bytelandian-gold-coins/instructions.txt	
@@ -0,0 +1,27 @@
+In Byteland they have a very strange monetary system.
+
+Each Bytelandian gold coin has an integer number written on it. A coin n can be exchanged in a bank into three coins: n/2, n/3 and n/4. But these numbers are all rounded down (the banks have to make a profit).
+
+You can also sell Bytelandian coins for American dollars. The exchange rate is 1:1. But you can not buy Bytelandian coins.
+
+You have one gold coin. What is the maximum amount of American dollars you can get for it?
+Input
+
+The input will contain several test cases (not more than 10). Each testcase is a single line with a number n, 0 <= n <= 1 000 000 000. It is the number written on your coin.
+Output
+
+For each test case output a single line, containing the maximum amount of American dollars you can make.
+
+Example
+
+Input:
+12
+2
+
+Output:
+13
+2
+
+You can change 12 into 6, 4 and 3, and then change these into $6+$4+$3 = $13.
+If you try changing the coin 2 into 3 smaller coins, you will get 1, 0 and 0, and later you can get no more than $1 out of them.
+It is better just to change the 2 coin directly into $2.
diff --git a/Dynamic Programming/Bytelandian-gold-coins/solution.cpp b/Dynamic Programming/Bytelandian-gold-coins/solution.cpp
new file mode 100644
index 0000000..aebf1b2
--- /dev/null
+++ b/Dynamic Programming/Bytelandian-gold-coins/solution.cpp	
@@ -0,0 +1,17 @@
+#include<bits/stdc++.h>
+using namespace std;
+map<int,long long> dp;
+long long optcoins(int n){
+    if(n<12)
+        return n;
+    if(dp.count(n))
+        return dp[n];
+    dp[n]=optcoins(n/2)+optcoins(n/3)+optcoins(n/4);
+    return dp[n];
+}
+int main(){
+    int x;
+    while(scanf("%d",&x)!=EOF)
+        printf("%lld\n",optcoins(x));
+    return 0;
+}
diff --git a/COINS/Question.txt b/Dynamic Programming/COINS/Question.txt
similarity index 100%
rename from COINS/Question.txt
rename to Dynamic Programming/COINS/Question.txt
diff --git a/COINS/Readme.md b/Dynamic Programming/COINS/Readme.md
similarity index 100%
rename from COINS/Readme.md
rename to Dynamic Programming/COINS/Readme.md
diff --git a/COINS/Solution.cpp b/Dynamic Programming/COINS/Solution.cpp
similarity index 100%
rename from COINS/Solution.cpp
rename to Dynamic Programming/COINS/Solution.cpp
diff --git a/Dynamic Programming/DP- Min Steps to 1/Min Steps to 1 Problem Statement.txt b/Dynamic Programming/DP- Min Steps to 1/Min Steps to 1 Problem Statement.txt
new file mode 100644
index 0000000..f3a3837
--- /dev/null
+++ b/Dynamic Programming/DP- Min Steps to 1/Min Steps to 1 Problem Statement.txt	
@@ -0,0 +1,35 @@
+Type: Dynamic Programming
+
+Code : Min Steps to 1
+
+Given a positive integer n, find the minimum number of steps s, that takes n to 1.
+You can perform any one of the following 3 steps.
+1.) Subtract 1 from it. (n= n - ­1) ,
+2.) If its divisible by 2, divide by 2.( if n%2==0, then n= n/2 ) ,
+3.) If its divisible by 3, divide by 3. (if n%3 == 0, then n = n / 3 ).  
+
+Input format :
+Line 1 : A single integer  i.e. n
+Output format :
+Line 1 : Single integer i.e number of steps
+Constraints :
+1 <= n <= 500
+
+Sample Input 1 :
+4
+Sample Output 1 :
+2 
+Sample Output 1 Explanation :
+For n = 4
+Step 1 : n = 4/2 = 2
+Step 2 : n = 2/2 = 1
+
+Sample Input 2 :
+7
+Sample Output 2 :
+3
+Sample Output 2 Explanation :
+For n = 7
+Step 1 : n = 7 ­ - 1 = 6
+Step 2 : n = 6 / 3 = 2
+Step 3 : n = 2 / 2 = 1
\ No newline at end of file
diff --git a/Dynamic Programming/DP- Min Steps to 1/minsteps.java b/Dynamic Programming/DP- Min Steps to 1/minsteps.java
new file mode 100644
index 0000000..8cb26ab
--- /dev/null
+++ b/Dynamic Programming/DP- Min Steps to 1/minsteps.java	
@@ -0,0 +1,47 @@
+import java.util.Scanner;
+import java.lang.Math;
+
+public class minsteps
+{
+    public static Scanner s=new Scanner(System.in);
+
+    public static void main(String[] args)
+    {
+        int n = s.nextInt();
+        System.out.println(countStepsTo1(n));
+    }
+
+    public static int countStepsTo1(int n)
+    {
+        if(n<=1)
+            return 0;
+        if(n==2 || n==3)
+            return 1;
+        int ans[]=new int[n+1];
+
+        ans[0]=0;
+        ans[1]=0;
+        ans[2]=1;
+        ans[3]=1;
+
+
+
+        for(int i=4;i<n+1;i++)
+        {
+            int x=Integer.MAX_VALUE;
+            int y=Integer.MAX_VALUE;
+            int z=ans[i-1]+1;
+
+            if(i%3==0)
+                x=ans[i/3]+1;
+            if(i%2==0)
+                y=ans[i/2]+1;
+
+            ans[i]=Math.min(x,Math.min(y,z));
+        }
+
+        return ans[n];
+    }
+
+
+}
diff --git a/Dynamic Programming/Gold mine problem/GoldMineProblem.txt b/Dynamic Programming/Gold mine problem/GoldMineProblem.txt
new file mode 100644
index 0000000..76506c3
--- /dev/null
+++ b/Dynamic Programming/Gold mine problem/GoldMineProblem.txt	
@@ -0,0 +1,7 @@
+Gold Mine Problem
+
+Given a gold mine of n*m dimensions.
+ Each field in this mine contains a positive integer which is the amount of gold in tons. 
+Initially the miner is at first column but can be at any row.
+ He can move only (right->,right up /,right down\) that is from a given cell, the miner can move to the cell diagonally up towards the right or right or diagonally down towards the right. 
+Find out maximum amount of gold he can collect.
\ No newline at end of file
diff --git a/Dynamic Programming/Gold mine problem/solution.cpp.txt b/Dynamic Programming/Gold mine problem/solution.cpp.txt
new file mode 100644
index 0000000..13394ba
--- /dev/null
+++ b/Dynamic Programming/Gold mine problem/solution.cpp.txt	
@@ -0,0 +1,61 @@
+// C++ program to solve Gold Mine problem 
+#include<bits/stdc++.h> 
+using namespace std; 
+
+const int MAX = 100; 
+
+// Returns maximum amount of gold that can be collected 
+// when journey started from first column and moves 
+// allowed are right, right-up and right-down 
+int getMaxGold(int gold[][MAX], int m, int n) 
+{ 
+	// Create a table for storing intermediate results 
+	// and initialize all cells to 0. The first row of 
+	// goldMineTable gives the maximum gold that the miner 
+	// can collect when starts that row 
+	int goldTable[m][n]; 
+	memset(goldTable, 0, sizeof(goldTable)); 
+
+	for (int col=n-1; col>=0; col--) 
+	{ 
+		for (int row=0; row<m; row++) 
+		{ 
+			// Gold collected on going to the cell on the right(->) 
+			int right = (col==n-1)? 0: goldTable[row][col+1]; 
+
+			// Gold collected on going to the cell to right up (/) 
+			int right_up = (row==0 || col==n-1)? 0: 
+							goldTable[row-1][col+1]; 
+
+			// Gold collected on going to the cell to right down (\) 
+			int right_down = (row==m-1 || col==n-1)? 0: 
+							goldTable[row+1][col+1]; 
+
+			// Max gold collected from taking either of the 
+			// above 3 paths 
+			goldTable[row][col] = gold[row][col] + 
+							max(right, max(right_up, right_down)); 
+													
+		} 
+	} 
+
+	// The max amount of gold collected will be the max 
+	// value in first column of all rows 
+	int res = goldTable[0][0]; 
+	for (int i=1; i<m; i++) 
+		res = max(res, goldTable[i][0]); 
+	return res; 
+} 
+
+// Driver Code 
+int main() 
+{ 
+	int gold[MAX][MAX]= { {1, 3, 1, 5}, 
+		{2, 2, 4, 1}, 
+		{5, 0, 2, 3}, 
+		{0, 6, 1, 2} 
+	}; 
+	int m = 4, n = 4; 
+	cout << getMaxGold(gold, m, n); 
+	return 0; 
+} 
diff --git a/Dynamic Programming/Magic-Spells-LCS/problem.txt b/Dynamic Programming/Magic-Spells-LCS/problem.txt
new file mode 100644
index 0000000..20df9df
--- /dev/null
+++ b/Dynamic Programming/Magic-Spells-LCS/problem.txt	
@@ -0,0 +1,19 @@
+This is from https://www.hackerrank.com/challenges/magic-spells/problem
+
+You are battling a powerful dark wizard. He casts his spells from a distance, giving you only a few seconds to react and conjure
+your counterspells. For a counterspell to be effective, you must first identify what kind of spell you are dealing with.
+
+The wizard uses scrolls to conjure his spells, and sometimes he uses some of his generic spells that restore his stamina. In that
+case, you will be able to extract the name of the scroll from the spell. Then you need to find out how similar this new spell is
+to the spell formulas written in your spell journal.
+
+
+Input Format
+The wizard will read  scrolls, which are hidden from you.
+Every time he casts a spell, it's passed as an argument to your counterspell function.
+
+
+Output Format
+After identifying the given spell, print its name and power.
+If it is a generic spell, find a subsequence of letters that are contained in both the spell name and your spell journal.
+Among all such subsequences, find and print the length of the longest one on a new line.
diff --git a/Dynamic Programming/Magic-Spells-LCS/solution.cpp b/Dynamic Programming/Magic-Spells-LCS/solution.cpp
new file mode 100644
index 0000000..8d2c209
--- /dev/null
+++ b/Dynamic Programming/Magic-Spells-LCS/solution.cpp	
@@ -0,0 +1,142 @@
+#include <iostream>
+#include <vector>
+#include <string>
+using namespace std;
+
+class Spell { 
+    private:
+        string scrollName;
+    public:
+        Spell(): scrollName("") { }
+        Spell(string name): scrollName(name) { }
+        virtual ~Spell() { }
+        string revealScrollName() {
+            return scrollName;
+        }
+};
+
+class Fireball : public Spell { 
+    private: int power;
+    public:
+        Fireball(int power): power(power) { }
+        void revealFirepower(){
+            cout << "Fireball: " << power << endl;
+        }
+};
+
+class Frostbite : public Spell {
+    private: int power;
+    public:
+        Frostbite(int power): power(power) { }
+        void revealFrostpower(){
+            cout << "Frostbite: " << power << endl;
+        }
+};
+
+class Thunderstorm : public Spell { 
+    private: int power;
+    public:
+        Thunderstorm(int power): power(power) { }
+        void revealThunderpower(){
+            cout << "Thunderstorm: " << power << endl;
+        }
+};
+
+class Waterbolt : public Spell { 
+    private: int power;
+    public:
+        Waterbolt(int power): power(power) { }
+        void revealWaterpower(){
+            cout << "Waterbolt: " << power << endl;
+        }
+};
+
+class SpellJournal {
+    public:
+        static string journal;
+        static string read() {
+            return journal;
+        }
+}; 
+string SpellJournal::journal = "";
+
+void counterspell(Spell *spell) {
+
+    /* Enter your code here */
+    if (auto f = dynamic_cast<Fireball*>(spell)) {
+        f->revealFirepower();
+    }
+    else if (auto f = dynamic_cast<Frostbite*>(spell)) {
+        f->revealFrostpower();
+    }
+    else if (auto f = dynamic_cast<Thunderstorm*>(spell)) {
+        f->revealThunderpower();
+    }
+    else if (auto f = dynamic_cast<Waterbolt*>(spell)) {
+        f->revealWaterpower();
+    }
+    else {
+        auto find = [](const string& A, const string& B) -> int
+        {
+            std::vector<std::vector<int>> LCS(A.length() + 1);        
+            for (int i = 0; i < LCS.size(); i++)
+                LCS[i].resize(B.length() + 1);
+            
+            for (int i = 1; i <= A.length(); i++) {
+                for (int j = 1; j <= B.length(); j++) {
+                    if (A[i - 1] == B[j - 1]) {
+                        LCS[i][j] = LCS[i - 1][j - 1] + 1;
+                    }
+                    else {
+                        LCS[i][j] = max(LCS[i - 1][j], LCS[i][j - 1]);
+                    }
+                }
+            }
+            return LCS[A.length()][B.length()];
+        };
+
+        string s1 = spell->revealScrollName();
+        string s2 = SpellJournal::read();
+        int len = 0;
+        if (s1.length() > 0 && s2.length() > 0)
+            len = find(&s1[0], &s2[0]);
+        cout << len << endl;
+    }
+}
+
+class Wizard {
+    public:
+        Spell *cast() {
+            Spell *spell;
+            string s; cin >> s;
+            int power; cin >> power;
+            if(s == "fire") {
+                spell = new Fireball(power);
+            }
+            else if(s == "frost") {
+                spell = new Frostbite(power);
+            }
+            else if(s == "water") {
+                spell = new Waterbolt(power);
+            }
+            else if(s == "thunder") {
+                spell = new Thunderstorm(power);
+            } 
+            else {
+                spell = new Spell(s);
+                cin >> SpellJournal::journal;
+            }
+            return spell;
+        }
+};
+
+int main() {
+    int T;
+    cin >> T;
+    Wizard Arawn;
+    while(T--) {
+        Spell *spell = Arawn.cast();
+        counterspell(spell);
+    }
+    return 0;
+}
diff --git a/Max_Sum_Contiguous_Subarray/Question.txt b/Dynamic Programming/Max_Sum_Contiguous_Subarray/Question.txt
similarity index 100%
rename from Max_Sum_Contiguous_Subarray/Question.txt
rename to Dynamic Programming/Max_Sum_Contiguous_Subarray/Question.txt
diff --git a/Max_Sum_Contiguous_Subarray/Readme.md b/Dynamic Programming/Max_Sum_Contiguous_Subarray/Readme.md
similarity index 100%
rename from Max_Sum_Contiguous_Subarray/Readme.md
rename to Dynamic Programming/Max_Sum_Contiguous_Subarray/Readme.md
diff --git a/Max_Sum_Contiguous_Subarray/Solution.cpp b/Dynamic Programming/Max_Sum_Contiguous_Subarray/Solution.cpp
similarity index 100%
rename from Max_Sum_Contiguous_Subarray/Solution.cpp
rename to Dynamic Programming/Max_Sum_Contiguous_Subarray/Solution.cpp
diff --git a/Maximize the Product/Maximize the product.txt b/Dynamic Programming/Maximize the Product/Maximize the product.txt
similarity index 100%
rename from Maximize the Product/Maximize the product.txt
rename to Dynamic Programming/Maximize the Product/Maximize the product.txt
diff --git a/Maximize the Product/solution.cpp b/Dynamic Programming/Maximize the Product/solution.cpp
similarity index 100%
rename from Maximize the Product/solution.cpp
rename to Dynamic Programming/Maximize the Product/solution.cpp
diff --git a/Maximum sum of digits/code.cpp b/Dynamic Programming/Maximum sum of digits/code.cpp
similarity index 100%
rename from Maximum sum of digits/code.cpp
rename to Dynamic Programming/Maximum sum of digits/code.cpp
diff --git a/Maximum sum of digits/problem_statement.txt b/Dynamic Programming/Maximum sum of digits/problem_statement.txt
similarity index 100%
rename from Maximum sum of digits/problem_statement.txt
rename to Dynamic Programming/Maximum sum of digits/problem_statement.txt
diff --git a/Maximum-Perimeter-Triangle/Maximum-Perimeter-Triangle-Problem b/Dynamic Programming/Maximum-Perimeter-Triangle/Maximum-Perimeter-Triangle-Problem
similarity index 100%
rename from Maximum-Perimeter-Triangle/Maximum-Perimeter-Triangle-Problem
rename to Dynamic Programming/Maximum-Perimeter-Triangle/Maximum-Perimeter-Triangle-Problem
diff --git a/Maximum-Perimeter-Triangle/Solution.cpp b/Dynamic Programming/Maximum-Perimeter-Triangle/Solution.cpp
similarity index 100%
rename from Maximum-Perimeter-Triangle/Solution.cpp
rename to Dynamic Programming/Maximum-Perimeter-Triangle/Solution.cpp
diff --git a/Dynamic Programming/Powerset/powerset.js b/Dynamic Programming/Powerset/powerset.js
new file mode 100644
index 0000000..f6e07b3
--- /dev/null
+++ b/Dynamic Programming/Powerset/powerset.js	
@@ -0,0 +1,22 @@
+// given an array, provide all subsets (powersets);
+
+// [1,3,2]
+// => [[],[1],[2],[3],[1,3],[1,2][2,3],[1,2,3]]
+
+const powerSet = (arr) => {
+  const result = [];
+
+  const _recurse = (chosen, remaining) => {
+    if (remaining.length === 0) {
+      result.push(chosen);
+    } else {
+      _recurse(chosen, remaining.slice(1));
+      _recurse(chosen.concat(remaining[0]), remaining.slice(1));
+    }
+  };
+
+  _recurse([], arr);
+  return result;
+}
+
+console.log(powerSet([1, 2, 3]));
\ No newline at end of file
diff --git a/Dynamic Programming/Powerset/question.txt b/Dynamic Programming/Powerset/question.txt
new file mode 100644
index 0000000..2eb1aca
--- /dev/null
+++ b/Dynamic Programming/Powerset/question.txt	
@@ -0,0 +1,5 @@
+given an array, provide all subsets (powersets);
+
+result:
+[1,3,2]
+[[],[1],[2],[3],[1,3],[1,2][2,3],[1,2,3]]
\ No newline at end of file
diff --git a/Dynamic Programming/Prime_subsequence/question.txt b/Dynamic Programming/Prime_subsequence/question.txt
new file mode 100644
index 0000000..b91d65a
--- /dev/null
+++ b/Dynamic Programming/Prime_subsequence/question.txt	
@@ -0,0 +1,10 @@
+
+Given a sequence of prime numbers A1,A2,…,AN. This sequence has exactly 2N subsequences.
+A subsequence of A is good if it does not contain any two identical numbers; in particular, the empty sequence is good.
+
+You to find the number of good subsequences which contain at most K numbers.
+This number could be very large, so compute it modulo 1,000,000,007.
+
+Constraints:
+1≤K≤N≤105
+2≤Ai≤8,000 for each valid i
diff --git a/Dynamic Programming/Prime_subsequence/solution.cpp b/Dynamic Programming/Prime_subsequence/solution.cpp
new file mode 100644
index 0000000..09cc920
--- /dev/null
+++ b/Dynamic Programming/Prime_subsequence/solution.cpp	
@@ -0,0 +1,41 @@
+#include<bits/stdc++.h>
+using namespace std;
+int main(){
+    ios_base::sync_with_stdio(false);
+    int n,k;cin>>n>>k;
+    int a[n];long long int mod=1000000007;
+    int max=0;
+    for(int i=0;i<n;i++){
+        cin>>a[i];
+        if(a[i]>max)
+            max=a[i];
+    }
+    long int f[max+1];
+    memset(f,0,sizeof(f));
+    for(int i=0;i<n;i++)
+        f[a[i]]++;
+    vector<long int>v;
+    for(int i=0;i<=max;i++)
+        if(f[i])
+            v.push_back(f[i]);
+    long int l=v.size();
+    k=k>l?l:k;
+    long int dpans[k+1][l],val;
+    val=v[0]+1;
+    memset(dpans,0,sizeof(dpans));
+    dpans[0][0]=1;
+    dpans[1][0]=val;
+    long int total=0;
+    for(int i=2;i<=k;i++)
+    	dpans[i][0]=val;
+    for(int i=1;i<l;i++)
+    	dpans[0][i]=1;
+    for(int i=1;i<l;i++)
+    	for(int j=1;j<=k;j++){
+    		total=((v[i]%mod)*(dpans[j-1][i-1])%mod)%mod;
+    		dpans[j][i]=(((dpans[j][i-1])%mod)+(total%mod))%mod;
+    	}
+    total=(dpans[k][l-1])%mod;
+    cout<<total<<endl;
+    return 0;
+}
diff --git a/ROCK/problem.txt b/Dynamic Programming/ROCK/problem.txt
similarity index 100%
rename from ROCK/problem.txt
rename to Dynamic Programming/ROCK/problem.txt
diff --git a/ROCK/rock.cpp b/Dynamic Programming/ROCK/rock.cpp
similarity index 100%
rename from ROCK/rock.cpp
rename to Dynamic Programming/ROCK/rock.cpp
diff --git a/Dynamic Programming/Rod cutting problem/question.txt b/Dynamic Programming/Rod cutting problem/question.txt
new file mode 100644
index 0000000..97e5488
--- /dev/null
+++ b/Dynamic Programming/Rod cutting problem/question.txt	
@@ -0,0 +1 @@
+Given a rod of length n, and an array that contains the prices of all the pieces smaller than n, determine the maximum profit you could obtain from cutting up the rod and selling its pieces.
diff --git a/Dynamic Programming/Rod cutting problem/solution.java b/Dynamic Programming/Rod cutting problem/solution.java
new file mode 100644
index 0000000..9f31281
--- /dev/null
+++ b/Dynamic Programming/Rod cutting problem/solution.java	
@@ -0,0 +1,51 @@
+class rod_cutting
+{
+  static int cut_rod(int price[], int n)
+  {
+    // Declaring a 2D array, T
+    int T[][] = new int[n-1][n+1];
+
+    // Initializing the array to all zeros
+    for(int i=0; i < n-1; i++)
+    {
+      for(int j=0; j < n+1; j++ )
+      {
+        T[i][j] = 0;
+      }
+    }
+
+    for(int i=0; i < n-1; i++)
+    {
+      for(int j=0; j < n+1; j++ )
+      {
+        // First column => 0 length of rod => 0 profit
+        if(j == 0) {
+          continue;
+        }
+
+        // First row => T[i-1][j] doesn't exist so just pick the second value
+        else if(i == 0) {
+          T[i][j] = price[i] + T[i][j-i-1];
+        }
+
+        // where j <= i => T[i][j-i-1] doesn't exist so just pick the first value
+        else if(j-i-1 < 0) {
+          T[i][j] = T[i-1][j];
+        }
+
+        // using the whole expression
+        else {
+          T[i][j] = Math.max(T[i-1][j], (price[i] + T[i][j-i-1]));
+        }
+      }
+    }
+    return T[n-2][n];
+  }
+
+  public static void main(String args[]) 
+  { 
+     int price[] = new int[] {2,5,7,8}; 
+     int n = 5;
+     System.out.println("Maximum profit is " + cut_rod(price, n)); 
+    } 
+}
diff --git a/Dynamic Programming/The Mailbox Manufacturers Problem/mailbox-question.txt b/Dynamic Programming/The Mailbox Manufacturers Problem/mailbox-question.txt
new file mode 100644
index 0000000..be2134a
--- /dev/null
+++ b/Dynamic Programming/The Mailbox Manufacturers Problem/mailbox-question.txt	
@@ -0,0 +1,38 @@
+The Mailbox Manufacturers Problem
+
+In the good old days when Swedish children were still allowed to blow up their fingers with fire-crackers, gangs of excited kids would plague certain smaller cities during Easter time, with only one thing in mind: To blow things up. Small boxes were easy to blow up, and thus mailboxes became a popular target. Now, a small mailbox manufacturer is interested in how many fire-crackers his new mailbox prototype can withstand without exploding and has hired you to help him. He will provide you with k (1≤k≤10) identical mailbox prototypes each fitting up to m (1≤m≤100) crackers.
+
+However, he is not sure of how many fire-crackers he needs to provide you with in order for you to be able to solve his problem, so he asks you. You think for a while and then say:
+
+“Well, if I blow up a mailbox I can’t use it again, so if you would provide me with only k=1 mailboxes, I would have to start testing with 1 cracker, then 2 crackers, and so on until it finally exploded. In the worst case, that is if it does not blow up even when filled with m crackers, I would need 1+2+3+…+m=m(m+1)2 crackers. If m=100 that would mean more than 5000 fire-crackers!�
+
+“That’s too many�, he replies. “What if I give you more than k=1 mailboxes? Can you find a strategy that requires fewer fire crackers?�
+
+Can you? And what is the minimum number of crackers that you should ask him to provide you with?
+
+You may assume the following:
+
+If a mailbox can withstand x fire-crackers, it can also withstand x−1 fire-crackers.
+
+Upon an explosion, a mailbox is either totally destroyed (blown up) or unharmed, which means that it can be reused in another test explosion.
+
+Note: If the mailbox can withstand a full load of m fire-crackers, then the manufacturer will of course be satisfied with that answer. But otherwise he is looking for the maximum number of crackers that his mailboxes can withstand.
+
+Input
+The input starts with a single integer N (1≤N≤100) indicating the number of test cases to follow. Each test case is described by a line containing two integers: k and m, separated by a single space.
+
+Output
+For each test case print one line with a single integer indicating the minimum number of fire-crackers that is needed, in the worst case, in order to figure out how many crackers the mailbox prototype can withstand.
+
+Sample Input
+4
+1 10
+1 100
+3 73
+5 100
+
+Sample Output
+55
+5050
+382
+495
diff --git a/Dynamic Programming/The Mailbox Manufacturers Problem/solution.cpp b/Dynamic Programming/The Mailbox Manufacturers Problem/solution.cpp
new file mode 100644
index 0000000..82a50fb
--- /dev/null
+++ b/Dynamic Programming/The Mailbox Manufacturers Problem/solution.cpp	
@@ -0,0 +1,36 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int memo[11][100][100] = {0};
+
+int solve(int k, int start, int end){
+    if(k == 0){
+        return INT_MAX;
+    }
+    if(k == 1){
+        return (end * (end + 1) / 2 - (start * (start + 1) / 2));
+    }
+    if(start == end){
+        return 0;
+    }
+
+    if(memo[k][start][end] == 0){
+        int result = INT_MAX;
+        for(int i = start + 1; i <= end; i++){
+            result = min(result, i + max(solve(k-1, start, i-1), solve(k, i, end)));
+        }
+        memo[k][start][end] = result;
+    }
+    return memo[k][start][end];
+}
+
+int main(){
+    int nCases;
+    cin >> nCases;
+    while(nCases--){
+        int mailboxes, firecrackers;
+        cin >> mailboxes >> firecrackers;
+        cout << solve(mailboxes, 0, firecrackers) << endl;
+    }
+    return 0;   
+}
diff --git a/Dynamic Programming/Zero_Sum_SubArray/question.txt b/Dynamic Programming/Zero_Sum_SubArray/question.txt
new file mode 100644
index 0000000..de9d990
--- /dev/null
+++ b/Dynamic Programming/Zero_Sum_SubArray/question.txt	
@@ -0,0 +1,4 @@
+Given an Array of size N, identify whether there exists a subarray with zero sum?
+
+Conditions: -10^6<=N<=10^6
+Time limit is 1.0 sec
diff --git a/Dynamic Programming/Zero_Sum_SubArray/solution.cpp b/Dynamic Programming/Zero_Sum_SubArray/solution.cpp
new file mode 100644
index 0000000..793b681
--- /dev/null
+++ b/Dynamic Programming/Zero_Sum_SubArray/solution.cpp	
@@ -0,0 +1,37 @@
+/* C++ Solution */
+
+#include <bits/stdc++.h>
+using namespace std;
+
+/*Function to check whether zero sum subarray exists or not*/
+bool hasZeroSum(int arr[], int N)
+{
+    set<int> st;
+    int sum=0;
+    for(int i=0;i<N;i++)
+    {
+        sum+=arr[i];
+        /*if Set contains a sum already,
+        that means zero sum subArray exists*/
+        if(st.find(sum)!=st.end()||sum==0)
+        return true;
+        
+        st.insert(sum);
+    }
+    return false;
+}
+
+int main() {
+	int N;
+	cin>>N;
+	int arr[N+1];
+	
+	//Array input
+	for(int i=0;i<N;i++)
+	    cin>>arr[i];
+	
+	
+	bool ans = hasZeroSum(arr,N);
+	cout<<ans;
+	return 0;
+}
diff --git a/Dynamic Programming/alphacode/problem_statement.txt b/Dynamic Programming/alphacode/problem_statement.txt
new file mode 100644
index 0000000..9902844
--- /dev/null
+++ b/Dynamic Programming/alphacode/problem_statement.txt	
@@ -0,0 +1,34 @@
+Alice and Bob need to send secret messages to each other and are discussing ways to encode their messages:
+
+Alice: “Let’s just use a very simple code: We’ll assign ‘A’ the code word 1, ‘B’ will be 2, and so on down to ‘Z’ being assigned 26.�
+
+Bob: “That’s a stupid code, Alice. Suppose I send you the word ‘BEAN’ encoded as 25114. You could decode that in many different ways!�
+Alice: “Sure you could, but what words would you get? Other than ‘BEAN’, you’d get ‘BEAAD’, ‘YAAD’, ‘YAN’, ‘YKD’ and ‘BEKD’. I think you would be able to figure out the correct decoding. And why would you send me the word ‘BEAN’ anyway?�
+Bob: “OK, maybe that’s a bad example, but I bet you that if you got a string of length 5000 there would be tons of different decodings and with that many you would find at least two different ones that would make sense.�
+Alice: “How many different decodings?�
+Bob: “Jillions!�
+
+For some reason, Alice is still unconvinced by Bob’s argument, so she requires a program that will determine how many decodings there can be for a given string using her code.
+
+INPUT
+
+Input will consist of multiple input sets. Each set will consist of a single line of at most 5000 digits representing a valid encryption (for example, no line will begin with a 0). There will be no spaces between the digits. An input line of ‘0’ will terminate the input and should not be processed.
+
+OUTPUT
+
+For each input set, output the number of possible decodings for the input string. All answers will be within the range of a 64 bit signed integer.
+
+Example
+
+Input:
+
+25114
+1111111111
+3333333333
+0
+
+Output:
+
+6
+89
+1
diff --git a/Dynamic Programming/alphacode/solution.txt b/Dynamic Programming/alphacode/solution.txt
new file mode 100644
index 0000000..7d8b958
--- /dev/null
+++ b/Dynamic Programming/alphacode/solution.txt	
@@ -0,0 +1,32 @@
+#include <cstdio>
+#include <cstring>
+
+using namespace std;
+
+int main(){
+	int L;
+	char d[5001];
+	long long dp[5001];
+	
+	while(true){
+		scanf("%s",d);
+		if(d[0]=='0') break;
+		
+		L = strlen(d);
+		
+		dp[0] = dp[1] = 1;
+		
+		for(int i = 2;i<=L;++i){
+			dp[i] = 0;
+			
+			char c1 = d[i-2]-'0', c2 = d[i-1]-'0';
+			
+			if(c1==1 || (c1==2 && c2<=6)) dp[i] += dp[i-2];
+			if(c2!=0) dp[i] += dp[i-1];
+		}
+		
+		printf("%lld\n",dp[L]);
+	}
+	
+	return 0;
+}
diff --git a/Dynamic Programming/largest_comman_subsequece/largest_comman_subsecuence.cpp b/Dynamic Programming/largest_comman_subsequece/largest_comman_subsecuence.cpp
new file mode 100644
index 0000000..f8996f7
--- /dev/null
+++ b/Dynamic Programming/largest_comman_subsequece/largest_comman_subsecuence.cpp	
@@ -0,0 +1,35 @@
+#include <iostream>
+#include<bits/stdc++.h>
+#include <string>
+using namespace std;
+int solver(string s1,string s2,vector<vector<int>>&dp,int n,int m)
+{
+    if(s1.empty()||s2.empty())
+        return 0;
+    if(dp[n][m] >= 0)
+        return dp[n][m];
+    if(s1[0]==s2[0])
+    {
+        int ans = 1 + solver(s1.substr(1),s2.substr(1),dp,n-1,m-1);
+            dp[n][m] = ans;
+        return ans;
+    }
+        int ans1 = solver(s1,s2.substr(1),dp,n,m-1);
+        int ans2 = solver(s1.substr(1),s2,dp,n-1,m);
+        dp[n][m] = max(ans1,ans2);
+        return max(ans1,ans2);
+}
+int lcs(string s1, string s2)
+{
+    int n = s1.length(),m=s2.length();
+    vector<vector<int>>dp(n+1,vector<int>(m+1,-1));
+      int ans = solver( s1, s2, dp , s1.length(),s2.length());
+      return ans;
+}
+
+int main()
+{
+    string s1, s2;
+    cin >> s1 >> s2;
+    cout << lcs(s1, s2);
+}
diff --git a/Dynamic Programming/largest_comman_subsequece/question.txt b/Dynamic Programming/largest_comman_subsequece/question.txt
new file mode 100644
index 0000000..5f6391b
--- /dev/null
+++ b/Dynamic Programming/largest_comman_subsequece/question.txt	
@@ -0,0 +1,3 @@
+LCS Problem Statement: Given two sequences, find the length of longest subsequence present in both of them. A subsequence is a sequence that appears in the same relative order, but not necessarily contiguous.
+
+
diff --git a/Product_of_lengths_all_cycles_undirected_graph/question.txt b/Graph/Product_of_lengths_all_cycles_undirected_graph/question.txt
similarity index 100%
rename from Product_of_lengths_all_cycles_undirected_graph/question.txt
rename to Graph/Product_of_lengths_all_cycles_undirected_graph/question.txt
diff --git a/Product_of_lengths_all_cycles_undirected_graph/solution.cpp b/Graph/Product_of_lengths_all_cycles_undirected_graph/solution.cpp
similarity index 100%
rename from Product_of_lengths_all_cycles_undirected_graph/solution.cpp
rename to Graph/Product_of_lengths_all_cycles_undirected_graph/solution.cpp
diff --git a/Greedy/Cutting_a_Rod/CuttingARod.java b/Greedy/Cutting_a_Rod/CuttingARod.java
new file mode 100644
index 0000000..8a29c87
--- /dev/null
+++ b/Greedy/Cutting_a_Rod/CuttingARod.java
@@ -0,0 +1,33 @@
+/**
+ * Time Complexity : O(n^2) 
+ * which is much better than the 
+ * worst case time complexity of Naive Recursive implementation.
+ */
+
+import java.util.*;
+import java.io.*;
+
+class CuttingARod {
+
+    public static int cutCutCut(int price[], int size) {
+
+        int memory[] = new int[size+1];
+        memory[0] = 0;
+        
+        for(int i=1; i<=size; i++){
+            int maximum = Integer.MIN_VALUE;
+            for(int j=0; j<i; j++) {
+                maximum = Math.max(maximum, price[j]+memory[i-j-1]);
+            }
+            memory[i] = maximum;
+        }
+        return memory[size];
+    }
+
+    public static void main(String[] args) {
+        int price[] = new int[] {1, 5, 8, 9, 10, 17, 17, 20};
+        int size = price.length;
+        System.out.println("Maximum Profit: " +
+                            cutCutCut(price, size));
+    }
+}
\ No newline at end of file
diff --git a/Greedy/Cutting_a_Rod/Problem_Statement.txt b/Greedy/Cutting_a_Rod/Problem_Statement.txt
new file mode 100644
index 0000000..7d949f9
--- /dev/null
+++ b/Greedy/Cutting_a_Rod/Problem_Statement.txt
@@ -0,0 +1,8 @@
+Given a rod of length n inches and an array of prices that contains prices of all pieces of size smaller than n. 
+Determine the maximum value obtainable by cutting up the rod and selling the pieces. 
+For example, if length of the rod is 8 and the values of different pieces are given as following, 
+then the maximum obtainable value is 22 (by cutting in two pieces of lengths 2 and 6)
+
+length   | 1   2   3   4   5   6   7   8  
+--------------------------------------------
+price    | 1   5   8   9  10  17  17  20
\ No newline at end of file
diff --git a/The_Coin_Change_Problem/Problem_Statement.txt b/Greedy/The_Coin_Change_Problem/Problem_Statement.txt
similarity index 100%
rename from The_Coin_Change_Problem/Problem_Statement.txt
rename to Greedy/The_Coin_Change_Problem/Problem_Statement.txt
diff --git a/The_Coin_Change_Problem/Solution.java b/Greedy/The_Coin_Change_Problem/Solution.java
similarity index 100%
rename from The_Coin_Change_Problem/Solution.java
rename to Greedy/The_Coin_Change_Problem/Solution.java
diff --git a/HelloWorld.cpp b/HelloWorld.cpp
deleted file mode 100644
index 503f4a6..0000000
--- a/HelloWorld.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <iostream>
-using namespace std;
-
-int main(){
-    cout << "Hello, World ! ";
-    return 0;
-}
diff --git a/LinkedList/Implement a Line Editor with a Linked List/Problem Statement.txt b/LinkedList/Implement a Line Editor with a Linked List/Problem Statement.txt
new file mode 100644
index 0000000..61a74ac
--- /dev/null
+++ b/LinkedList/Implement a Line Editor with a Linked List/Problem Statement.txt	
@@ -0,0 +1,320 @@
+Implement a line editor with a linked list.  Include your code that implements a linked list.  Include your code for the line editor.  
+Edit the main method to invoke your line editor implementation.  
+
+-insertEnd:
+insert at the end of the linked list
+
+-print
+prints the contents of the linked list with correct numbering
+
+-search [string]
+searches the linked list for the inputted string and print out the index and content of it. Otherwise, print "not found".
+
+-edit [index]
+edits the content of the linked list at the given index value
+
+-delete [index]
+deletes the node of the linked list at the given index value
+
+-quit
+quits the program
+
+Hint: Use std::cin statements to read in the test cases with a while loop. Create your own node and linked list structure. Make sure 
+your code works for linked lists of size > 9 (i.e. edit 10). Make sure simply calling the methods won't result in a crash.
+
+Sample Input 1:
+
+insertEnd "now is the time"
+insertEnd "for all good men"
+insertEnd "to come to the aid of their country"
+print
+search "come to the aid"
+quit
+
+Sample Output 1:
+
+1 now is the time
+2 for all good men
+3 to come to the aid of their country
+3 to come to the aid of their country
+
+Sample Input 2:
+
+insertEnd "now is the time"
+insertEnd "for all good men"
+insertEnd "to come to the aid of their country"
+print
+edit 2 "for all good people"
+print
+quit
+
+Sample Output 2:
+
+1 now is the time
+2 for all good men
+3 to come to the aid of their country
+1 now is the time
+2 for all good people
+3 to come to the aid of their country
+
+Sample Input 3:
+
+insertEnd "now is the time"
+insertEnd "for all good people"
+insertEnd "to come to the aid of their country"
+delete 2
+print
+insert 2 "for all good people"
+print
+quit
+
+Sample Output 3:
+
+1 now is the time
+2 to come to the aid of their country
+1 now is the time
+2 for all good people
+3 to come to the aid of their country
+
+Sample Input 4:
+
+insertEnd "hello world"
+insertEnd "how are you doing"
+insertEnd "hello world"
+search "hello world"
+quit
+
+Sample Output 4:
+
+1 hello world
+3 hello world
+
+Sample Input 5:
+
+insertEnd "hello world"
+insertEnd "how are you doing"
+insertEnd "hello world"
+search "hello pluto"
+print
+quit
+
+Sample Output 5:
+
+not found
+1 hello world
+2 how are you doing
+3 hello world
+
+Sample Input 6:
+
+insertEnd "hello world"
+insertEnd "how are you doing"
+insert 2 "hello pluto"
+print
+delete 3
+print
+quit
+
+Sample Output 6:
+
+1 hello world
+2 hello pluto
+3 how are you doing
+1 hello world
+2 hello pluto
+
+Sample Input 7:
+
+insertEnd "now is the time"
+insertEnd "for all good men"
+insertEnd "to come to the aid of their country"
+delete 4
+print
+insert 4 "Patrick Henry or Charles Weller?"
+print
+insert 6 "it was neither"
+print
+quit
+
+Sample Output 7:
+
+1 now is the time
+2 for all good men
+3 to come to the aid of their country
+1 now is the time
+2 for all good men
+3 to come to the aid of their country
+4 Patrick Henry or Charles Weller?
+1 now is the time
+2 for all good men
+3 to come to the aid of their country
+4 Patrick Henry or Charles Weller?
+
+Sample Input 8:
+
+insertEnd "hello mercury"
+insertEnd "hello venus"
+insertEnd "hello world"
+insertEnd "hello pluto"
+insertEnd "how are you doing"
+insert 4 "hello mars"
+insert 5 "hello jupiter"
+insert 6 "hello saturn"
+print
+search "doing"
+quit
+
+Sample Output 8:
+
+1 hello mercury
+2 hello venus
+3 hello world
+4 hello mars
+5 hello jupiter
+6 hello saturn
+7 hello pluto
+8 how are you doing
+8 how are you doing
+
+Sample Input 9:
+
+insertEnd "hello mercury"
+insertEnd "hello venus"
+insertEnd "hello world"
+insertEnd "hello pluto"
+insertEnd "how are you doing"
+insert 4 "hello mars"
+insert 5 "hello jupiter"
+print
+delete 7
+print
+quit
+
+Sample Output 9:
+
+1 hello mercury
+2 hello venus
+3 hello world
+4 hello mars
+5 hello jupiter
+6 hello pluto
+7 how are you doing
+1 hello mercury
+2 hello venus
+3 hello world
+4 hello mars
+5 hello jupiter
+6 hello pluto
+
+Sample Input 10:
+
+insertEnd "hello mercury"
+insertEnd "hello venus"
+insertEnd "hello world"
+insertEnd "hello pluto"
+insertEnd "how are you doing"
+insert 4 "hello mars"
+insert 5 "hello jupiter"
+insert 6 "hello saturn"
+insert 7 "hello neptune"
+insert 8 "hello uranus"
+print
+quit
+
+Sample Output 10:
+
+1 hello mercury
+2 hello venus
+3 hello world
+4 hello mars
+5 hello jupiter
+6 hello saturn
+7 hello neptune
+8 hello uranus
+9 hello pluto
+10 how are you doing
+
+Sample Input 11:
+
+insertEnd "hello mercury"
+insertEnd "hello venus"
+insertEnd "hello world"
+insertEnd "hello pluto"
+insertEnd "how are you doing"
+insert 4 "hello mars"
+insert 5 "hello jupiter"
+print
+insert 8 "I'm fine"
+print
+quit
+
+Sample Output 11:
+
+1 hello mercury
+2 hello venus
+3 hello world
+4 hello mars
+5 hello jupiter
+6 hello pluto
+7 how are you doing
+1 hello mercury
+2 hello venus
+3 hello world
+4 hello mars
+5 hello jupiter
+6 hello pluto
+7 how are you doing
+8 I'm fine
+
+Sample Input 12:
+
+insertEnd "hello mercury"
+insertEnd "hello venus"
+insertEnd "hello world"
+insertEnd "hello pluto"
+insertEnd "how are you doing"
+insert 4 "hello mars"
+insert 5 "hello jupiter"
+print
+edit 7 "I'm fine"
+print
+quit
+
+Sample Output 12:
+
+1 hello mercury
+2 hello venus
+3 hello world
+4 hello mars
+5 hello jupiter
+6 hello pluto
+7 how are you doing
+1 hello mercury
+2 hello venus
+3 hello world
+4 hello mars
+5 hello jupiter
+6 hello pluto
+7 I'm fine
+
+Sample Input 13:
+
+insertEnd "hello world"
+insertEnd "how are you doing"
+insert 2 "hello pluto"
+insert 1 "hello mercury"
+insert 2 "hello venus"
+insert 4 "hello mars"
+insert 5 "hello jupiter"
+print
+quit
+
+Sample Output 13:
+
+1 hello mercury
+2 hello venus
+3 hello world
+4 hello mars
+5 hello jupiter
+6 hello pluto
+7 how are you doing
\ No newline at end of file
diff --git a/LinkedList/Implement a Line Editor with a Linked List/Solution.cpp b/LinkedList/Implement a Line Editor with a Linked List/Solution.cpp
new file mode 100644
index 0000000..589df5d
--- /dev/null
+++ b/LinkedList/Implement a Line Editor with a Linked List/Solution.cpp	
@@ -0,0 +1,217 @@
+//your linked list implementation here
+#include<string>
+#include<iostream>
+#include <locale>
+#include <cstring>
+using namespace std;
+struct Node
+{
+public:
+    string text;
+    Node * next = nullptr;
+};
+class LinkedList
+{
+public:
+    int size;
+    Node *head;
+    LinkedList()    //when should constructor be private
+    {
+        head = nullptr;
+        size = 0;
+    }
+    Node* add(int index, string textToAdd) //returns the new head and inserts a new node (line)
+    {
+        int count = 1;
+        Node *curr = head; //curr points to the address of head
+        Node * toDeleteHead = head;
+        Node *newNode = new Node(); //needs the operating system to assign memory also struct dont need ()
+        Node * toDeleteNew = newNode;
+        newNode->text = textToAdd;
+        /**
+        if(index>size+1){
+            return head;
+        }**/
+        if(head == nullptr){
+            head = newNode;
+            delete toDeleteHead;
+            size++;
+            return head;
+        }
+        if(index ==0){
+            newNode->next = curr;
+            size++;
+            return newNode;
+        }
+        while((curr->next) != nullptr){
+            if(index == count){
+                newNode->next = curr->next;
+                curr->next = newNode;
+                size++;
+                return head;
+            }
+            curr = curr->next;
+            count++;
+        }
+        if(index>count){ //I'm pretty sure this code never runs due to insert x method's print statement
+            //Node * toDelete = head;
+            cout<<"WOW U REALLY SCREWED UP \n";
+            return nullptr;
+        }
+        curr->next = newNode;
+        newNode->next = nullptr;
+        size++;
+        return head;
+    }
+    void print(){
+        int count = 1;
+        Node * temp = head;
+        while(temp != nullptr){
+            cout<< count << " " <<temp->text<<"\n";
+            temp = temp->next;
+            count++;
+        }
+    }
+    void search(const string look){
+        int count = 1;
+        bool find = false;
+        Node * temp = head;
+        while(temp != nullptr){
+            if((temp->text).find(look)!= string::npos){
+                cout<<count<< " " <<temp->text<<"\n";
+                find = true;
+            }
+            temp = temp->next;
+            count++;
+        }
+        if(!find)
+            cout<<"not found" <<"\n";
+    }
+    void edit(int index, const string textReplace){
+        int count = 1;
+        bool find = false;
+        Node * temp = head;
+        while(temp != nullptr){
+            if(count == index){
+                temp->text = textReplace;
+                find = true;
+                break;
+            }
+            temp = temp->next;
+            count++;
+        }
+        if(!find){}
+        //cout<<"not found - edit" <<"\n";
+    }
+    void deletetext(int index){ //delete 1 on empty needs to be fixed
+        int count = 1;
+        Node * prev = head;
+        if(index == 1){
+            if(head != nullptr){
+                Node * toDelete = head;
+                prev = nullptr;
+                head = head->next;
+                delete toDelete;
+                size--; //why was this not here before
+            }
+        }
+        while(prev != nullptr){
+            if(prev->next ==nullptr){ //testing failed case
+                break;
+            }
+            if((count+1) == index){
+                Node * toDelete = prev->next;
+                prev->next = prev->next->next; //prob should delete the value.
+                delete toDelete;
+                size--;
+                break;
+            }
+            count++;
+            prev = prev->next;
+        }
+    }
+};
+//your line editor implementation here
+class LineEditor
+{
+public:
+    LinkedList list;
+    /*
+    void insertEnd(string s){
+        list.head = list.add(1,s);
+    }*/
+    void insert(int index, string s){
+        list.head = list.add(index, s);
+    }
+    void deletetext(int index){
+        list.deletetext(index);
+    }
+    void edit(int index, string s){
+        list.edit(index,s);
+    }
+    void print(){
+        list.print();
+    }
+    void search(string s){
+        list.search(s);
+    }
+};
+
+int main() //need to do more than "9 lines"
+{
+    //your code to invoke line editor here
+    LineEditor le;
+    string s;
+    locale loc;
+    while (s != "quit"){
+        getline (cin,s);
+        if(s.empty()){
+            //cout<<"you inputted like an empty string\n";
+            s="";
+        }
+        if(s.substr(s.find("\"")+1,s.find_last_of("\"")-1-s.find_first_of("\"")).size()>80){
+            //cout<<"you inputted text with more than 80 chars\n";
+            s="";
+        }
+        if(s.substr(s.find(" ")+1,1)=="-"){
+            //cout<<"you inputted a negative index\n";
+            s="";
+        }
+        int temp = s.find(" ");
+        for (int i=0; i<temp; ++i) // you need string:: .. actually u dont seems to be unsign int
+            s[i] = tolower(s[i],loc);
+        if(s.find("insertend") != string::npos) { //you need string::
+            //cout<<(s.find_last_of("\"")-s.find_first_of("\""))<<"\n";
+            le.insert(le.list.size, s.substr(s.find("\"")+1,s.find_last_of("\"")-1-s.find_first_of("\"")));// don't use -12
+        }
+        if(s.find("insert ") != string::npos){
+            //cout<<stoi(s.substr(s.find(" ")+1,s.find_last_of(" ")-1-s.find_first_of(" ")))<<" " <<le.list.size<< "\n";
+            if(s.substr(s.find(" ")+1,1)!="-" && stoi(s.substr(s.find(" ")+1,s.find_last_of(" ")-1-s.find_first_of(" ")))>0){ //&& !(stoi(s.substr(s.find(" ")+1,s.find_last_of(" ")-1-s.find_first_of(" ")))>le.list.size)
+                int indexNumber = stoi(s.substr(s.find(" ")+1,s.find_last_of(" ")-1-s.find_first_of(" ")));
+                /**le.insert(stoi(s.substr(s.find(" ")+1,1))-1, s.substr(s.find("\"")+1,s.find_last_of("\"")-1-s.find_first_of("\"")));//int to string**/
+                /*if(stoi(s.substr(s.find(" ")+1,s.find_last_of(" ")-1-s.find_first_of(" ")))==le.list.size){
+                    le.insert(le.list.size, s.substr(s.find("\"")+1,s.find_last_of("\"")-1-s.find_first_of("\"")));
+                }
+                else{*/
+                if(!(le.list.size==0 && indexNumber-1>0) && indexNumber-1<=le.list.size){
+                    le.insert(indexNumber-1, s.substr(s.find("\"")+1,s.find_last_of("\"")-1-s.find_first_of("\"")));
+                }
+            }
+            //if(s.substr(s.find(" ")+1,1)!="-"
+
+        }
+        if(s.find("search") != string::npos){
+            le.search(s.substr(s.find("\"")+1,s.find_last_of("\"")-1-s.find_first_of("\"")));
+        }
+        if(s.find("print") != string::npos){
+            le.print();
+        }
+        if(s.find("edit") != string::npos){
+            le.edit(stoi(s.substr(s.find(" ")+1,s.find_last_of(" ")-1-s.find_first_of(" "))), s.substr(s.find("\"")+1,s.find_last_of("\"")-1-s.find_first_of("\"")));
+        }
+        if(s.find("delete") != string::npos){
+            le.deletetext(stoi(s.substr(s.find(" ")+1,s.find_last_of(" ")-1-s.find_first_of(" "))));
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/Patterns/AAL/Aditya And Ladders.txt b/Patterns/AAL/Aditya And Ladders.txt
new file mode 100644
index 0000000..273d877
--- /dev/null
+++ b/Patterns/AAL/Aditya And Ladders.txt	
@@ -0,0 +1,31 @@
+Aditya is fond of ladders. Everyday he goes through pictures of ladders online but unfortunately today he ran out of ladder pictures online. Write a program to print “ladder with N steps”, which he can use to get his daily dose of ladder love.
+
+INPUT:
+Input contains integer N, the number of steps in the ladder
+
+OUTPUT:
+
+Print the ladder with the gap between two side rails being 3 spaces(“   “).
+
+Check the sample output for format of printing the ladder.
+
+CONSTRAINTS:
+
+1<=N<=40
+
+Sample Input : 4
+Sample Output: 
+*   *
+*   *
+*****
+*   *
+*   *
+*****
+*   *
+*   *
+*****
+*   *
+*   *
+*****
+*   *
+*   *
\ No newline at end of file
diff --git a/Patterns/AAL/x.cpp b/Patterns/AAL/x.cpp
new file mode 100644
index 0000000..65b0a5b
--- /dev/null
+++ b/Patterns/AAL/x.cpp
@@ -0,0 +1,31 @@
+#include <iostream>
+
+using namespace std;
+
+int main() 
+
+{
+    
+int N,i=0;
+    
+cin>>N;
+    
+while(i<N)
+    
+	{	
+        
+	  cout<<"\n*   *";
+        
+	  cout<<"\n*   *";
+        
+	  cout<<"\n*****";
+        
+	  i++;
+    
+	}
+    
+	cout<<"\n*   *";
+    
+	cout<<"\n*   *";
+
+}
\ No newline at end of file
diff --git a/PatternPrinting/README.md b/Patterns/PatternPrinting/README.md
similarity index 100%
rename from PatternPrinting/README.md
rename to Patterns/PatternPrinting/README.md
diff --git a/PatternPrinting/sum.java b/Patterns/PatternPrinting/sum.java
similarity index 95%
rename from PatternPrinting/sum.java
rename to Patterns/PatternPrinting/sum.java
index d211336..292e80b 100644
--- a/PatternPrinting/sum.java
+++ b/Patterns/PatternPrinting/sum.java
@@ -1,36 +1,36 @@
-class Sum{
-    public void print(int arr[],int n)
-    {
-        int b[] = new int[arr.length-1];
-        if(arr.length>1)
-        {
-            for(int i =0;i<arr.length-1;i++)
-            {
-                b[i] = arr[i] + arr[i+1];
-            }
-            print(b,n);
-        }
-        
-        System.out.println();
-        for(int j=0;j<n-b.length;j++)
-        {
-            System.out.print(" ");
-        }
-        for(int j=0;j<b.length;j++)
-        {
-            System.out.print(b[j]+" ");
-        }
-    }
-    public static void main(String args[])
-    {
-        Sum s = new Sum();
-        //int a[] = {1,1,1,1,1};
-         int a[] = {1,2,1,3,1};
-        s.print(a,a.length);
-        System.out.println();
-        for(int j=0;j<a.length;j++)
-        {
-            System.out.print(a[j]+" ");
-        }
-    }
+class Sum{
+    public void print(int arr[],int n)
+    {
+        int b[] = new int[arr.length-1];
+        if(arr.length>1)
+        {
+            for(int i =0;i<arr.length-1;i++)
+            {
+                b[i] = arr[i] + arr[i+1];
+            }
+            print(b,n);
+        }
+        
+        System.out.println();
+        for(int j=0;j<n-b.length;j++)
+        {
+            System.out.print(" ");
+        }
+        for(int j=0;j<b.length;j++)
+        {
+            System.out.print(b[j]+" ");
+        }
+    }
+    public static void main(String args[])
+    {
+        Sum s = new Sum();
+        //int a[] = {1,1,1,1,1};
+         int a[] = {1,2,1,3,1};
+        s.print(a,a.length);
+        System.out.println();
+        for(int j=0;j<a.length;j++)
+        {
+            System.out.print(a[j]+" ");
+        }
+    }
 }
\ No newline at end of file
diff --git a/Patterns/SpiralMatrix/problem.txt b/Patterns/SpiralMatrix/problem.txt
new file mode 100644
index 0000000..8f5bbe4
--- /dev/null
+++ b/Patterns/SpiralMatrix/problem.txt
@@ -0,0 +1,21 @@
+Given a 2D array, print it in spiral form. See the following examples.
+
+Examples:
+
+Input:
+        1    2   3   4
+        5    6   7   8
+        9   10  11  12
+        13  14  15  16
+
+Output: 
+1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10 
+
+
+Input:
+        1   2   3   4  5   6
+        7   8   9  10  11  12
+        13  14  15 16  17  18
+
+Output: 
+1 2 3 4 5 6 12 18 17 16 15 14 13 7 8 9 10 11
\ No newline at end of file
diff --git a/Patterns/SpiralMatrix/solution.cpp b/Patterns/SpiralMatrix/solution.cpp
new file mode 100644
index 0000000..92b45a2
--- /dev/null
+++ b/Patterns/SpiralMatrix/solution.cpp
@@ -0,0 +1,43 @@
+#include <bits/stdc++.h> 
+using namespace std; 
+#define R 3 
+#define C 6 
+  
+void spiralPrint(int m, int n, int a[R][C]) 
+{ 
+    int i, k = 0, l = 0; 
+  
+    while (k < m && l < n) 
+    { 
+        for (i = l; i < n; ++i) 
+            cout << a[k][i] << " "; 
+        k++; 
+  
+        for (i = k; i < m; ++i) 
+            cout << a[i][n - 1] << " "; 
+        n--; 
+  
+        if (k < m) 
+        { 
+            for (i = n - 1; i >= l; --i) 
+                cout << a[m - 1][i] << " "; 
+            m--; 
+        } 
+  
+        if (l < n) { 
+            for (i = m - 1; i >= k; --i) 
+                cout << a[i][l] << " "; 
+            l++; 
+        } 
+    } 
+} 
+  
+int main() 
+{ 
+    int a[R][C] = { { 1, 2, 3, 4, 5, 6 }, 
+                    { 7, 8, 9, 10, 11, 12 }, 
+                    { 13, 14, 15, 16, 17, 18 } }; 
+  
+    spiralPrint(R, C, a); 
+    return 0; 
+} 
\ No newline at end of file
diff --git a/README.md b/README.md
index 7f7b618..2acee2f 100644
--- a/README.md
+++ b/README.md
@@ -1,11 +1,24 @@
 # Competitive Programming questions
+
 This repo is open for all. Add your favourite competitive programming questions along with the solution.
 
 ## Guidelines
 
-- Create a  folder with the question name.
+- Create a folder with the question name.
 - Add a .txt file with the problem statement and a solution file which contains the solution of the given problem.
 
+## Folder Structure
+
+```
+├── Array
+|    ├── Question/Problem name
+|    |         ├── Question.txt
+|    |         ├── Solution.yourLanguageExt
+```
+
+- Try to maintain `👆above` folder structure.
+- If your question/Problem folder doesn't lie in the above once fill free to create
+
 ## Getting Started
 
 - Fork this repo (button on top)
@@ -17,7 +30,7 @@ git clone https://github.com/your-username/Competitive-Programming-questions.git
 ```
 
 - Create a new folder with the question name.
-- Add your question and solution file in that folder. 
+- Add your question and solution file in that folder.
 - Commit and push
 
 ```markdown
diff --git a/Recursion/Factorial using Recursion/Factorial using recursion.cpp b/Recursion/Factorial using Recursion/Factorial using recursion.cpp
new file mode 100644
index 0000000..3756f5f
--- /dev/null
+++ b/Recursion/Factorial using Recursion/Factorial using recursion.cpp	
@@ -0,0 +1,18 @@
+#include<stdio.h>
+int c,fac;
+int fact(int n)
+{
+	if(n==0){
+		return 1;
+	}
+	fac=n*fact(n-1);
+	return fac;
+}
+int main()
+{
+	 printf("enter a number ");
+	 scanf("%d",&c);
+	 fact(c);
+	 printf("factorial of entered no. is %d",fac);
+return 0;
+}
diff --git a/Recursion/Factorial using Recursion/Question.txt b/Recursion/Factorial using Recursion/Question.txt
new file mode 100644
index 0000000..e11ae3b
--- /dev/null
+++ b/Recursion/Factorial using Recursion/Question.txt	
@@ -0,0 +1,15 @@
+Find factorial of a number using recursion. 
+
+Input
+The input will contain several test cases (not more than 10). Each testcase is a single line with a number n, 0 <= n <= 1 000 000 000.
+
+Output
+For each test case output a single line, containing the factorial as the answer.
+
+Example
+Input:
+1
+5
+
+Output:
+120
\ No newline at end of file
diff --git a/Recursion/Tower-of-Hanoi/Hanoi.java b/Recursion/Tower-of-Hanoi/Hanoi.java
new file mode 100644
index 0000000..a6e0571
--- /dev/null
+++ b/Recursion/Tower-of-Hanoi/Hanoi.java
@@ -0,0 +1,22 @@
+import java.util.Scanner;
+
+class Hanoi{
+    public static void main(String[] args){
+        Scanner newInput = new Scanner(System.in);
+        System.out.print("Enter the value of n: ");
+        int n = newInput.nextInt();
+        char[] rod = new char[]{'A','B','C'};
+        move(n,rod[0],rod[2],rod[1]);
+    }
+
+
+    public static void move(int n, char from, char to, char aux){
+        if (n == 1) {
+            System.out.println("Move " + n + " From " + from + " to " + to);
+            return;
+        }
+        move(n-1,from,aux,to);
+        System.out.println("Move " + n + " From " + from + " to " + to);
+        move(n-1,aux,to,from);
+    }
+}
\ No newline at end of file
diff --git a/Recursion/Tower-of-Hanoi/Tower of Hanoi.txt b/Recursion/Tower-of-Hanoi/Tower of Hanoi.txt
new file mode 100644
index 0000000..88ff2b5
--- /dev/null
+++ b/Recursion/Tower-of-Hanoi/Tower of Hanoi.txt	
@@ -0,0 +1,16 @@
+Tower of Hanoi is a mathematical puzzle where we have three rods and n disks. The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
+1) Only one disk can be moved at a time.
+2) Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
+3) No disk may be placed on top of a smaller disk.
+
+The most ideal solution to this problem has 2^n-1 steps, where, n = number of disks.
+
+For example: 
+For 2 disks :
+Let rod 1 = 'A', rod 2 = 'B', rod 3 = 'C'.
+Number of Steps = 2^2-1 = 3.
+
+Therefore, 
+Step 1 : Shift first disk from 'A' to 'B'.
+Step 2 : Shift second disk from 'A' to 'C'.
+Step 3 : Shift first disk from 'B' to 'C'.
\ No newline at end of file
diff --git a/In search of an easy problem/problem_statement.txt b/Searching/In search of an easy problem/problem_statement.txt
similarity index 100%
rename from In search of an easy problem/problem_statement.txt
rename to Searching/In search of an easy problem/problem_statement.txt
diff --git a/In search of an easy problem/sol.cpp b/Searching/In search of an easy problem/sol.cpp
similarity index 100%
rename from In search of an easy problem/sol.cpp
rename to Searching/In search of an easy problem/sol.cpp
diff --git a/Searching/SGU_weeds_344/weed.cpp b/Searching/SGU_weeds_344/weed.cpp
new file mode 100644
index 0000000..89780a7
--- /dev/null
+++ b/Searching/SGU_weeds_344/weed.cpp
@@ -0,0 +1,63 @@
+//344. Weed
+//http://acm.sgu.ru/problem.php?contest=0&problem=344
+
+#include<bits/stdc++.h>
+
+using namespace std;
+
+int grid[1000][1000];
+queue< pair<int, int> > weeds;
+int cntr = 0, m, n;
+int dx[] = {-1, 0, 0, 1};
+int dy[] = {0, -1, 1, 0};
+
+
+void push(int i, int j){
+	weeds.push(make_pair(i, j));
+	cntr ++;
+}
+
+bool isValid(int i, int j)
+{
+	if ( i < 0 || j < 0 || i >= n || j >= m || grid[i][j] == 2)
+		return false;
+	return true;
+}
+
+
+void bfs(){
+	while(weeds.size() != 0)
+	{
+		pair<int, int> poped = weeds.front();
+		weeds.pop();
+		for (int i = 0; i < 4; i++)
+		{
+			if (isValid(poped.first + dx[i] , poped.second + dy[i]))
+			{
+				grid[poped.first + dx[i]][poped.second + dy[i]] ++;
+				if (grid[poped.first + dx[i]][poped.second + dy[i]] == 2)
+					push(poped.first + dx[i], poped.second + dy[i]);
+			}
+		}
+	}
+}
+
+int main()
+{
+	memset(grid, 0, sizeof grid);
+	cin >> n >> m;
+	for(int i = 0; i < n; i++)
+	{
+		for (int j = 0; j < m; j++)
+		{
+			char c;
+			cin >> c;
+			if (c == 'X'){
+				grid[i][j] = 2;
+				push(i,j);	
+			}
+		}
+	}
+	bfs();
+	cout << cntr << endl;	
+}
diff --git a/Searching/SGU_weeds_344/weed.txt b/Searching/SGU_weeds_344/weed.txt
new file mode 100644
index 0000000..33c5f83
--- /dev/null
+++ b/Searching/SGU_weeds_344/weed.txt
@@ -0,0 +1,44 @@
+
+Andrew has visited his garden for the last time many years ago. Today's property taxes are so high, so Andrew decided to sell his garden. The land was not cultivated for a long time and now it is probably a lot of weed on it. Andrew wants to remove everything from the ground before selling. Now he wants to estimate the amount of work.
+
+The garden has the rectangular form and is divided into N x M equal squares. Andrew's memory is phenomenal. He remembers which squares were occupied by the weed. For the purpose of simplicity, Andrew thinks that each square is either fully occupied by the weed or completely free from it. Andrew likes botany and he knows that if some square is free from the weed but at least two of its adjacent squares are occupied by the weed (two squares are adjacent if they have common side), that square will be also occupied by the weed soon. Andrew is pretty sure that during last years weed occupied every square possible. Please help Andrew to estimate how many squares is occupied by the weed.
+
+Input
+The first line of the input contains integers N and M (1 ≤ N, M ≤ 1000). Next N lines contain M characters each. Character X denotes that the corresponding square is occupied by the weed. A period character (.) denotes an empty square.
+
+Output
+Print one integer denoting the number of squares occupied by the weed after so many years.
+
+Example(s)
+
+sample input
+
+	
+
+3 3
+X..
+.X.
+.X.
+
+
+sample output
+
+6
+
+
+sample input	
+
+
+3 4
+X..X
+.X..
+.X..
+
+sample output
+	
+
+12
+
+
+
+
diff --git a/Sorting/Get Longest Sorted Sequence/answer.py b/Sorting/Get Longest Sorted Sequence/answer.py
new file mode 100644
index 0000000..24a404f
--- /dev/null
+++ b/Sorting/Get Longest Sorted Sequence/answer.py	
@@ -0,0 +1,40 @@
+def get_longest_sorted_sequence(words):
+    count = 1
+    total_letters = 0
+    current = 0
+    increasing_sum = 0
+    is_sequence = True
+
+    if len(words) == 0:
+        return 0
+    else:
+        current = len(words[0])
+
+    for i in range (1, len(words)):
+        next = len(words[i])
+        if current == next-1:
+            print(current)
+            # in sequence
+            count += 1
+            current = len(words[i])
+            print(current)
+        else:
+            current = len(words[i])
+
+    return count
+
+
+# test cases
+print ('Actual  :' + str(get_longest_sorted_sequence(['a', 'is', 'ape', 'in'])))
+print ()
+
+
+print ('Actual  :' + str(get_longest_sorted_sequence(['apple', 'in', 'has', 'wed', 'code', 'rocks', 'bee'])))
+print ()
+
+
+print ('Actual  :' + str(get_longest_sorted_sequence(['apple'])))
+print ()
+
+print ('Actual  :' + str(get_longest_sorted_sequence([])))
+print ()
diff --git a/Sorting/Get Longest Sorted Sequence/problem.txt b/Sorting/Get Longest Sorted Sequence/problem.txt
new file mode 100644
index 0000000..a22267c
--- /dev/null
+++ b/Sorting/Get Longest Sorted Sequence/problem.txt	
@@ -0,0 +1,3 @@
+The function takes in as its parameter a list called words that contains strings. This function first calculates the length of each word, and then returns the count whereby the sequence formed by the length of the words is in increasing order.
+
+The function calculates the length of every string in the list. It has to then generate a sequence of numbers that are of increasing numberical value and return the length of the longest such sequence generated.
\ No newline at end of file
diff --git a/Sorting/Insertion_sort_using_classes/insertion_sort.cpp b/Sorting/Insertion_sort_using_classes/insertion_sort.cpp
new file mode 100644
index 0000000..8aaa360
--- /dev/null
+++ b/Sorting/Insertion_sort_using_classes/insertion_sort.cpp
@@ -0,0 +1,182 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+/* Hi I am using my own class to use in insertion sort function*/
+
+template<class Item>
+class LinearList{
+	private:
+		int MaxSize;
+		Item *element;    // 1D dynamic array
+        int len;
+	public:
+		/* Default constructor. 
+		 * Should create an empty list that not contain any elements*/
+		LinearList()
+		{
+			element=nullptr;
+			len=0;
+		};
+
+		/* This constructor should create a list containing MaxSize elements. You can intialize the elements with any values.*/
+		LinearList(const int& MaxListSize)
+		{
+			MaxSize=MaxListSize;
+			element = new Item[MaxSize];
+			len=0;
+
+		};
+
+		/* Destructor. 
+		 * Must free all the memory contained by the list */
+		~LinearList(){};
+
+		/* Indexing operator.
+     		 * It should behave the same way array indexing does. i.e,
+     		 * LinearList L;
+     		 * L[0] should refer to the first element;
+     		 * L[1] to the second element and so on.
+     		 * */
+		Item& operator[](const int& i)
+		{
+			return element[i];
+		}; //return i'th element of list
+		
+		/* Returns true if the list is empty, false otherwise.
+     		 * */
+		bool isEmpty()
+		{
+			if(len==0)
+			{
+				return true;
+			}
+			else
+			{
+				return false;
+			}
+		};
+
+		/* Returns the actual length (number of elements) in the list.
+     		 * */
+		int  length()
+		{
+			return len;
+		};	
+
+		/* Returns the maximum size of the list.
+     		 * */
+		int  maxSize()
+		{
+			return maxSize;
+		};
+
+		/* Returns the k-th element of the list. 
+		 * */
+		Item  returnListElement(const int k)
+		{
+			return element[k-1];
+		};
+		/* Set x to the k-th element and 
+		 * return true if k-th element is present otherwise return false.
+		 * */
+		bool find(const int k, Item& x)
+		{
+			if(x==element[k-1])
+			{
+				return true;
+			}
+			else
+			{
+				
+				return false;
+			}
+		};
+
+		/* Search for x and 
+		 * return the position if found, else return 0.
+		 * */
+		int  search(Item& x)
+		{
+			for(int i=0;i<len;i++)
+			{
+				if(element[i]==x)
+				{
+					return i+1;
+				}
+			}
+			return 0;
+
+		};
+
+		/* Set x to the k-th element and delete that k-th element.
+		 * */
+		void  deleteElement(const int  k, Item& x)
+		{
+			x=element[k-1];
+			for(int i=k;i<len;i++)
+			{
+				element[i-1]=element[i];
+			}
+			len=len-1;
+		};
+
+		/* Insert x after k-th element.
+		 * */
+		void  insert(const int  k, Item& x)
+		{
+			for(int i=len;i>k;i--)
+			{
+				element[i]=element[i-1];
+			}
+			element[k]=x;
+			len=len+1;
+		};
+
+					
+};
+
+//insertion sort function
+void insertionSort(LinearList<int>& A)
+		{
+			int i,j,temp,len;
+			i=j=0;
+			len=A.length();
+			j=len;
+			for(i=1;i<len;i++)
+			{
+				temp=A[i];
+				for(j=i-1;j>-1;j--)
+				{
+					if(temp<A[j])
+					{
+						A[j+1]=A[j];
+					}
+					else
+					{						
+						break;
+					}
+				}
+				A[j+1]=temp;
+
+			}
+		}
+
+//Driver Function
+int main()
+{
+	int n,temp,i;
+	cin >> n;
+	LinearList<int> l(100);
+	
+	for(i=0;i<n;i++)
+	{
+		cin >> temp;
+		l.insert(i,temp);
+	}
+	insertionSort(l);
+	for(i=0;i<n;i++)
+	{
+		cout << l[i] << " ";
+	}
+	cout << endl;
+}
diff --git a/Sorting/Insertion_sort_using_classes/problem.txt b/Sorting/Insertion_sort_using_classes/problem.txt
new file mode 100644
index 0000000..bda236a
--- /dev/null
+++ b/Sorting/Insertion_sort_using_classes/problem.txt
@@ -0,0 +1,7 @@
+I have made an insertion sort algorithm in c++.
+This program uses a class as its data structure instead of array.
+Input:-
+first line will be the number of elements to be sorted
+second line will contain n space separated elements
+Output:-
+The program will use insertion sort algorithm to output n space separated numbers in sorted order.
\ No newline at end of file
diff --git a/Sorting/Mergesort-JS/mergeSort.js b/Sorting/Mergesort-JS/mergeSort.js
new file mode 100644
index 0000000..7d8061e
--- /dev/null
+++ b/Sorting/Mergesort-JS/mergeSort.js
@@ -0,0 +1,33 @@
+const myArray = [2, 4, 1, 6, -7, 8, 5, 9, 3, 4];
+
+const mergeSort = (arr) => {
+  if (arr.length <= 1) {
+    return arr;
+  }
+
+  let midIdx = Math.floor(arr.length / 2);
+  let left = arr.slice(0, midIdx);
+  let right = arr.slice(midIdx);
+
+  let leftSorted = mergeSort(left);
+  let rightSorted = mergeSort(right);
+
+  return merge(leftSorted, rightSorted);
+
+};
+
+const merge = (arr1, arr2) => {
+  let merged = [];
+
+  while (arr1.length && arr2.length) {
+    if (arr1[0] < arr2[0]) {
+      merged.push(arr1.shift());
+    } else {
+      merged.push(arr2.shift());
+    }
+  }
+
+  return [...merged, ...arr1, ...arr2];
+};
+
+console.log(mergeSort(myArray));
\ No newline at end of file
diff --git a/Sorting/Mergesort-JS/question.txt b/Sorting/Mergesort-JS/question.txt
new file mode 100644
index 0000000..3d3188a
--- /dev/null
+++ b/Sorting/Mergesort-JS/question.txt
@@ -0,0 +1,5 @@
+Sort the given by implementing Quicksort
+[2, 4, 1, 6, -7, 8, 5, 9, 3, 4]
+
+answer:
+[ -7, 1, 2, 3, 4, 4, 5, 6, 8, 9 ]
\ No newline at end of file
diff --git a/Sorting/Merging_Two_Sorted_Array/question.txt b/Sorting/Merging_Two_Sorted_Array/question.txt
new file mode 100644
index 0000000..43fe95f
--- /dev/null
+++ b/Sorting/Merging_Two_Sorted_Array/question.txt
@@ -0,0 +1 @@
+Given two sorted arrays arr1[] and arr2[] in non-decreasing order with size n and m. The task is to merge the two sorted arrays into one sorted array (in non-decreasing order)
diff --git a/Sorting/Merging_Two_Sorted_Array/solution.cpp b/Sorting/Merging_Two_Sorted_Array/solution.cpp
new file mode 100644
index 0000000..a61ab49
--- /dev/null
+++ b/Sorting/Merging_Two_Sorted_Array/solution.cpp
@@ -0,0 +1,54 @@
+#include<bits/stdc++.h>
+using namespace std;
+int main()
+ {
+	int t;
+	cin>>t;
+	while(t--)
+	{
+	    int x,y;
+	    cin>>x>>y;
+	    long a[x+1],b[y+1];
+	    for(int i=0;i<x;i++)
+	    cin>>a[i];
+	    for(int i=0;i<y;i++)
+	    cin>>b[i];
+	    
+	    int i=0,j=0;
+	    vector<long> vec;
+	    while(i<x&&j<y)
+	    {
+	        if(a[i]<b[j])
+	        {
+	            vec.push_back(a[i]);
+	            i++;
+	        }
+	        else if(a[i]>b[j])
+	        {
+	            vec.push_back(b[j]);
+	            j++;
+	        }
+	        else if(a[i]==b[j])
+	        {
+	            vec.push_back(a[i]);
+	            vec.push_back(b[j]);
+	            i++;
+	            j++;
+	        }
+        }
+        while(i<x)
+        {
+            vec.push_back(a[i]);
+            i++;
+        }
+        while(j<y){
+            vec.push_back(b[j]);
+            j++;
+        }
+        for(int i=0;i<vec.size();i++)
+        cout<<vec[i]<<" ";
+        
+        cout<<endl;
+	}
+	return 0;
+}
diff --git a/Sorting/Mersort_In_C++/mergeSort.cpp b/Sorting/Mersort_In_C++/mergeSort.cpp
new file mode 100644
index 0000000..310b08c
--- /dev/null
+++ b/Sorting/Mersort_In_C++/mergeSort.cpp
@@ -0,0 +1,78 @@
+
+#include "../helper.h"
+#include <iostream>
+using namespace std;
+
+void copyArr(int from[], int si, int ei, int * to) {
+    // while (si <= ei) *to++ = *si++;
+    while (si <= ei) {
+        *to = from[si];
+        ++si;
+        ++to;
+    }
+}
+
+
+void mergeSortedArray(int arr[], int si, int ei, int mid) {
+
+    int tmp_A[100];
+    int tmp_B[100];
+
+    copyArr(arr, si, mid, tmp_A);
+    copyArr(arr, mid + 1, ei, tmp_B);
+
+    int i = 0;
+    int j = 0;
+    int k = si;
+
+    //while a has elements and b has elements, I have to do something
+    int size_A = mid - si + 1;
+    int size_B = ei - (mid + 1) + 1;
+
+    while (i < size_A && j < size_B) {
+        if (tmp_A[i] < tmp_B[j]) {
+            arr[k] = tmp_A[i];
+            i++;
+            k++;
+        }
+        else {
+            arr[k++] = tmp_B[j++];
+        }
+    }
+
+    while (i < size_A) {
+        arr[k++] = tmp_A[i++];
+    }
+
+    while (j < size_B) arr[k++] = tmp_B[j++];
+
+
+}
+
+
+void mergeSort(int arr[], int si, int ei) {
+    if (si >= ei) {
+        //no elements
+        return;
+    }
+
+    int mid = (si + ei) / 2;
+    //sort the left part
+    mergeSort(arr, si, mid);
+    mergeSort(arr, mid + 1, ei);
+
+    mergeSortedArray(arr, si, ei, mid);
+
+}
+
+
+int main() {
+    int arr[100];
+    int n;
+    cin >> n;
+    inputArr(arr, n);
+
+    mergeSort(arr, 0, n - 1);
+
+    printArr(arr, n);
+}
diff --git a/Sorting/Mersort_In_C++/mergesort.txt b/Sorting/Mersort_In_C++/mergesort.txt
new file mode 100644
index 0000000..ba3cfe6
--- /dev/null
+++ b/Sorting/Mersort_In_C++/mergesort.txt
@@ -0,0 +1,13 @@
+Merge Sort is a Divide and Conquer algorithm. It divides input array in 
+two halves, calls itself for the two halves and then merges the two sorted halves.
+Algorithm:
+MergeSort(arr[], l,  r)
+If r > l
+1. Find the middle point to divide the array into two halves:  
+             middle m = (l+r)/2
+2. Call mergeSort for first half:   
+             Call mergeSort(arr, l, m)
+3. Call mergeSort for second half:
+             Call mergeSort(arr, m+1, r)
+4. Merge the two halves sorted in step 2 and 3:
+             Call merge(arr, l, m, r)
\ No newline at end of file
diff --git a/Sorting/Quicksort-JS/question.txt b/Sorting/Quicksort-JS/question.txt
new file mode 100644
index 0000000..3d3188a
--- /dev/null
+++ b/Sorting/Quicksort-JS/question.txt
@@ -0,0 +1,5 @@
+Sort the given by implementing Quicksort
+[2, 4, 1, 6, -7, 8, 5, 9, 3, 4]
+
+answer:
+[ -7, 1, 2, 3, 4, 4, 5, 6, 8, 9 ]
\ No newline at end of file
diff --git a/Sorting/Quicksort-JS/quickSort.js b/Sorting/Quicksort-JS/quickSort.js
new file mode 100644
index 0000000..e67e3e7
--- /dev/null
+++ b/Sorting/Quicksort-JS/quickSort.js
@@ -0,0 +1,21 @@
+const myArray = [2, 4, 1, 6, -7, 8, 5, 9, 3, 4];
+
+const quickSortV1 = arr => {
+  if (arr.length <= 1) {
+    return arr;
+  }
+
+  // shift takes out the element of the array
+  // so that it can reach the base case
+  let pivot = arr.shift();
+  let left = arr.filter(el => el < pivot);
+  let right = arr.filter(el => el >= pivot);
+
+  let leftSorted = quickSortV1(left);
+  let rightSorted = quickSortV1(right);
+
+  return [...leftSorted, pivot, ...rightSorted];
+
+};
+
+console.log(quickSortV1(myArray));
\ No newline at end of file
diff --git a/Sorting/Quicksort-python/Question.txt b/Sorting/Quicksort-python/Question.txt
new file mode 100644
index 0000000..f3ca74e
--- /dev/null
+++ b/Sorting/Quicksort-python/Question.txt
@@ -0,0 +1 @@
+Sort the given the array [90, 30, 5, 3, 15, 1, 2 ] by implementing Quicksort
\ No newline at end of file
diff --git a/Sorting/Quicksort-python/algorithm.txt b/Sorting/Quicksort-python/algorithm.txt
new file mode 100644
index 0000000..2e78ce8
--- /dev/null
+++ b/Sorting/Quicksort-python/algorithm.txt
@@ -0,0 +1,10 @@
+ QuickSort is a Divide and Conquer algorithm. It picks an element as pivot and partitions the given array around the picked pivot.
+ There are many different versions of quickSort that pick pivot in different ways.
+
+Always pick first element as pivot.
+Always pick last element as pivot (implemented below)
+Pick a random element as pivot.
+Pick median as pivot.
+The key process in quickSort is partition(). Target of partitions is, given an array and an element x of array as pivot,
+put x at its correct position in sorted array and put all smaller elements (smaller than x) before x, and put all greater
+elements (greater than x) after x. All this should be done in linear time.
\ No newline at end of file
diff --git a/Sorting/Quicksort-python/quickSort.py b/Sorting/Quicksort-python/quickSort.py
new file mode 100644
index 0000000..341997d
--- /dev/null
+++ b/Sorting/Quicksort-python/quickSort.py
@@ -0,0 +1,12 @@
+def quickSort(lst):
+    if len(lst) <= 1:
+        return lst
+    smaller = [x for x in lst[1:] if x < lst[0]]
+    larger = [x for x in lst[1:] if x >= lst[0]]
+    return quickSort(smaller) + [lst[0]] + quickSort(larger)
+
+
+# Main Function
+if __name__ == '__main__':
+    lst = [2, 4, 5, 1]
+    print(quickSort(lst))
diff --git a/Sorting/bubble_sort_c/question.txt b/Sorting/bubble_sort_c/question.txt
new file mode 100644
index 0000000..bd6c83d
--- /dev/null
+++ b/Sorting/bubble_sort_c/question.txt
@@ -0,0 +1,2 @@
+Make a C program to bubble sort this array of integers (smallest to biggest): {303, -909, 101, 42, 0, 42, 21, 1, 2}
+Expected result => {-909, 0, 1, 2, 21. 42, 42, 101, 303}
diff --git a/Sorting/bubble_sort_c/solution/bubble_sort.c b/Sorting/bubble_sort_c/solution/bubble_sort.c
new file mode 100644
index 0000000..8f7ab02
--- /dev/null
+++ b/Sorting/bubble_sort_c/solution/bubble_sort.c
@@ -0,0 +1,23 @@
+#include "bubble_sort.h"
+
+void	swap_values(int *a, int *b)
+{
+	int buffer = *a;
+	*a = *b;
+	*b = buffer;
+}
+
+int *bubble_sort(int *arr, size_t arr_len)
+{
+	size_t i = 0;
+
+	while (i++ < arr_len)
+	{
+		if (arr[i] < arr[i-1])
+		{
+			swap_values(&arr[i], &arr[i-1]);
+			i = 0;
+		}
+	}
+	return(arr);
+}
diff --git a/Sorting/bubble_sort_c/solution/bubble_sort.h b/Sorting/bubble_sort_c/solution/bubble_sort.h
new file mode 100644
index 0000000..4e69c28
--- /dev/null
+++ b/Sorting/bubble_sort_c/solution/bubble_sort.h
@@ -0,0 +1,5 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int *bubble_sort(int *arr, size_t arr_len);
+void	print_array(int *arr, size_t arr_len);
diff --git a/Sorting/bubble_sort_c/solution/main.c b/Sorting/bubble_sort_c/solution/main.c
new file mode 100644
index 0000000..9616442
--- /dev/null
+++ b/Sorting/bubble_sort_c/solution/main.c
@@ -0,0 +1,12 @@
+#include "bubble_sort.h"
+
+int main(void)
+{
+	int to_sort[] = {303, -909, 101, 42, 0, 42, 21, 1, 2};
+	size_t arr_len = sizeof(to_sort) / sizeof(to_sort[0]);
+	int *sorted = bubble_sort(to_sort, arr_len);
+
+	print_array(sorted, arr_len);
+
+	return(EXIT_SUCCESS);
+}
diff --git a/Sorting/bubble_sort_c/solution/print_array.c b/Sorting/bubble_sort_c/solution/print_array.c
new file mode 100644
index 0000000..39c130a
--- /dev/null
+++ b/Sorting/bubble_sort_c/solution/print_array.c
@@ -0,0 +1,10 @@
+#include "bubble_sort.h"
+
+void	print_array(int *arr, size_t arr_len)
+{
+	size_t i;
+
+	printf("Sorted array:\n");
+	for (i = 0; i < arr_len; i++)
+		printf("%d\n", arr[i]);
+}
diff --git a/Stack/Binary numbers/Question.txt b/Stack/Binary numbers/Question.txt
new file mode 100644
index 0000000..d540fa0
--- /dev/null
+++ b/Stack/Binary numbers/Question.txt	
@@ -0,0 +1 @@
+The question is how to make binary numbers using a stack.
\ No newline at end of file
diff --git a/Stack/Binary numbers/solution.cpp b/Stack/Binary numbers/solution.cpp
new file mode 100644
index 0000000..a388706
--- /dev/null
+++ b/Stack/Binary numbers/solution.cpp	
@@ -0,0 +1,27 @@
+#include <iostream>
+#include <stack>
+using namespace std;
+int main()
+{
+  int a,b,l,c;
+  stack <int> stos;
+  cout << "Number to change: ";
+  cin >> a;
+	l=a;
+
+  while(a!=0)
+  {
+      b=a%2;
+      a=a/2;
+      stos.push(b);
+  }
+	cout << "Number " << l << " is equal to:  ";
+    while(!stos.empty())
+  {
+      cout << stos.top();
+      stos.pop();
+  }
+    cout << " in binary system.";
+
+return 0;
+}
diff --git a/Stack/Generate Parentheses/Question.txt b/Stack/Generate Parentheses/Question.txt
new file mode 100644
index 0000000..4b3c0df
--- /dev/null
+++ b/Stack/Generate Parentheses/Question.txt	
@@ -0,0 +1,11 @@
+Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
+
+For example, given n = 3, a solution set is:
+
+[
+  "((()))",
+  "(()())",
+  "(())()",
+  "()(())",
+  "()()()"
+]
\ No newline at end of file
diff --git a/Stack/Generate Parentheses/Solution b/Stack/Generate Parentheses/Solution
new file mode 100644
index 0000000..c1d065f
Binary files /dev/null and b/Stack/Generate Parentheses/Solution differ
diff --git a/Stack/Generate Parentheses/Solution.cpp b/Stack/Generate Parentheses/Solution.cpp
new file mode 100644
index 0000000..3153f05
--- /dev/null
+++ b/Stack/Generate Parentheses/Solution.cpp	
@@ -0,0 +1,45 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+void generate(int n, int opening, int closing, string combination, vector<string>& result) {
+    int size = combination.size();
+    if(size == n && closing == opening) {
+        result.push_back(combination);
+        return;
+    }
+    
+    if((closing < opening) && (size > 0)) {
+        combination.push_back(')');
+        generate(n, opening, closing+1, combination, result);
+        combination.pop_back();
+    }
+    
+    if(size < n-1) {
+        combination.push_back('(');
+        generate(n, opening+1, closing, combination, result);
+        combination.pop_back();    
+    }
+}
+
+vector<string> generateParenthesis(int n) {
+    vector<string> result;
+    string combination;
+    generate(2*n, 0, 0, combination, result);
+    return result;
+}
+
+int main() {
+
+    int n;
+    vector<string> result;
+
+    scanf("%d", &n);
+
+    result = generateParenthesis(n);
+    
+    for(int i=0; i<result.size(); i++) {
+        printf("%s\n", result[i].c_str());
+    }
+
+    return 0;   
+}
\ No newline at end of file
diff --git a/Street parade/code.cpp b/Stack/Street parade/code.cpp
similarity index 100%
rename from Street parade/code.cpp
rename to Stack/Street parade/code.cpp
diff --git a/Street parade/problem_statement.txt b/Stack/Street parade/problem_statement.txt
similarity index 100%
rename from Street parade/problem_statement.txt
rename to Stack/Street parade/problem_statement.txt
diff --git a/String/AnagramChecking/anagram_checking.py b/String/AnagramChecking/anagram_checking.py
new file mode 100644
index 0000000..db37c54
--- /dev/null
+++ b/String/AnagramChecking/anagram_checking.py
@@ -0,0 +1,39 @@
+# Python3 program to check if two strings are anagram of each other
+
+def are_anagram(s1, s2):
+    """ Check if two strings are anagram of each other.
+
+    Apply XOR to all characters of both strings. If the final value is 0, then
+    there is an even occurence of all characters, ie the two strings are
+    anagram. Otherwise, there are not anagram.
+
+    Args:
+        s1 (str): First string
+        s2 (str): Second string
+
+    Returns:
+        bool: True if the two strings are anagram of each other, otherwise False
+    """
+    # Two strings with different sizes can not be anagram of each other
+    if len(s1) != len(s2):
+        return False
+
+    # Apply XOR to all characters of both strings
+    xor_value = 0
+    for c1, c2 in zip(s1, s2):
+        xor_value = xor_value ^ ord(c1)
+        xor_value = xor_value ^ ord(c2)
+
+    return not bool(xor_value)
+
+def main():
+    """ Driver code """
+    s1 = 'listen'
+    s2 = 'silent'
+    s3 = 'hacktoberfest'
+    print('{} / {} -> {}'.format(s1, s2, are_anagram(s1, s2)))
+    print('{} / {} -> {}'.format(s1, s3, are_anagram(s1, s3)))
+    print('{} / {} -> {}'.format(s2, s3, are_anagram(s2, s3)))
+
+if __name__=='__main__':
+    main()
diff --git a/String/AnagramChecking/anagram_checking.txt b/String/AnagramChecking/anagram_checking.txt
new file mode 100644
index 0000000..43158e6
--- /dev/null
+++ b/String/AnagramChecking/anagram_checking.txt
@@ -0,0 +1,3 @@
+Anagram checking
+
+Write a function that check whether two given strings are anagram of each other. An anagram is a word or phrase formed by rearranging the letters of a different word or phrase using all the original letters exactly once. An optimized solution should have a O(n) time complexity and O(1) space complexity.
diff --git a/Arrangement_of_Queue/Question.txt b/String/Arrangement_of_Queue/Question.txt
similarity index 100%
rename from Arrangement_of_Queue/Question.txt
rename to String/Arrangement_of_Queue/Question.txt
diff --git a/Arrangement_of_Queue/README.md b/String/Arrangement_of_Queue/README.md
similarity index 100%
rename from Arrangement_of_Queue/README.md
rename to String/Arrangement_of_Queue/README.md
diff --git a/Arrangement_of_Queue/Solution.py b/String/Arrangement_of_Queue/Solution.py
similarity index 100%
rename from Arrangement_of_Queue/Solution.py
rename to String/Arrangement_of_Queue/Solution.py
diff --git a/String/Cenit-Polar-Crypt/Issue.txt b/String/Cenit-Polar-Crypt/Issue.txt
new file mode 100644
index 0000000..9014f79
--- /dev/null
+++ b/String/Cenit-Polar-Crypt/Issue.txt
@@ -0,0 +1,40 @@
+Create a solution that can be able to encrypt a string using Cenit-Polar Method
+
+- Solution
+Cenit Polar it's a basic scout crytographic method based on replace characters
+corresponding this order :
+-------------------------
+| C | E  | N  | I  | T  | 
+-------------------------
+| P | O  | L  | A  | R  | 
+-------------------------
+
+The main idea is take a word and replace the characters which match in CENIT, with its equivalent on POLAR and viceversa.
+
+For example, if you want to encrypt the word COMPUTER, you should have to replace any character.
+If some character don't have match, you should keep it in place:
+
+C = P
+O = E
+M = M
+P = C
+U = U
+T = R
+E = O
+R = T
+
+If you want to decript the word generated, you have to do reverse the process, replacing any character which have match in POLAR,
+with its equivalent on CENIT :
+
+P = C 
+E = O 
+M = M 
+C = P 
+U = U 
+R = T 
+O = E 
+T = R 
+
+Cenit - Polar makes this alphabet table:
+A	B	C	D	E	F	G	H	I	J	K	L	M	N	Ñ	O	P	Q	R	S	T	U	V	W	X	Y	Z
+I	B	P	D	O	F	G	H	A	J	K	N	M	L	Ñ	E	C	Q	T	S	R	U	V	W	X	Y	Z
\ No newline at end of file
diff --git a/String/Cenit-Polar-Crypt/Solution.js b/String/Cenit-Polar-Crypt/Solution.js
new file mode 100644
index 0000000..e5f1bfc
--- /dev/null
+++ b/String/Cenit-Polar-Crypt/Solution.js
@@ -0,0 +1,21 @@
+
+function processWord(encryptedWord){
+    let splitedText = (encryptedWord.toLowerCase()).split("");
+    let cenit = ["c", "e", "n", "i", "t"];
+    var polar = ["p", "o", "l", "a", "r"];
+    var encryptWordArray = [];
+    splitedText.map(function(i) {
+      if (cenit.indexOf(i) > -1) {
+        i = polar[cenit.indexOf(i)];
+        encryptWordArray.push(i);
+      } else if (polar.indexOf(i) > -1) {
+        i = cenit[polar.indexOf(i)];
+        encryptWordArray.push(i);
+      } else {
+        encryptWordArray.push(i);
+      }
+    });
+    return encryptWordArray.join("").toUpperCase();
+}
+
+console.log(processWord("COMPUTER"));
\ No newline at end of file
diff --git a/String/Check_String_Palindrome/Source1.cpp b/String/Check_String_Palindrome/Source1.cpp
new file mode 100644
index 0000000..8585e70
--- /dev/null
+++ b/String/Check_String_Palindrome/Source1.cpp
@@ -0,0 +1,30 @@
+#include<iostream>
+#include<string>
+
+using namespace std;
+
+//This is a function that returns a boolean value, after checking the string.
+bool checkStringPallindrome(string inputString);
+
+bool checkStringPallindrome(string inputString) {
+	for (int i = 0; i < (inputString.length() / 2); i++) {
+		if (inputString.at(i) != inputString.at(inputString.length() - 1 - i)) {
+			return false;
+		}
+	}
+	return true;
+}
+void main() {
+
+	clrscr(); //this inbuild function clears the screen
+	string input; //the string to check whether its palindrome or not
+	getline(cin, input); 
+	if (checkStringPallindrome(input)) {
+		cout << "true" << endl;
+	}
+	else {
+		cout << "false" << endl;
+	}
+
+	getch();
+}
diff --git a/String/Check_String_Palindrome/problem.txt b/String/Check_String_Palindrome/problem.txt
new file mode 100644
index 0000000..14448c8
--- /dev/null
+++ b/String/Check_String_Palindrome/problem.txt
@@ -0,0 +1,17 @@
+You are given a string consisting of letters from a-z and A-Z. No any special characters. A palindrome is a word which is equal to itself when reversed. Examples are DAD, MOM, APCPA. Words like TIGER, RAT are not palindromes.
+Input and Output:
+The function should take a queue of characters as input and return True or False as output. If the queue is empty return true.
+
+
+Sample Input 1: 
+ABCBA
+Sample Output 1: 
+true
+Sample Input 2: 
+PrOGraMiNG
+Sample Output 2: 
+false
+Sample Input 3: 
+AA
+Sample Output 3: 
+true
\ No newline at end of file
diff --git a/String/FANCY/problem.txt b/String/FANCY/problem.txt
new file mode 100644
index 0000000..50a5747
--- /dev/null
+++ b/String/FANCY/problem.txt
@@ -0,0 +1,32 @@
+Chef was reading some quotes by great people. Now, he is interested in classifying all the fancy quotes he knows. He thinks that all fancy quotes which contain the word "not" are Real Fancy; quotes that do not contain it are regularly fancy.
+
+You are given some quotes. For each quote, you need to tell Chef if it is Real Fancy or just regularly fancy.
+
+Input
+The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
+The first and only line of each test case contains a single string S denoting a quote.
+
+Output
+For each test case, print a single line containing the string "Real Fancy" or "regularly fancy" (without quotes).
+
+Constraints
+1≤T≤50
+1≤|S|≤100
+each character of S is either a lowercase English letter or a space
+
+Subtasks
+Subtask #1 (100 points): original constraints
+
+Example Input
+2
+i do not have any fancy quotes
+when nothing goes right go left
+
+Example Output
+Real Fancy
+regularly fancy
+
+Explanation
+Example case 1: "i do not have any fancy quotes"
+
+Example case 2: The word "not" does not appear in the given quote.
\ No newline at end of file
diff --git a/String/FANCY/solution.py b/String/FANCY/solution.py
new file mode 100644
index 0000000..056df26
--- /dev/null
+++ b/String/FANCY/solution.py
@@ -0,0 +1,16 @@
+# cook your dish here
+x=int(input())
+p=0
+flag=0
+while(p<x):
+    s=str(input())
+    s=s.split(" ")
+    for i in range(len(s)):
+        if(s[i]=='not'):
+            print("Real Fancy")
+            flag=1
+            break
+    if(flag==0):
+        print("regularly fancy")
+    flag=0
+    p=p+1
\ No newline at end of file
diff --git a/String/Isograms/isograms.py b/String/Isograms/isograms.py
new file mode 100644
index 0000000..453f09f
--- /dev/null
+++ b/String/Isograms/isograms.py
@@ -0,0 +1,12 @@
+def is_isogram(string):
+    lower_string = string.lower()
+    unique_string = set(lower_string)
+    return (len(lower_string)==len(unique_string))
+
+def main():
+    print(is_isogram("Dermatoglyphics"))
+    print(is_isogram("aba"))
+    print(is_isogram("moOse"))
+    print(is_isogram(""))
+
+main()
\ No newline at end of file
diff --git a/String/Isograms/problem_statement.txt b/String/Isograms/problem_statement.txt
new file mode 100644
index 0000000..60d5e8a
--- /dev/null
+++ b/String/Isograms/problem_statement.txt
@@ -0,0 +1,7 @@
+An isogram is a word that has no repeating letters, consecutive or non-consecutive. 
+How to determine whether a string is an isogram. Ignore letter case
+
+Ex.
+"Dermatoglyphics" is isogram.
+"aba" is not isogram.
+"moOse"  is not isogram.
\ No newline at end of file
diff --git a/String/Palindrome/palindrome.c b/String/Palindrome/palindrome.c
new file mode 100644
index 0000000..3eed551
--- /dev/null
+++ b/String/Palindrome/palindrome.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+int main()
+{
+    int n, reversedInteger = 0, remainder, originalInteger;
+    printf("Enter an integer: ");
+    scanf("%d", &n);
+    originalInteger = n;
+    // reversed integer is stored in variable 
+    while( n!=0 )
+    {
+        remainder = n%10;
+        reversedInteger = reversedInteger*10 + remainder;
+        n /= 10;
+    }
+    // palindrome if orignalInteger and reversedInteger are equal
+    if (originalInteger == reversedInteger)
+        printf("%d is a palindrome.", originalInteger);
+    else
+        printf("%d is not a palindrome.", originalInteger);
+    
+    return 0;
+}
diff --git a/String/Palindrome/question.txt b/String/Palindrome/question.txt
new file mode 100644
index 0000000..6e1fc41
--- /dev/null
+++ b/String/Palindrome/question.txt
@@ -0,0 +1,6 @@
+
+A palindromic number (or a numeric palindrome) is a number that remains the same when its digits are reversed.
+Like 16461, for example, it is "symmetrical".
+
+This program reverses an integer (entered by the user) using while loop. 
+Then, if statement is used to check whether the reversed number is equal to the original number or not.
diff --git a/String/Python_Palindrome/PalindromeQues.txt b/String/Python_Palindrome/PalindromeQues.txt
new file mode 100644
index 0000000..bedc45d
--- /dev/null
+++ b/String/Python_Palindrome/PalindromeQues.txt
@@ -0,0 +1,9 @@
+Given a string, write a python function to check if it is palindrome or not. A string is said to be palindrome if reverse of the string is same as string. For example, “radar� is palindrome, but “radix� is not palindrome.
+
+Examples:
+
+Input : malayalam
+Output : Yes
+
+Input : geeks
+Output : No
\ No newline at end of file
diff --git a/String/Python_Palindrome/solution.py b/String/Python_Palindrome/solution.py
new file mode 100644
index 0000000..aa14a75
--- /dev/null
+++ b/String/Python_Palindrome/solution.py
@@ -0,0 +1,22 @@
+# function which return reverse of a string 
+def reverse(s): 
+	return s[::-1] 
+
+def isPalindrome(s): 
+	# Calling reverse function 
+	rev = reverse(s) 
+
+	# Checking if both string are equal or not 
+	if (s == rev): 
+		return True
+	return False
+
+
+# Driver code 
+s = "malayalam"
+ans = isPalindrome(s) 
+
+if ans == 1: 
+	print("Yes") 
+else: 
+	print("No") 
diff --git a/String/Reverse string in place/question.txt b/String/Reverse string in place/question.txt
new file mode 100644
index 0000000..bce9195
--- /dev/null
+++ b/String/Reverse string in place/question.txt	
@@ -0,0 +1,2 @@
+Write a program to reverse a String in place in Java, without using additional memory.
+You cannot use any library classes or methods like e.g. StringBuilder to solve this problem. This restriction is placed because StringBuilder and StringBuffer class define a reverse() method which can easily reverse the given String.
diff --git a/String/Reverse string in place/solution.java b/String/Reverse string in place/solution.java
new file mode 100644
index 0000000..21999cc
--- /dev/null
+++ b/String/Reverse string in place/solution.java	
@@ -0,0 +1,74 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Java Program to reverse a String in place, 
+ * without any additional buffer in Java.
+ *
+ * @author WINDOWS 8
+ *
+ */
+public class StringReversal {
+
+    /**
+     * Java method to reverse a String in place
+     * @param str 
+     * @return  reverse of String
+     */
+    public static String reverse(String str) {
+        if(str == null || str.isEmpty()){
+            return str;
+        }
+        char[] characters = str.toCharArray();
+        int i = 0;
+        int j = characters.length - 1;
+        while (i < j) {
+            swap(characters, i, j);
+            i++;
+            j--;
+        }
+        return new String(characters);
+    }
+
+    /**
+     * Java method to swap two numbers in given array
+     * @param str
+     * @param i
+     * @param j 
+     */
+    private static void swap(char[] str, int i, int j) {
+        char temp = str[i];
+        str[i] = str[j];
+        str[j] = temp;
+    }
+
+    @Test
+    public void reverseEmptyString(){
+        Assert.assertEquals("", reverse(""));
+    }
+    
+    @Test
+    public void reverseString(){
+        Assert.assertEquals("cba", reverse("abc"));
+    }
+    
+    @Test
+    public void reverseNullString(){
+        Assert.assertEquals(null, reverse(null));
+    }
+    
+    @Test
+    public void reversePalindromeString(){
+        Assert.assertEquals("aba", reverse("aba"));
+    }
+    
+    @Test
+    public void reverseSameCharacterString(){
+        Assert.assertEquals("aaa", reverse("aaa"));
+    }
+    
+    @Test
+    public void reverseAnagramString(){
+        Assert.assertEquals("mary", reverse("yram"));
+    }
+}
diff --git a/String/ReverseChars/ReverseChars.java b/String/ReverseChars/ReverseChars.java
new file mode 100644
index 0000000..bd0c68e
--- /dev/null
+++ b/String/ReverseChars/ReverseChars.java
@@ -0,0 +1,26 @@
+class main {
+
+    public static void main(String[] args){
+
+        System.out.println(reverseChars("These Chars will be in reverse"));
+
+        }
+
+    public static String reverseChars(String reverseIt) {
+
+        int stringLength;
+        String itReversed;
+
+        reverseIt = reverseIt;
+
+        stringLength = reverseIt.length();
+        itReversed = "";
+
+        for (int i = 1; i <= stringLength; i++){
+            char backwardChars = reverseIt.charAt(stringLength - i);
+
+            itReversed += backwardChars;
+        }
+        return itReversed;
+    }
+        }
\ No newline at end of file
diff --git a/String/ReverseChars/problem.txt b/String/ReverseChars/problem.txt
new file mode 100644
index 0000000..bd800af
--- /dev/null
+++ b/String/ReverseChars/problem.txt
@@ -0,0 +1 @@
+This is a program that takes a given string and loops through the string and places each character in reverse!
\ No newline at end of file
diff --git a/String/SplitString/Question.txt b/String/SplitString/Question.txt
new file mode 100644
index 0000000..07ff26c
--- /dev/null
+++ b/String/SplitString/Question.txt
@@ -0,0 +1,4 @@
+Given a string, break it into a vector of substrings separated by a specific
+character. For example: get the string "name.midname.lastname" and the
+character "." as separator, the function should return a list/vector with the
+strings {"name", "midname", "lastname"}
diff --git a/String/SplitString/Solution.cpp b/String/SplitString/Solution.cpp
new file mode 100644
index 0000000..3ada9f2
--- /dev/null
+++ b/String/SplitString/Solution.cpp
@@ -0,0 +1,39 @@
+#include <iostream>
+#include <vector>
+#include <string>
+using namespace std;
+
+/** Gets a string and separe through a separator _sep and returns into a
+ * std::vector<std::string> */
+std::vector<std::string> split(std::string _str, char _sep) {
+    std::vector<std::string> v;
+    int begin = 0;
+    for (int i=0 ; i < _str.size() ; i++){
+        if (_str[i] == _sep) {
+            v.push_back( _str.substr(begin, i-begin) );
+            begin = i+1;
+        }
+    }
+    v.push_back(_str.substr(begin, _str.size()));
+    return v;
+};
+
+
+int main() {
+
+    string str1 = "name.midname.lastname";
+    vector<string> vecStr1 = split(str1, '.');
+    for (string& s : vecStr1) {
+        cout << s << endl;
+    }
+
+    cout << endl;
+    string str2 = "myname@emailservice.com";
+
+    vector<string> vecStr2 = split(str2, '@');
+    for (string& s : vecStr2) {
+        cout << s << endl;
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/String/String_Permutation/question.txt b/String/String_Permutation/question.txt
new file mode 100644
index 0000000..65c6d8b
--- /dev/null
+++ b/String/String_Permutation/question.txt
@@ -0,0 +1 @@
+Check if two strings are permutations of each other.
diff --git a/String/String_Permutation/solution.cpp b/String/String_Permutation/solution.cpp
new file mode 100644
index 0000000..2da7d53
--- /dev/null
+++ b/String/String_Permutation/solution.cpp
@@ -0,0 +1,25 @@
+#include<iostream>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+
+
+int main()
+{
+    string a,b;
+    cout<<"Enter two strings \n";
+    cin>>a>>b;
+    sort(a.begin(),a.end());
+    sort(b.begin(),b.end());
+    
+    if(a==b)
+        cout<<"These strings are permutations of each other\n";
+    else
+        cout<<"These strings are NOT permutations of each other\n";
+    
+
+    return 0;   
+}
+
+
+
diff --git a/String/StrongPassword/solution.py b/String/StrongPassword/solution.py
new file mode 100644
index 0000000..01c2e43
--- /dev/null
+++ b/String/StrongPassword/solution.py
@@ -0,0 +1,55 @@
+#!/bin/python3
+
+import math
+import os
+import random
+import re
+import sys
+
+def minimumNumber(n, password):
+    # Return the minimum number of characters to make the password strong
+    numbers = list("0123456789")
+    lower_case = list("abcdefghijklmnopqrstuvwxyz")
+    upper_case = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+    special_characters = list("!@#$%^&*()-+")
+    count = 0
+    length = len(password)
+    flagn = 0
+    flagl = 0
+    flagu = 0
+    flags = 0
+    for i in password:
+        if i in numbers:
+            flagn = 1
+    for i in password:
+        if i in lower_case:
+            flagl = 1
+    for i in password:
+        if i in upper_case:
+            flagu = 1
+    for i in special_characters:
+        if i in password:
+            flags = 1
+    if flagn == 0:
+        count+=1
+    if flagu == 0:
+        count+=1
+    if flagl == 0:
+        count+=1
+    if flags == 0:
+        count+=1    
+    
+    check = length + count
+    if check < 6:
+        count = count + (6 - (length + count))
+    return count  
+    
+if __name__ == '__main__':
+
+    n = int(input())
+
+    password = input()
+
+    answer = minimumNumber(n, password)
+
+    print(answer)
diff --git a/String/StrongPassword/strongpasswordqn.txt b/String/StrongPassword/strongpasswordqn.txt
new file mode 100644
index 0000000..12b2952
--- /dev/null
+++ b/String/StrongPassword/strongpasswordqn.txt
@@ -0,0 +1,51 @@
+Louise joined a social networking site to stay in touch with her friends. The signup page required her to input a name and a password. However, the password must be strong. The website considers a password to be strong if it satisfies the following criteria:
+
+Its length is at least 6.
+It contains at least one digit.
+It contains at least one lowercase English character.
+It contains at least one uppercase English character.
+It contains at least one special character. The special characters are: !@#$%^&*()-+
+She typed a random string of length n in the password field but wasn't sure if it was strong. Given the string she typed, can you find the minimum number of characters she must add to make her password strong?
+
+Note: Here's the set of types of characters in a form you can paste in your solution:
+
+numbers = "0123456789"
+lower_case = "abcdefghijklmnopqrstuvwxyz"
+upper_case = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+special_characters = "!@#$%^&*()-+"
+Input Format
+
+The first line contains an integer n denoting the length of the string.
+
+The second line contains a string consisting of n characters, the password typed by Louise. Each character is either a lowercase/uppercase English alphabet, a digit, or a special character.
+
+Constraints
+1 <= n <= 100
+
+Output Format
+
+Print a single line containing a single integer denoting the answer to the problem.
+
+Sample Input 0
+
+3
+Ab1
+Sample Output 0
+
+3
+Explanation 0
+
+She can make the password strong by adding  characters, for example, $hk, turning the password into Ab1$hk which is strong.
+
+2 characters aren't enough since the length must be at least 6.
+
+Sample Input 1
+
+11
+#HackerRank
+Sample Output 1
+
+1
+Explanation 1
+
+The password isn't strong, but she can make it strong by adding a single digit
diff --git a/String/Subsequences/question.txt b/String/Subsequences/question.txt
new file mode 100644
index 0000000..2bd6830
--- /dev/null
+++ b/String/Subsequences/question.txt
@@ -0,0 +1,6 @@
+Print all the subsequences of a string. A String is a subsequence of a given String,
+that is generated by deleting some character of a given string without changing 
+its order.
+Example:
+Input : abc
+Output : a, b, c, ab, bc, ac, abc
diff --git a/String/Subsequences/subsequences.cpp b/String/Subsequences/subsequences.cpp
new file mode 100644
index 0000000..9c0ec8c
--- /dev/null
+++ b/String/Subsequences/subsequences.cpp
@@ -0,0 +1,27 @@
+//find all the sub sequences of a string
+#include <iostream>
+using namespace std;
+char output[100] = "";
+
+void printSubSeq(char str[], int be, int idx)
+{
+    if (str[be] == '\0')
+    {
+        output[idx] = '\0';
+        cout << output << endl;
+        return;
+    }
+
+    printSubSeq(str, be + 1, idx);
+    output[idx] = str[be];
+    printSubSeq(str, be + 1, idx + 1);
+}
+
+
+int main() {
+    char str[100];
+    cin >> str;
+
+
+    printSubSeq(str, 0, 0);
+}
diff --git a/The Reversed World/Solution.cpp b/String/The Reversed World/Solution.cpp
similarity index 100%
rename from The Reversed World/Solution.cpp
rename to String/The Reversed World/Solution.cpp
diff --git a/The Reversed World/The Reversed World.txt b/String/The Reversed World/The Reversed World.txt
similarity index 100%
rename from The Reversed World/The Reversed World.txt
rename to String/The Reversed World/The Reversed World.txt
diff --git a/String/ToyObsession/problem.c b/String/ToyObsession/problem.c
new file mode 100644
index 0000000..d59efa2
--- /dev/null
+++ b/String/ToyObsession/problem.c
@@ -0,0 +1,7 @@
+We are to input a string of characters(say, s1= XxxyXxxXXxY) and a character(say, X) that belongs to that string
+( The string represents the collection of toys and the character represents the most beautiful toy)
+ we are to input a number that denotes the no. of beautiful toys needed ( smaller than equal to the maximum beautiful toys, say 2 )
+	now we are to print the smallet length (as in no. of characters) of the substring
+eg here 2 X containing substrigs are... XxxyX  XxxX XX 
+       					 5	4    2
+					 max         min therefor 2 printed. \(>o<)/
diff --git a/String/ToyObsession/solution.c b/String/ToyObsession/solution.c
new file mode 100644
index 0000000..0855193
--- /dev/null
+++ b/String/ToyObsession/solution.c
@@ -0,0 +1,40 @@
+#include<stdio.h>
+#include<string.h>
+int main() 
+{
+	long long int T,m;
+	scanf("%lld",&T);
+	for(m=0;m<T;m++)
+
+	{	char s1[100001],s2[100001],a;
+		long long int i=1,k,b,j=0,c,l,u,N,z=999999,arr[100001],brr[100001];
+		scanf("%s%s%lld",s1,s2,&N);
+		k = strlen(s1);
+		a = s2[0];
+		for(i=0;i<k;i++)
+		{if(s1[i]==a)
+			{
+				arr[j]=i;
+				j++;
+			}
+		}
+		i=0;
+		j--;
+		while(j-(N-1)>=0)
+		{ 
+			brr[i] = arr[j]-arr[j-(N-1)]+1;
+			i++;
+			j--;
+		}	
+
+		for(l=0;l<i;l++)
+		{
+			if(brr[l]<z)	
+			z = brr[l];
+		}
+		printf("%lld\n",z);
+	} 
+	return 0;
+}
+
+
diff --git a/String/Word_Frequency/question.txt b/String/Word_Frequency/question.txt
new file mode 100644
index 0000000..fd684eb
--- /dev/null
+++ b/String/Word_Frequency/question.txt
@@ -0,0 +1,7 @@
+Given a text, find the frequency of all the words in it and print the words that are duplicates:
+"Work hard and play hard and have fun at work."
+
+answer:
+hard
+work
+and
\ No newline at end of file
diff --git a/String/Word_Frequency/solution.js b/String/Word_Frequency/solution.js
new file mode 100644
index 0000000..41665f1
--- /dev/null
+++ b/String/Word_Frequency/solution.js
@@ -0,0 +1,22 @@
+function printDuplicates(inputText){
+  var frequenceCountMap = {};
+  var inputs = inputText.split(' ');
+  for(var ii = 0, len = inputs.length; ii < len; ii++){
+    var word = inputs[ii];
+    if(frequenceCountMap[word]){
+      frequenceCountMap[word] += 1;
+    }else{
+      frequenceCountMap[word] = 1;
+    }
+  }
+
+  for(var key in frequenceCountMap){
+    if(frequenceCountMap[key] > 1){
+      console.log(key);
+    }
+  }
+}
+
+var inputVal = "Work hard and play hard and have fun at work.";
+
+printDuplicates(inputVal);
\ No newline at end of file
diff --git a/String/ginortS/Question.txt b/String/ginortS/Question.txt
new file mode 100644
index 0000000..8c8b4c2
--- /dev/null
+++ b/String/ginortS/Question.txt
@@ -0,0 +1,16 @@
+You are given a string S
+ S contains alphanumeric characters only.
+
+ Your task is to sort the string S in the following manner:
+
+All sorted lowercase letters are ahead of uppercase letters.
+All sorted uppercase letters are ahead of digits.
+All sorted odd digits are ahead of sorted even digits.
+
+Sample Input
+
+Sorting1234
+
+Sample Output
+
+ginortS1234
\ No newline at end of file
diff --git a/String/ginortS/Solution.py b/String/ginortS/Solution.py
new file mode 100644
index 0000000..252193c
--- /dev/null
+++ b/String/ginortS/Solution.py
@@ -0,0 +1,21 @@
+s=input()
+upperCase=[]
+lowerCase=[]
+even=[]
+odd=[]
+for i in s:
+    if i >= 'A' and i<= 'Z':
+        upperCase.append(i)
+    elif i >='a' and i<= 'z':
+        lowerCase.append(i)
+    elif int(i)%2 == 0:
+        even.append(i)
+    elif int(i)%2 != 0:
+        odd.append(i)
+
+upperCase.sort()
+lowerCase.sort()
+even.sort()
+odd.sort()
+
+print("".join(lowerCase+upperCase+odd+even))
diff --git a/Tree/size-of-tree-C++/problem_statement.txt b/Tree/size-of-tree-C++/problem_statement.txt
new file mode 100644
index 0000000..16cfc27
--- /dev/null
+++ b/Tree/size-of-tree-C++/problem_statement.txt
@@ -0,0 +1 @@
+Program to find size of tree in c++
diff --git a/Tree/size-of-tree-C++/sizeoftree.cpp b/Tree/size-of-tree-C++/sizeoftree.cpp
new file mode 100644
index 0000000..89b5c0a
--- /dev/null
+++ b/Tree/size-of-tree-C++/sizeoftree.cpp
@@ -0,0 +1,37 @@
+class node  
+{  
+    public: 
+    int data;  
+    node* left;  
+    node* right;  
+};  
+  
+node* newNode(int data)  
+{  
+    node* Node = new node(); 
+    Node->data = data;  
+    Node->left = NULL;  
+    Node->right = NULL;  
+          
+    return(Node);  
+}  
+  
+int size(node* node)  
+{  
+    if (node == NULL)  
+        return 0;  
+    else
+        return(size(node->left) + 1 + size(node->right));  
+}  
+  
+int main()  
+{  
+    node *root = newNode(1);  
+    root->left = newNode(2);  
+    root->right = newNode(3);  
+    root->left->left = newNode(4);  
+    root->left->right = newNode(5);  
+      
+    cout << "Size of the tree is " << size(root);  
+    return 0;  
+}  
diff --git a/Unknown/Acronym/instructions.txt b/Unknown/Acronym/instructions.txt
new file mode 100644
index 0000000..f4f3cf7
--- /dev/null
+++ b/Unknown/Acronym/instructions.txt
@@ -0,0 +1,6 @@
+Acronym
+Convert a phrase to its acronym.
+
+Techies love their TLA (Three Letter Acronyms)!
+
+Help generate some jargon by writing a program that converts a long name like Portable Network Graphics to its acronym (PNG).
diff --git a/Unknown/Acronym/ruby_solution.rb b/Unknown/Acronym/ruby_solution.rb
new file mode 100644
index 0000000..346c592
--- /dev/null
+++ b/Unknown/Acronym/ruby_solution.rb
@@ -0,0 +1,13 @@
+def abbreviate(string)
+  string_arr = string.scan(/\b\w/)
+  string_arr.join.upcase
+end
+
+
+# begin
+# >> abbreviate("Portable Network Graphics")
+# => "PNG"
+# >> abbreviate("Ruby on Rails")
+# => "ROR"
+# >> abbreviate("GNU Image Manipulation Program")
+# => "GIMP"
diff --git a/CONTON/QUESTION.txt b/Unknown/CONTON/QUESTION.txt
similarity index 100%
rename from CONTON/QUESTION.txt
rename to Unknown/CONTON/QUESTION.txt
diff --git a/CONTON/solution.c b/Unknown/CONTON/solution.c
similarity index 100%
rename from CONTON/solution.c
rename to Unknown/CONTON/solution.c
diff --git a/Unknown/Chefdil/ans.cpp b/Unknown/Chefdil/ans.cpp
new file mode 100644
index 0000000..c8c9330
--- /dev/null
+++ b/Unknown/Chefdil/ans.cpp
@@ -0,0 +1,20 @@
+#include<bits/stdc++.h>
+using namespace std;
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        string a;
+        cin>>a;
+        int b=0;
+        for(int i=0;i<a.size();i++)
+            b+=a[i]-'0';
+        //cout<<b;
+        if(b%2)
+            cout<<"WIN"<<endl;
+        else
+            cout<<"LOSE"<<endl;
+    }
+}
diff --git a/Unknown/Chefdil/ques.txt b/Unknown/Chefdil/ques.txt
new file mode 100644
index 0000000..30a33a7
--- /dev/null
+++ b/Unknown/Chefdil/ques.txt
@@ -0,0 +1,32 @@
+Chef has no work to do in the kitchen, so he decided to play a card game with the following rules:
+
+Initially, N cards are placed in a row on a table. Each card is placed either face up or face down.
+The goal of the game is to remove all cards from the table, one by one.
+A card may be removed only if it is currently facing up.
+When a card is removed, its adjacent cards (the cards directly to its left and right, if they exist) are flipped, i.e. a card that was facing up will be facing down and vice versa.
+There is an empty space left behind each removed card, i.e. the remaining cards are not moved to create a contiguous row of cards again. Therefore, if the game starts with three cards and the middle card is removed, then the cards on the sides are flipped, but removing one of these cards afterwards does not cause the other card to be flipped, since it is only adjacent to the empty space created by removing the middle card.
+Determine whether Chef is able to win this game.
+
+Input
+The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
+The first line of each test case contains a single string S describing the row of cards initially placed on the table. Each character of this string is either '1', denoting a face up card, or '0', denoting a face down card.
+Output
+For each test case, print a single line containing the string "WIN" if Chef can win the game or "LOSE" if he cannot win (without quotes).
+
+Constraints
+1=T=102
+1=|S|=105
+Subtasks
+Subtask #1 (30 points):
+
+1=T=10
+1=|S|=100
+Subtask #2 (70 points): original constraints
+
+Example Input
+1
+10
+Example Output
+WIN
+Explanation
+Example case 1: First, Chef should remove the first card, which makes the second card face up. Then, he should remove the second card. This way, all cards are removed and Chef wins.
\ No newline at end of file
diff --git a/Unknown/Chocolate_SPOJ/question.txt b/Unknown/Chocolate_SPOJ/question.txt
new file mode 100644
index 0000000..8f45eef
--- /dev/null
+++ b/Unknown/Chocolate_SPOJ/question.txt
@@ -0,0 +1,41 @@
+We are given a bar of chocolate composed of m*n square pieces. One should break the chocolate into single squares. Parts of the chocolate may be broken along the vertical and horizontal lines as indicated by the broken lines in the picture.
+
+A single break of a part of the chocolate along a chosen vertical or horizontal line divides that part into two smaller ones. Each break of a part of the chocolate is charged a cost expressed by a positive integer. This cost does not depend on the size of the part that is being broken but only depends on the line the break goes along. Let us denote the costs of breaking along consecutive vertical lines with x1, x2, ..., xm-1 and along horizontal lines with y1, y2, ..., yn-1.
+
+The cost of breaking the whole bar into single squares is the sum of the successive breaks. One should compute the minimal cost of breaking the whole chocolate into single squares.
+
+
+For example, if we break the chocolate presented in the picture first along the horizontal lines, and next each obtained part along vertical lines then the cost of that breaking will be y1+y2+y3+4*(x1+x2+x3+x4+x5).
+
+Task
+Write a program that for each test case:
+
+Reads the numbers x1, x2, ..., xm-1 and y1, y2, ..., yn-1
+Computes the minimal cost of breaking the whole chocolate into single squares, writes the result.
+Input
+One integer in the first line, stating the number of test cases, followed by a blank line. There will be not more than 20 tests.
+
+For each test case, at the first line there are two positive integers m and n separated by a single space, 2 <= m,n <= 1000. In the successive m-1 lines there are numbers x1, x2, ..., xm-1, one per line, 1 <= xi <= 1000. In the successive n-1 lines there are numbers y1, y2, ..., yn-1, one per line, 1 <= yi <= 1000.
+
+The test cases will be separated by a single blank line.
+
+Output
+For each test case : write one integer - the minimal cost of breaking the whole chocolate into single squares.
+
+
+Example
+Input:
+1
+
+6 4
+2
+1
+3
+1
+4
+4
+1
+2
+
+Output:
+42
diff --git a/Unknown/Chocolate_SPOJ/solution.java b/Unknown/Chocolate_SPOJ/solution.java
new file mode 100644
index 0000000..f04b8c2
--- /dev/null
+++ b/Unknown/Chocolate_SPOJ/solution.java
@@ -0,0 +1,182 @@
+import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.io.BufferedWriter;
+import java.io.Writer;
+import java.io.OutputStreamWriter;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.io.InputStream;
+ 
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ *
+ * @author Rishabhdeep Singh
+ */
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        OutputWriter out = new OutputWriter(outputStream);
+        MultipleTestcases solver = new MultipleTestcases();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+ 
+    static class MultipleTestcases {
+        public void solve(int testNumber, InputReader in, OutputWriter out) {
+            int n = in.nextInt();
+            int m = in.nextInt();
+            --n;
+            --m;
+            int[] x = in.nextIntArray(n);
+            int[] y = in.nextIntArray(m);
+            int s1 = 0, s2 = 0;
+            for (int i = 0; i < n; i++) {
+                s1 += x[i];
+            }
+            for (int i = 0; i < m; i++) {
+                s2 += y[i];
+            }
+            Arrays.sort(x);
+            Arrays.sort(y);
+            int ans = s1 + s2;
+            for (int i = n - 1, j = m - 1; i >= 0 && j >= 0; ) {
+                if (y[j] >= x[i]) {
+                    ans += s1;
+                    s2 -= y[j];
+                    --j;
+                } else {
+                    ans += s2;
+                    s1 -= x[i];
+                    --i;
+                }
+            }
+            out.println(ans);
+        }
+ 
+    }
+ 
+    static class OutputWriter {
+        private final PrintWriter writer;
+ 
+        public OutputWriter(OutputStream outputStream) {
+            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+        }
+ 
+        public OutputWriter(Writer writer) {
+            this.writer = new PrintWriter(writer);
+        }
+ 
+        public void close() {
+            writer.close();
+        }
+ 
+        public void println(int i) {
+            writer.println(i);
+        }
+ 
+    }
+ 
+    static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private InputReader.SpaceCharFilter filter;
+ 
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+ 
+        public int read() {
+            if (numChars == -1) {
+                throw new InputMismatchException();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+ 
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+ 
+        public String nextString() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            StringBuilder res = new StringBuilder();
+            do {
+                if (Character.isValidCodePoint(c)) {
+                    res.appendCodePoint(c);
+                }
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+ 
+        public boolean isSpaceChar(int c) {
+            if (filter != null) {
+                return filter.isSpaceChar(c);
+            }
+            return isWhitespace(c);
+        }
+ 
+        public static boolean isWhitespace(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+ 
+        public String next() {
+            return nextString();
+        }
+ 
+        public int[] nextIntArray(int n) {
+            int[] array = new int[n];
+            for (int i = 0; i < n; ++i) array[i] = nextInt();
+            return array;
+        }
+ 
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+ 
+        }
+ 
+    }
+}
+ 
diff --git a/Fair Rations/Answer.cpp b/Unknown/Fair Rations/Answer.cpp
similarity index 100%
rename from Fair Rations/Answer.cpp
rename to Unknown/Fair Rations/Answer.cpp
diff --git a/Fair Rations/Problem Statement .txt b/Unknown/Fair Rations/Problem Statement .txt
similarity index 100%
rename from Fair Rations/Problem Statement .txt
rename to Unknown/Fair Rations/Problem Statement .txt
diff --git a/Unknown/Industrial Nim/Industrial_Nim.cpp b/Unknown/Industrial Nim/Industrial_Nim.cpp
new file mode 100644
index 0000000..680db05
--- /dev/null
+++ b/Unknown/Industrial Nim/Industrial_Nim.cpp	
@@ -0,0 +1,35 @@
+#include <bits/stdc++.h>
+using namespace std;
+ 
+vector<long long> vec;
+bool nim()	/* return true if the first player will win */
+{
+		long long x=0;
+		for(int i=0;i<vec.size();i++)		x=x^vec[i];
+		return x>0;
+}
+ 
+long long f(long long n)		/* n&3 equivalent to n%4 */
+{		
+    	long long x=n&3;
+ 	    if(x==0)	return n;	if(x==1)	return 1;
+		if(x==2)	return n+1;	if(x==3)	return 0;
+}
+ 
+  
+ 
+int main() 
+{ 
+    long long n,x,m;
+    cin>>n;
+    while(n--)
+    {
+        cin>>x>>m;
+        vec.push_back(f(x+m-1)^f(x-1));
+    }
+    if(nim())
+        cout<<"tolik"<<endl;
+    else
+        cout<<"bolik"<<endl;
+} 
+
diff --git a/Unknown/Industrial Nim/Industrial_Nim.txt b/Unknown/Industrial Nim/Industrial_Nim.txt
new file mode 100644
index 0000000..7bded13
--- /dev/null
+++ b/Unknown/Industrial Nim/Industrial_Nim.txt	
@@ -0,0 +1,29 @@
+Statement:
+There are n stone quarries in Petrograd.
+Each quarry owns mi dumpers (1 ≤ i ≤ n). It is known that the first dumper of the i-th quarry has xi stones in it, the second dumper has xi + 1 stones in it, the third has xi + 2, and the mi-th dumper (the last for the i-th quarry) has xi + mi - 1 stones in it.
+Two oligarchs play a well-known game Nim. Players take turns removing stones from dumpers. On each turn, a player can select any dumper and remove any non-zero amount of stones from it. The player who cannot take a stone loses.
+Your task is to find out which oligarch will win, provided that both of them play optimally. The oligarchs asked you not to reveal their names. So, let's call the one who takes the first stone «tolik» and the other one «bolik».
+
+Input:
+The first line of the input contains one integer number n (1 ≤ n ≤ 105) — the amount of quarries. Then there follow n lines, each of them contains two space-separated integers xi and mi (1 ≤ xi, mi ≤ 1016) — the amount of stones in the first dumper of the i-th quarry and the number of dumpers at the i-th quarry.
+
+Output:
+Output «tolik» if the oligarch who takes a stone first wins, and «bolik» otherwise.
+
+Example1
+input:
+2
+2 1
+3 2
+output:
+tolik
+
+Example2
+input:
+4
+1 1
+1 1
+1 1
+1 1
+output:
+bolik
diff --git a/Unknown/Necklace/solution.cpp b/Unknown/Necklace/solution.cpp
new file mode 100644
index 0000000..4f2bcc6
--- /dev/null
+++ b/Unknown/Necklace/solution.cpp
@@ -0,0 +1,227 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+void input(int *n, vector<int> *stones) {
+    cin >> *n;
+    vector<int> v(*n);
+    for (int i = 0; i < *n; ++i) {
+        cin >> v[i];
+        int temp = v[i];
+        int j = 0;
+        int f = 1;
+        for (int l = 2; l * l <= temp; ++l) {
+            if (temp % l == 0) {
+                if (j == l) {
+                    ++f;
+                    if (f == 2) {
+                        v[i] /= j * j;
+                        f = 0;
+                    }
+                } else {
+                    f = 1;
+                    j = l;
+                }
+                temp /= l;
+                --l;
+            }
+        }
+        if (temp == j) {
+            ++f;
+            if (f == 2) {
+                v[i] /= j * j;
+            }
+        }
+    }
+    sort(v.begin(), v.end());
+    stones->push_back(1);
+    for (int i = 1; i < *n; ++i) {
+        if (v[i] == v[i - 1]) {
+            ++stones->at(stones->size() - 1);
+        } else {
+            stones->push_back(1);
+        }
+    }
+}
+
+int necklace(size_t n, const std::vector<int> &stones, int mod) {
+    std::vector<long long> data_first(n);
+    std::vector<long long> data_second(n);
+    std::vector<std::vector<long long>> c(n + 2, std::vector<long long>(n + 2));
+    std::vector<long long> fact(n + 2);
+    c[0][0] = 1;
+    fact[0] = 1;
+    for (int i = 1; i <= n + 1; ++i) {
+        fact[i] = (fact[i - 1] * i) % mod;
+        c[i][0] = 1;
+        for (int j = 1; j <= n + 1; ++j) {
+            c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
+        }
+    }
+    int count = stones[0] - 1;
+    data_second[stones[0] - 1] = fact[stones[0]];
+    for (int stone = 1; stone < stones.size(); ++stone) {
+        if (stones[stone] != 0) {
+            std::vector<long long> temp_first = std::move(data_first);
+            std::vector<long long> temp_second = std::move(data_second);
+            data_first = std::vector<long long>(n);
+            data_second = std::vector<long long>(n);
+            for (int i = 0; i < n; ++i) {
+                if (temp_first[i] != 0) {
+                    for (int l = 1; l <= stones[stone]; ++l) {
+                        for (int j = 0; j <= std::min(i, l); ++j) {
+                            long long temp1 = 0;
+                            if (count >= i) {
+                                temp1 = (c[count - i][l - j] * c[i][j]) % mod;
+                                temp1 = (temp1 * c[stones[stone] - 1][l - 1]) % mod;
+                                temp1 = (temp1 * fact[stones[stone]]) % mod;
+                                temp1 = (temp1 * temp_first[i]) % mod;
+                            }
+                            long long temp2 = 0;
+                            if (count + 1 >= i) {
+                                temp2 =
+                                        (c[count - i + 1][l - j] * c[i][j]) % mod;
+                                temp2 = (temp2 * c[stones[stone] - 1][l - 1]) % mod;
+                                temp2 = (temp2 * fact[stones[stone]]) % mod;
+                                temp2 = (temp2 * temp_first[i]) % mod;
+                            }
+                            temp2 = (temp2 * 2) % mod;
+                            temp2 = (temp2 - temp1) % mod;
+                            if (temp2 < 0) {
+                                temp2 += mod;
+                            }
+                            data_first[i - j + stones[stone] - l] =
+                                    (data_first[i - j + stones[stone] - l] +
+                                     temp2) % mod;
+                            if (l - j >= 2) {
+                                temp1 =
+                                        (c[count - i][l - j - 2] * c[i][j]) % mod;
+                                temp1 = (temp1 * c[stones[stone] - 1][l - 1]) % mod;
+                                temp1 = (temp1 * fact[stones[stone]]) % mod;
+                                temp1 = (temp1 * temp_first[i]) % mod;
+                                data_second[i - j + stones[stone] - l] =
+                                        (data_second[i - j + stones[stone] - l] +
+                                         temp1) % mod;
+                            }
+                        }
+                    }
+                }
+                if (temp_second[i] != 0) {
+                    for (int l = 1; l <= stones[stone]; ++l) {
+                        for (int j = 0; j <= std::min(i, l); ++j) {
+                            long long temp1 = 0;
+                            if (count >= i) {
+                                temp1 = (c[count - i][l - j] * c[i][j]) % mod;
+                                temp1 = (temp1 * c[stones[stone] - 1][l - 1]) % mod;
+                                temp1 = (temp1 * fact[stones[stone]]) % mod;
+                                temp1 = (temp1 * temp_second[i]) % mod;
+                                data_second[i - j + stones[stone] - l] =
+                                        (data_second[i - j + stones[stone] - l] +
+                                         temp1) % mod;
+                            }
+                            long long temp2 = 0;
+                            if (count + 1 >= i) {
+                                temp2 =
+                                        (c[count - i + 1][l - j] * c[i][j]) % mod;
+                                temp2 = (temp2 * c[stones[stone] - 1][l - 1]) % mod;
+                                temp2 = (temp2 * fact[stones[stone]]) % mod;
+                                temp2 = (temp2 * temp_second[i]) % mod;
+                            }
+                            temp2 = (temp2 * 2) % mod;
+                            temp1 = (temp1 * 2) % mod;
+                            temp2 = (temp2 - temp1) % mod;
+                            if (temp2 < 0) {
+                                temp2 += mod;
+                            }
+                            data_first[i - j + stones[stone] - l] =
+                                    (data_first[i - j + stones[stone] - l] +
+                                     temp2) % mod;
+                            if (l - j >= 2) {
+                                temp1 =
+                                        (c[count - i][l - j - 2] * c[i][j]) % mod;
+                                temp1 = (temp1 * c[stones[stone] - 1][l - 1]) % mod;
+                                temp1 = (temp1 * fact[stones[stone]]) % mod;
+                                temp1 = (temp1 * temp_second[i]) % mod;
+                                data_second[i - j + stones[stone] - l] =
+                                        (data_second[i - j + stones[stone] - l] +
+                                         temp1) % mod;
+                            }
+                        }
+                    }
+                }
+            }
+            count += stones[stone];
+        }
+    }
+    return (int) ((data_first[0] + data_second[0]) % mod);
+}
+
+int rek(std::vector<int> *v, int last, int first) {
+    int res = 0;
+    int k = 0;
+    for (int &a : *v) {
+        if (a != -1) {
+            ++k;
+            if (a != last) {
+                int temp = a;
+                a = -1;
+                if (first == -1) {
+                    res += rek(v, temp, temp);
+                } else {
+                    res += rek(v, temp, first);
+                }
+                a = temp;
+            }
+        }
+    }
+    if (k == 0) {
+        if (first != last) {
+            return 1;
+        }
+        return 0;
+    }
+    return res;
+}
+
+bool test() {
+    int n = rand() % 10 + 1;
+    int k = rand() % 10 + 1;
+    std::vector<int> stones(k);
+    std::vector<int> v(n);
+    for (int i = 0; i < n; ++i) {
+        v[i] = rand() % k;
+        ++stones[v[i]];
+    }
+    std::sort(stones.rbegin(), stones.rend());
+    if (rek(&v, -1, -1) != necklace(n, stones, 1000000007)) {
+        std::cout << n << " " << k << std::endl;
+        for (int i = 0; i < n; ++i) {
+            std::cout << v[i] << " ";
+        }
+        std::cout << std::endl;
+        std::cout << rek(&v, -1, -1) << " ";
+        std::cout << necklace(n, stones, 1000000007) << std::endl;
+        return false;
+    }
+    return true;
+}
+
+void tests() {
+    srand(16);
+    int c = 0;
+    int count = 1000;
+    while (c++ < count && test());
+}
+
+int main() {
+    int n;
+    std::vector<int> stones;
+    input(&n, &stones);
+    std::cout << necklace((size_t) n, stones, 1000000007) << std::endl;
+    fclose(stdin);
+    fclose(stdout);
+//    tests();
+    return 0;
+}
diff --git a/Unknown/Necklace/statement.pdf b/Unknown/Necklace/statement.pdf
new file mode 100644
index 0000000..5a9f14e
Binary files /dev/null and b/Unknown/Necklace/statement.pdf differ
diff --git a/PINS/problem.txt b/Unknown/PINS/problem.txt
similarity index 100%
rename from PINS/problem.txt
rename to Unknown/PINS/problem.txt
diff --git a/PINS/solution.cpp b/Unknown/PINS/solution.cpp
similarity index 100%
rename from PINS/solution.cpp
rename to Unknown/PINS/solution.cpp
diff --git a/Unknown/PolyMul/question.txt b/Unknown/PolyMul/question.txt
new file mode 100644
index 0000000..2d08f19
--- /dev/null
+++ b/Unknown/PolyMul/question.txt
@@ -0,0 +1,31 @@
+Sam and Dean fight the supernatural creatures to protect the humans. Now they have come across a creature called the Vedala, which are always found in pairs. Each vedala can be represented by a polynomial. Both the Vedalas need to be killed at once or else they can't be killed. They can be killed only by using the product of the two polynomials representing the two Vedala. Help Sam and Dean find the product of the polynomials fast, so they can do thier work. 
+
+Input
+
+First line contains an integer T (≤ 10), number of test cases.
+Each test case will have n (n ≤ 10000), maximum degree of the polynomials on the first line. 
+
+Next two lines will have n+1 space separated integers each representing the coeffiecients of first and second polynomials respectively.
+
+All input coefficients values are <=1000.
+
+Output
+For each test case ouput a line of 2n space seperated integers indicating coefficients of the polynomial created after multiplication.
+
+
+Example 
+Input:
+2
+2
+1 2 3
+3 2 1
+2
+1 0 1
+2 1 0
+
+Output:
+3 8 14 8 3
+2 1 2 1 0
+
+
+
diff --git a/Unknown/PolyMul/solution.cpp b/Unknown/PolyMul/solution.cpp
new file mode 100644
index 0000000..f439663
--- /dev/null
+++ b/Unknown/PolyMul/solution.cpp
@@ -0,0 +1,86 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+
+typedef long long int LL;
+typedef vector<LL> VLL;
+typedef std::complex<double> CD;
+
+#define PB              push_back
+#define F               first
+#define s               second
+#define SZ(x)           x.size()
+#define ALL(a)          std::begin(a), std::end(a)
+#define IN_REP          int _t; cin >> _t ; while(_t--)
+#define IOS             ios::sync_with_stdio(false);cin.tie(NULL)
+#define FOR(i, a, b)    for(int i=(a);i<(b);i++)
+#define REP(i, n)       FOR(i,0,n)
+const double PI     =   acos(-1);
+typedef std::valarray<CD> CArray;
+
+// Cooley–Tukey FFT (in-place)
+void fft(CArray &x) {
+    // const size_t N = x.size();
+    int N = SZ(x);
+    if (N <= 1) return;
+
+    // divide
+    CArray even = x[std::slice(0, N / 2, 2)];
+    CArray odd = x[std::slice(1, N / 2, 2)];
+
+    // conquer
+    fft(even);
+    fft(odd);
+
+    // combine
+    // for (size_t k = 0; k < N/2; ++k){
+    for (int k = 0; k < N / 2; ++k) {
+        CD t = std::polar(1.0, -2 * PI * k / N) * odd[k];
+        x[k] = even[k] + t;
+        x[k + N / 2] = even[k] - t;
+    }
+}
+
+// inverse fft (in-place)
+void ifft(CArray &x) {
+    // conjugate the complex numbers
+    x = x.apply(std::conj);
+
+    // forward fft
+    fft(x);
+
+    // conjugate the complex numbers again
+    x = x.apply(std::conj);
+
+    // scale the numbers
+    x /= x.size();
+}
+
+int main() {
+    IOS;
+    IN_REP {
+        int n;
+        cin >> n;
+        n++; // Given in question
+        int size = 2 * (1 << int(ceil(log2(n))));
+
+        CArray x(size), y(size);
+        FOR(i, size - n, size) cin >> x[i];
+        fft(x);
+        FOR(i, size - n, size) cin >> y[i];
+        fft(y);
+
+        CArray res(size);
+        res = x * y;
+        ifft(res);
+        VLL ans;
+        REP(i, size - 1) {
+            ans.PB(round(res[i].real()));
+        }
+        for (int i = size - 1 - (2 * n - 1); i < size - 1; i++) {
+            cout << ans[i] << " ";
+        }
+        cout << endl;
+    }
+    return 0;
+}
diff --git a/Unknown/Strange_Food_Chain/question.txt b/Unknown/Strange_Food_Chain/question.txt
new file mode 100644
index 0000000..ae9b410
--- /dev/null
+++ b/Unknown/Strange_Food_Chain/question.txt
@@ -0,0 +1,37 @@
+There are 3 kinds of animals A,B and C. A can eat B,B can eat C,C can eat A. It's interesting,isn't it?
+
+Now we have n animals,numbered from 1 to n. Each of them is one of the 3 kinds of animals:A,B,C.
+
+Today Mary tells us k pieces of information about these n animals. Each piece has one of the two forms below:
+
+1 x y: It tells us the kind of x and y are the same.
+2 x y: It tells us x can eat y.
+Some of these k pieces are true,some are false. The piece is false if it satisfies one of the 3 conditions below, otherwise it's true.
+
+X or Y in this piece is larger than n.
+This piece tells us X can eat X.
+This piece conflicts to some true piece before.
+Input
+The first line contains a single integer t.t blocks follow.
+
+To every block,the first line contains two integers n(1<=n<=50000) and k (1<=k<=100000). k lines follow,each contains 3 positive integers D(1<=D<=2),X,Y,separated by single spaces.
+
+
+Output
+t lines,each contains a single integer - the number of false pieces in the corresponding block.
+
+
+Example
+Sample input:
+1
+100 7
+1 101 1
+2 1 2
+2 2 3
+2 3 3
+1 1 3
+2 3 1
+1 5 5
+
+Sample output:
+3
diff --git a/Unknown/Strange_Food_Chain/solution.cpp b/Unknown/Strange_Food_Chain/solution.cpp
new file mode 100644
index 0000000..ba8dc5b
--- /dev/null
+++ b/Unknown/Strange_Food_Chain/solution.cpp
@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <algorithm>
+ 
+using namespace std;
+ 
+const int N = 5e4 + 10;
+ 
+int n, k;
+int par[N], lab[N];
+ 
+int anc(int u) {
+    if (u == par[u]) return u;
+    int tmp = par[u];
+    par[u] = anc(par[u]);
+    lab[u] = lab[tmp] + lab[u];
+    return par[u];
+}
+ 
+int main() {
+ //   freopen("input.in", "r", stdin);
+//    freopen("output.out", "w", stdout);
+ 
+    int test; scanf("%d", &test);
+    while (test--) {
+        scanf("%d%d", &n, &k);
+        for (int i = 1; i <= n; ++i) {
+            par[i] = i;
+            lab[i] = 0;
+        }
+        int answer = 0;
+        while (k--) {
+            int t, x, y; scanf("%d%d%d", &t, &x, &y);
+            if (x > n || y > n) { answer++; continue; }
+            int px = anc(x), py = anc(y);
+            t--;
+            if (px == py) {
+                int tmp = (lab[x] - lab[y]) % 3; if (tmp < 0) tmp += 3;
+                if (tmp != t) answer++;
+            } else {
+                par[px] = py;
+                int i = (lab[x] - lab[y] - t) % 3;
+                lab[px] = i < 0 ? -i : -i + 3;
+            }
+        }
+        printf("%d\n", answer);
+    }
+ 
+    return 0;
+}
+  
+
diff --git a/Unknown/WATCHFB/Main.class b/Unknown/WATCHFB/Main.class
new file mode 100644
index 0000000..539b6a7
Binary files /dev/null and b/Unknown/WATCHFB/Main.class differ
diff --git a/Unknown/WATCHFB/Main.ctxt b/Unknown/WATCHFB/Main.ctxt
new file mode 100644
index 0000000..b2ed59f
--- /dev/null
+++ b/Unknown/WATCHFB/Main.ctxt
@@ -0,0 +1,19 @@
+#BlueJ class context
+comment0.target=Main
+comment1.params=stream
+comment1.target=LCSin(java.io.InputStream)
+comment2.params=
+comment2.target=int\ read()
+comment3.params=
+comment3.target=int\ readInt()
+comment4.params=c
+comment4.target=boolean\ isSpaceChar(int)
+comment5.params=
+comment5.target=java.lang.String\ readString()
+comment6.params=
+comment6.target=byte\ readByte()
+comment7.params=
+comment7.target=long\ readLong()
+comment8.params=args
+comment8.target=void\ main(java.lang.String[])
+numComments=9
diff --git a/Unknown/WATCHFB/Main.java b/Unknown/WATCHFB/Main.java
new file mode 100644
index 0000000..430dbef
--- /dev/null
+++ b/Unknown/WATCHFB/Main.java
@@ -0,0 +1,195 @@
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.InputMismatchException;
+import java.util.Arrays;
+class LCSin
+{
+    private InputStream stream;
+    private byte[] buf = new byte[1024];
+    private int curChar;
+    private int numChars;
+    private SpaceCharFilter filter;
+    public LCSin(InputStream stream) {
+        this.stream = stream;
+    }
+    public interface SpaceCharFilter {
+        public boolean isSpaceChar(int ch);
+    }
+    public int read() {
+        if (numChars == -1)
+            throw new InputMismatchException();
+        if (curChar >= numChars) {
+            curChar = 0;
+        try {
+            numChars = stream.read(buf);
+        } catch (IOException e) {
+            throw new InputMismatchException();
+        }
+        if (numChars <= 0)
+            return -1;
+        }
+        return buf[curChar++];
+    }
+    public int readInt() {
+        int c = read();
+        while (isSpaceChar(c))
+            c = read();
+        int sgn = 1;
+        if (c == '-') {
+            sgn = -1;
+            c = read();
+        }
+        int res = 0;
+        do {
+            if (c < '0' || c > '9')
+                throw new InputMismatchException();
+            res *= 10;
+            res += c - '0';
+            c = read();
+        } while (!isSpaceChar(c));
+        return res * sgn;
+    }
+    public boolean isSpaceChar(int c) {
+        if (filter != null)
+            return filter.isSpaceChar(c);
+        return c==' '||c=='\n'|| c == '\r' || c == '\t' || c == -1;
+    }
+    public String readString() {
+        int c = read();
+        while (isSpaceChar(c))
+            c = read();
+        StringBuilder res = new StringBuilder();
+        do {
+            res.appendCodePoint(c);
+            c = read();
+        } 
+        while (!isSpaceChar(c));
+        return res.toString();
+    }
+    public byte readByte() {
+        int c = read();
+        while (isSpaceChar(c))
+            c = read();
+        byte res = 0;
+        do {
+            if (c < '0' || c > '9')
+                throw new InputMismatchException();
+            res *= 10;
+            res += c - '0';
+            c = read();
+        } while (!isSpaceChar(c));
+        return res;
+    }
+    public long readLong() {
+        int c = read();
+        while (isSpaceChar(c))
+            c = read();
+        int sgn = 1;
+        if (c == '-')
+        {
+            sgn = -1;
+            c = read();
+        }
+        long res = 0;
+        do
+        {
+            if (c < '0' || c > '9')
+                throw new InputMismatchException();
+            res *= 10;
+            res += c - '0';
+            c = read();
+        }
+        while (!isSpaceChar(c));
+        return res * sgn;
+    }
+}
+
+public class Main
+{
+    public static void main(String args[])
+    {
+        LCSin br= new LCSin(System.in);
+        int test= br.readInt();
+        StringBuilder sb=new StringBuilder();
+        for(int testcase= 0; testcase<test;testcase++)
+        {
+            long x=0;
+            long y=0;
+            long prevmax=0;
+            long prevmin=0;
+            boolean res= false;
+            
+            int n= br.readInt();
+            for(int i=0;i<n;i++)
+            {
+                int alpha= br.readInt();
+                long a= br.readInt();
+                long b= br.readInt();
+                long max= (long)Math.max(a,b);
+                long min= (long)Math.min(a,b);
+                
+                if(a==b)
+                {
+                    System.out.println("YES");
+                    res= true;
+                    prevmax= a;
+                    prevmin= a;
+                    continue;
+                }
+                
+                if(alpha==1)
+                {
+                    System.out.println("YES");
+                    prevmax= max;
+                    prevmin= min;
+                    res= true;
+                    continue;
+                }
+                
+                if(min>prevmax)
+                {
+                    System.out.println("NO");
+                    prevmax= max;
+                    prevmin= min;
+                    res= false;
+                    continue;
+                }
+                
+                if((max>prevmax)&&(min<prevmax))
+                {
+                    if(res==false)
+                    {System.out.println("NO");}
+                    else
+                    {System.out.println("YES");}
+                    prevmax= max;
+                    prevmin= min;
+                    continue;
+                
+                }
+                
+                if((max==prevmax)&&(min<prevmax))
+                {
+                 if(res==false)
+                    {System.out.println("NO");}
+                    else
+                    {System.out.println("YES");}
+                    prevmax= max;
+                    prevmin= min;
+                    continue;
+                
+                }
+                
+                if((max>prevmax)&&(min==prevmax))
+                {
+                
+                System.out.println("NO");
+                res= false;
+                prevmax= max;
+                prevmin= min;
+                continue;
+                
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Unknown/WATCHFB/WATCHFB.txt b/Unknown/WATCHFB/WATCHFB.txt
new file mode 100644
index 0000000..68b7e03
--- /dev/null
+++ b/Unknown/WATCHFB/WATCHFB.txt
@@ -0,0 +1,58 @@
+The solution given is created by the author and using it without prior written permission from the author can lead to legal actions.
+Please contact amcs1729@gmail.com for any queries
+
+
+
+https://www.codechef.com/problems/WATCHFB
+
+Chef and his son Chefu want to watch a match of their favourite football team playing against another team, which will take place today.
+
+Unfortunately, Chef is busy in the kitchen preparing lunch, so he cannot watch the match. Therefore, every now and then, Chef asks Chefu about the current scores of the teams and Chefu tells him the score. However, Chefu sometimes does not specify the teams along with the score — for example, he could say "the score is 3 to 6", and there is no way to know just from this statement if it was their favourite team or the other team that scored 6 goals; in different statements, the order of teams may also be different. Other times, Chefu specifies which team scored how many goals.
+
+Chef asks for the score and receives a reply N times. There are two types of replies:
+
+1 A B: their favourite team scored A goals and the other team scored B goals
+2 A B: one team scored A goals and the other scored B goals
+Chef is asking you to help him determine the score of his favourite team after each of Chefu's replies. After each reply, based on the current reply and all previous information (but without any following replies), tell him whether it is possible to certainly determine the number of goals scored by his favourite team.
+
+Input
+The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
+The first line of each test case contains a single integer N.
+The following N lines describe Chefu's replies in the format described above.
+Output
+For each of Chefu's replies, print a single line containing the string "YES" if it is possible to determine the score of Chef's favourite team after this reply or "NO" if it is impossible.
+
+Constraints
+1=T=100
+1=N=104
+0=A,B=109
+the sum of N over all test cases does not exceed 105
+there is at least one valid sequence of scored goals consistent with all replies
+Subtasks
+Subtask #1 (100 points): original constraints
+
+Example Input
+1
+6
+2 0 1
+1 3 1
+2 2 4
+2 5 6
+2 8 8
+2 9 10
+Example Output
+NO
+YES
+YES
+NO
+YES
+NO
+Explanation
+Example case 1:
+
+Reply 1: Chef cannot know who scored the first goal.
+Reply 2: Chefu told Chef that their favourite team has scored 3 goals so far.
+Reply 3: Chef can conclude that his favourite team has scored 4 goals, since it already scored 3 goals earlier.
+Reply 4: the favourite team could have scored 5 or 6 goals, but there is no way to know which option is correct.
+Reply 5: since there is a tie, Chef knows that his favourite team has scored 8 goals.
+Reply 6: again, Chef cannot know if his favourite team has scored 9 or 10 goals.
diff --git a/Unknown/chusky_adventurer/problem_statement.txt b/Unknown/chusky_adventurer/problem_statement.txt
new file mode 100644
index 0000000..cb4840f
--- /dev/null
+++ b/Unknown/chusky_adventurer/problem_statement.txt
@@ -0,0 +1,35 @@
+Chusky the Adventurer
+========================
+
+Chusky Jones is a famous adventurer who is looking for the treasures of the Yuraq, an ancient nation that developed in the South American Andes. The Yuraq were famous for protecting their treasures in very complex systems that sought to confuse intruders, this society far ahead of its time dominated mathematics at a high level so that the protection of its treasures was commonly related to combinatorial counting problems, Modular arithmetic and other subjects that his priests considered obscure.
+Analyzing ancient texts Chusky determined that the Yuraq used to have multiple paths for their treasures but that many of them were full of deadly traps, because Chusky plans to use robots to search for the treasures for him. The Yuraq maps are represented by an integer  n  that indicates that you must go up  n  times and go down another  n  to reach the treasures, note that at no time is it possible to go down more times than has been uploaded.
+
+For example, if the map is represented by n = 3 , there are 5 different possible mountain roads that can be followed to find the treasure
+
+Chusky will use a robot for every possible existing path, help him determine the total number he will need.
+
+Input
+======
+The entry will begin with an integer  t (1 <= t <= 1000000) on a line indicating the number of maps that Chusky has. Then follow  t lines, each describing the map for the integer  n (1 <= n <= 1000000).
+
+Output
+======
+
+Para cada mapa escribe una línea con el número total de robots que Chusky necesitará. Como este número puedes ser muy grande indique la respuesta módulo 1000000007.
+
+Example
+=======
+
+Input
+
+3
+1
+3
+19
+
+Ouput
+
+1
+5
+767263183
+
diff --git a/Unknown/chusky_adventurer/solution.cpp b/Unknown/chusky_adventurer/solution.cpp
new file mode 100644
index 0000000..c9904ca
--- /dev/null
+++ b/Unknown/chusky_adventurer/solution.cpp
@@ -0,0 +1,54 @@
+#include <bits/stdc++.h>
+using namespace std;
+typedef long long int i64;
+
+const i64 MOD = 1000000007;
+const int limit = 1000001;
+
+int cat[limit];
+
+i64 num(i64 x){
+    return (((2ll*x)%MOD + 2ll)*((2ll*x)%MOD + 1ll))%MOD;
+}
+
+i64 den(i64 x){
+    return ((x + 2ll)*(x + 1ll))%MOD;
+}
+
+i64 fast_pow(i64 x, i64 pow){
+    if (pow == 0) return 1;
+    if (pow == 1) return x;
+    if (pow % 2ll == 0ll){
+        i64 prod = fast_pow(x, pow / 2ll);
+        return (prod * prod) % MOD;
+    } 
+    else{
+        i64 prod = fast_pow(x, pow / 2ll);
+        return (((prod * prod) % MOD) * x) % MOD;
+    }
+}
+
+i64 inverse(i64 x){
+    //because MOD is prime, we can use Fermat's little theorem
+    return fast_pow(x, MOD - 2);
+}
+
+void precompute(){
+    cat[0] = 1;
+    for(int i = 1; i < limit; i++){
+        i64 ans = (1ll*cat[i-1] * num(i)) % MOD;
+        ans = (ans * inverse(den(i))) % MOD;
+        cat[i] = (int)(ans);
+    }
+}
+int main(){
+    precompute();
+    int test;
+    scanf("%d", &test);
+    while(test--){
+        int x;
+        scanf("%d", &x);
+        printf("%d\n", cat[x - 1]);
+    }
+}
+
diff --git a/Unknown/chusky_hunger/problem_statement.txt b/Unknown/chusky_hunger/problem_statement.txt
new file mode 100644
index 0000000..5625b7b
--- /dev/null
+++ b/Unknown/chusky_hunger/problem_statement.txt
@@ -0,0 +1,41 @@
+Chusky and Hunger
+=========================
+
+Chusky lives in Dogland and as everyone in this city, he loves the local dish: Aguadito. There is a unique Polleria (a really nice place to eat Aguadito) in Dogland, hence, this eatery is really selective with its customers. To eat in the Polleria, Chusky must solve the next task: Given D boxes, each one has all integer numbers between L_i and R_i (1 <= i <= D) inclusive, indicate the K-th lowest unique existing element. Because there is big queue waiting after Chusky, he has just some seconds to give the correct answer, otherwise he will not be able to eat in the Polleria and will eat some boiled potatoes that has at home (he does not like it too much) .
+Help Chusky to eat an Aguadito.
+
+Input
+=====
+
+The first line of the input contains a number T (1 <= T <= 100) indicating the number of test cases. Each test case follows the next format:
+The first line of each test case contains a number D (1 <= D <= 100) representing the number of boxes Chusky receives, the second line contains a number K (1 <= K <= 10 ^ 15) representing the K- th number Chusky must guess, then D lines follows, each one in has two integers L_i and R_i (1 <= L_i <= R_i <= 10 ^ 15) representing that box i has all integers between L_i and R_i (1 <= i <= D) inclusive.
+
+Output
+=====
+
+For each test case, print the K-th lowest number between all boxes. Print -1 if no K-th lowest number exists.
+
+Example
+======
+
+Input
+
+2
+3
+2
+3 6
+3 4
+11 13
+1
+7
+1 5
+
+Output
+
+4
+-1
+
+Explanation:
+
+For the first test case, the first box has numbers {3, 4, 5, 6}, the second one has {3, 4} and the last one has {11, 13}, then all existing numbers are {3, 4 , 5, 6, 11, 13} and the 2nd lowest number is 4. In the second case the box has numbers {1, 2, 3, 4, 5}, thus there is no 7th lowest element.
+
diff --git a/Unknown/chusky_hunger/solution.cpp b/Unknown/chusky_hunger/solution.cpp
new file mode 100644
index 0000000..4a65e79
--- /dev/null
+++ b/Unknown/chusky_hunger/solution.cpp
@@ -0,0 +1,75 @@
+#include <bits/stdc++.h>
+//#define DEBUG
+using namespace std;
+typedef vector < int > vi; 
+typedef pair < long long int, long long int > pii;
+typedef vector < pii > vii;
+typedef long long int i64;
+int d;
+i64 k;
+bool byPairs(pii left, pii right)
+{
+    if(left.first != right.first)
+        return left.first < right.first;
+    return left.second < right.second;
+}
+i64 sol(vii &nums)
+{
+    sort(nums.begin(), nums.end(), byPairs);
+    
+    i64 ans = -1ll;
+    i64 last = -1ll;
+    int i = 0;
+    while(k>0ll && i < (int)nums.size())
+    {
+        if(last < nums[i].first) // no overlap
+        {
+            i64 len = nums[i].second - nums[i].first + 1ll;
+#ifdef DEBUG
+
+            cout<<nums[i].first<<" --- "<<nums[i].second<<" : "<<len<< "  > " <<k<<endl;
+#endif                  
+
+            if(len < k)
+                k-=len, last = nums[i].second, i++;
+            else
+            {
+                ans = nums[i].first + k - 1ll, k = 0ll; 
+
+            }
+        }
+        else // overlap
+        {
+            if(nums[i].second <=  last) i++;
+            else nums[i].first = last + 1;
+        }
+    }
+    return ans;
+}
+int main()
+{
+#ifdef DEBUG
+  clock_t begin = clock();
+#endif   
+  int test_cases;
+  scanf("%d", &test_cases);
+  while(test_cases--)
+  {
+    cin>>d>>k;
+    vii nums = vii();
+    for(int i = 0; i < d; i++)
+    {
+      pii x;
+      cin>>x.first>>x.second;
+      nums.push_back(x);
+    }
+    cout<< sol(nums) <<endl;
+  }
+#ifdef DEBUG
+  clock_t end = clock();
+  double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
+  printf("%.10f\n", elapsed_secs);
+#endif   
+}
+
+
diff --git a/Unknown/chusky_nightgame/problem_statement.txt b/Unknown/chusky_nightgame/problem_statement.txt
new file mode 100644
index 0000000..a3d3e3d
--- /dev/null
+++ b/Unknown/chusky_nightgame/problem_statement.txt
@@ -0,0 +1,35 @@
+Chusky and the Night Game
+=========================
+Every Friday night Chusky and his friends meet to play billiards at his house. At the beginning of the game a pyramid is formed with the balls: 1 ball in the first level, 2 in the second level, 3 in the third level and so on. Then, a set of balls is assigned for each player and he/she must put only those that were assigned, the one who manages to put them all first, wins.
+
+Chusky is a good host and wants his friends to have fun playing, he knows that the game would be very boring if the number of balls is less than 10 and it would be unfair if any of the players have more or less balls to poke. Since Chusky has $ n $ friends, help him determine the minimum number of balls he will need to make the game fun and fair.
+
+Input
+=====
+
+The entry will begin with an integer t (1 <= t <= 1000) on a line indicating the number of weekends Chusky's friends get together to play. Then there are  t  lines, one for each weekend, which indicate the number  n (2 <= n <= 1000)  of friends for each weekend. Remember that only the n friends of Chusky play.
+
+Output
+=====
+
+For each weekend write a line with the minimum number of balls needed to make the game fair and fun
+
+
+Example
+======
+
+Input
+
+3
+3
+2
+4
+
+Output
+
+15
+10
+28
+
+Explanation:
+For the first night, each player would have 5 balls, for the second 5 balls, and for the third 7 balls.
diff --git a/Unknown/chusky_nightgame/solution.cpp b/Unknown/chusky_nightgame/solution.cpp
new file mode 100644
index 0000000..f123c59
--- /dev/null
+++ b/Unknown/chusky_nightgame/solution.cpp
@@ -0,0 +1,29 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+const int MAX =  1005;
+int sol[MAX];
+
+int f(int x){
+    return (x* (x + 1))/2;
+}
+void precompute(){
+    for(int people  = 2; people < MAX; people++){
+        int lim_level = max(2*people, 5);
+        for (int level = 4; level < lim_level; level++)
+            if(f(level) % people == 0){
+                sol[people] = f(level);
+                break;
+            }
+    }
+}
+int main(){
+    precompute();
+    int cases, n;
+    scanf("%d", &cases);
+    while(cases--){
+        scanf("%d", &n);
+        printf("%d\n", sol[n]);
+    }
+}
+
diff --git a/coin-piles/problem_statement.txt b/Unknown/coin-piles/problem_statement.txt
similarity index 100%
rename from coin-piles/problem_statement.txt
rename to Unknown/coin-piles/problem_statement.txt
diff --git a/coin-piles/solution.cpp b/Unknown/coin-piles/solution.cpp
similarity index 100%
rename from coin-piles/solution.cpp
rename to Unknown/coin-piles/solution.cpp