diff --git a/1472DesignBrowserHistory.java b/1472DesignBrowserHistory.java
new file mode 100644
index 00000000..c9990697
--- /dev/null
+++ b/1472DesignBrowserHistory.java
@@ -0,0 +1,34 @@
+class BrowserHistory {
+    List<String> arr=new ArrayList<>();
+    int i=0;
+        public BrowserHistory(String homepage) {
+         arr.add(homepage);  
+         i=0; 
+        }
+        public void visit(String url) {
+         while(arr.size()>i+1){
+            arr.remove(arr.size()-1);
+         }
+         arr.add(url); 
+         i++;
+        }
+        public String back(int steps) {
+            i=Math.max(i-steps,0);
+            return arr.get(i);
+        }
+        public String forward(int steps) {
+            i=i+steps;
+            if(i>=arr.size()){
+                i=arr.size()-1;
+            }
+            return arr.get(i);
+        }
+    }
+    
+    /**
+     * Your BrowserHistory object will be instantiated and called as such:
+     * BrowserHistory obj = new BrowserHistory(homepage);
+     * obj.visit(url);
+     * String param_2 = obj.back(steps);
+     * String param_3 = obj.forward(steps);
+     */
\ No newline at end of file
diff --git a/2696MinimumStringLengthAfterRemovingSubstrings.java b/2696MinimumStringLengthAfterRemovingSubstrings.java
new file mode 100644
index 00000000..456e63df
--- /dev/null
+++ b/2696MinimumStringLengthAfterRemovingSubstrings.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int minLength(String s) {
+        Stack<Character> st=new Stack<>();
+        for(char c:s.toCharArray()){
+            if(!st.isEmpty()){
+                if(st.peek()=='A' && c=='B') st.pop();
+                else if(st.peek()=='C' && c=='D') st.pop();
+                else st.push(c);
+            }
+            else st.push(c);
+        }
+        return st.size();
+    }
+}
\ No newline at end of file
diff --git a/682BaseballGame.java b/682BaseballGame.java
new file mode 100644
index 00000000..67655c3a
--- /dev/null
+++ b/682BaseballGame.java
@@ -0,0 +1,22 @@
+class Solution {
+    public int calPoints(String[] operations) {
+        Stack<Integer> stack=new Stack<>();
+        for(String st:operations){
+            if(st.equals("C")) stack.pop();
+            else if(st.equals("D")) stack.push(stack.peek()*2);
+            else if(st.equals("+")){
+                int a=stack.pop();
+                int b=stack.pop();
+                stack.push(b);
+                stack.push(a);
+                stack.push(a+b);
+            }
+            else stack.push(Integer.parseInt(st));
+        }
+        int ans=0;
+        while(!stack.isEmpty()){
+            ans+=stack.pop();
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/CoinChange.java b/CoinChange.java
new file mode 100644
index 00000000..1af1897b
--- /dev/null
+++ b/CoinChange.java
@@ -0,0 +1,17 @@
+import java.util.Arrays;
+
+public class CoinChange {
+        public int coinChange(int[] coins, int amount) {
+        int[] dp=new int[amount+1];
+        Arrays.fill(dp,amount+1);
+        dp[0]=0;
+        for(int i=1;i<=amount;i++){
+            for(int j=0;j<coins.length;j++){
+                if(coins[j]<=i){
+                    dp[i]=Math.min(dp[i],dp[i-coins[j]]+1);
+                }
+            }
+        }
+        return dp[amount]>amount?-1:dp[amount];
+    }
+}
diff --git a/CounttheNumberofFairPairs.java b/CounttheNumberofFairPairs.java
new file mode 100644
index 00000000..d3e2d11d
--- /dev/null
+++ b/CounttheNumberofFairPairs.java
@@ -0,0 +1,49 @@
+import java.util.Arrays;
+
+public class CounttheNumberofFairPairs {
+    public int left(int nums[], int tar){
+        int i =0;
+        int j = nums.length-1;
+        int res = -1;
+        while(i<=j){
+            int mid = (i+j)/2;
+            if(nums[mid]>=tar){
+                res = mid;
+                j = mid-1;
+            }else i = mid+1;
+        }
+        return res;
+    }
+    public int right(int nums[], int tar){
+        int i =0;
+        int j = nums.length-1;
+        int res = -1;
+        while(i<=j){
+            int mid = (i+j)/2;
+            if(nums[mid]<=tar){
+                res = mid;
+                i = mid+1;
+            }else j = mid-1;
+        }
+        return res;
+    }
+    public int solve(int nums[], int l, int r, int i){
+        int left = left(nums,l-nums[i]);
+        if(left==-1) return 0;
+        int right = right(nums,r-nums[i]);
+        if(right==-1) return 0;
+        int diff = (right-left+1);
+        if(left<=i && right>=i) diff--;
+        return diff;
+
+    }
+    public long countFairPairs(int[] nums, int lower, int upper) {
+        Arrays.sort(nums);
+        long res= 0;
+        for(int i=0; i<nums.length; i++){
+            int temp =solve(nums,lower,upper,i);
+            res+=temp;
+        }
+        return res/2;
+    }
+}
diff --git a/Factorial.java b/Factorial.java
new file mode 100644
index 00000000..c38a8fc6
--- /dev/null
+++ b/Factorial.java
@@ -0,0 +1,15 @@
+
+import java.util.*;
+public class Factorial {
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        int n=sc.nextInt();
+        System.out.println(fact(n));
+    }
+    public static int fact(int n){
+        if(n==1 || n==0){
+            return 1;
+        }
+        return n*fact(n-1);
+    }
+}
diff --git a/NaturalSum.java b/NaturalSum.java
new file mode 100644
index 00000000..b67268b1
--- /dev/null
+++ b/NaturalSum.java
@@ -0,0 +1,17 @@
+
+import java.util.*;
+public class NaturalSum {
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        int n=sc.nextInt();
+        func(n,1);
+    }
+    public static void func(int n,int n2){
+        if(n==n2){
+            System.out.print(n2);
+            return;
+        }
+        System.out.print(n2+"+");
+        func(n, n2+1);
+    }
+}
diff --git a/Nthfibonacii.java b/Nthfibonacii.java
new file mode 100644
index 00000000..93b6fe38
--- /dev/null
+++ b/Nthfibonacii.java
@@ -0,0 +1,12 @@
+import java.util.*;
+public class Nthfibonacii {
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        int n=sc.nextInt();
+        System.out.println(func(n));
+    }
+    public static int func(int n){
+        if(n==0 || n==1) return 1;
+        return func(n-1)+func(n-2);
+    }
+}
diff --git a/PowerOf2.java b/PowerOf2.java
new file mode 100644
index 00000000..094c2dfa
--- /dev/null
+++ b/PowerOf2.java
@@ -0,0 +1,20 @@
+
+
+public class PowerOf2 {
+    public static void main(String[] args) {
+        PowerOf2 p = new PowerOf2();
+        int num = 16;
+        if (p.isPowerOfTwo(num)) {
+            System.out.println(num + " is a power of 2.");
+        } else {
+            System.out.println(num + " is not a power of 2.");
+        }
+    }
+
+    public boolean isPowerOfTwo(int n) {
+        if (n <= 0) {
+            return false;
+        }
+        return (n & (n - 1)) == 0;
+    }
+}
diff --git a/README.md b/README.md
deleted file mode 100644
index bc9b5590..00000000
--- a/README.md
+++ /dev/null
@@ -1,362 +0,0 @@
-# DSA-Task-
-
-# For Any Doubt 💬
-
-Reach out to *Piyush* at *6397415707* Or *Parth* at *9559805577*.
-# Week 2 Task: The Beauty of Binary Search 🚀
-
-# Ultimate Guide to Binary Search
-
-Binary Search is one of the most fundamental and efficient searching algorithms. It operates on the principle of **divide and conquer**, allowing you to solve a problem by repeatedly halving the search space. This guide will provide you with everything you need to know about Binary Search, from the basics to advanced topics, along with templates and practice problems.
-
----
-
-## Table of Contents
-
-1. [Introduction to Binary Search](#introduction-to-binary-search)
-2. [When to Use Binary Search](#when-to-use-binary-search)
-3. [Recognizing a Binary Search Problem](#recognizing-a-binary-search-problem)
-4. [Upper Bound and Lower Bound](#upper-bound-and-lower-bound)
-5. [Binary Search on Answer](#binary-search-on-answer)
-6. [Templates for Binary Search](#templates-for-binary-search)
-7. [Practice Questions](#practice-questions)
-
----
-
-## Introduction to Binary Search
-
-Binary Search is a searching technique used on **sorted arrays or ranges** to find an element or a condition. The algorithm works by dividing the search space into two halves, checking the middle element, and eliminating half of the search space based on the comparison.
-
-### Key Properties:
-- **Input Requirement**: The array or range must be sorted.
-- **Efficiency**: The time complexity is **O(log n)**, which makes Binary Search much faster than a linear search, especially for large datasets.
-
----
-
-## When to Use Binary Search
-
-### Indicators of Binary Search Problems:
-- **Sorted Data**: When the input is sorted (increasing, decreasing, or even rotated), Binary Search is likely applicable.
-- **Search for Extremes**: When you're tasked with finding a minimum, maximum, or something like "first occurrence", "last occurrence".
-- **Range Queries**: Problems asking for a specific range, such as finding the lower or upper bound.
-- **Optimization Problems**: When minimizing or maximizing a value is the goal, Binary Search can often be applied on the answer space.
-
-### Common Scenarios:
-- Searching for an element in a sorted array.
-- Finding the first or last occurrence of an element.
-- Optimizing time, distance, or other criteria where you are asked to "minimize" or "maximize" something.
-
----
-
-## Recognizing a Binary Search Problem
-
-Many problems aren't directly presented as Binary Search problems, but with practice, you'll start to recognize common patterns.
-
-#### Ask yourself:
-1. **Is the input sorted or can it be treated as sorted?**
-2. **Can I break down the problem by halving the search space?**
-3. **Am I trying to find a value that satisfies a certain condition (minimum/maximum, first/last occurrence)?**
-4. **Is the problem asking me to minimize or maximize something?**
-
-If any of these questions apply, Binary Search could be a potential solution.
-
----
-
-## Upper Bound and Lower Bound
-
-### **Lower Bound**:
-The smallest index where the target is greater than or equal to a value. Useful when finding the first occurrence or the smallest element that satisfies a condition.
-
-### **Upper Bound**:
-The first index where an element is strictly greater than the target. Useful when finding ranges of elements or when checking the validity of a range.
-
-### Applications of UB and LB:
-- **Range Queries**: Find the number of occurrences of a specific element.
-- **Positioning**: Used to find the insert position in sorted arrays.
-
-### Example (Lower Bound in Java):
-```java
-public int lowerBound(int[] nums, int target) {
-    int low = 0, high = nums.length;
-    while (low < high) {
-        int mid = low + (high - low) / 2;
-        if (nums[mid] < target) {
-            low = mid + 1;
-        } else {
-            high = mid;
-        }
-    }
-    return low;
-}
-```
-### Example (Upper Bound in Java):
-```java
-public int upperBound(int[] nums, int target) {
-    int low = 0, high = nums.length;
-    while (low < high) {
-        int mid = low + (high - low) / 2;
-        if (nums[mid] <= target) {
-            low = mid + 1;
-        } else {
-            high = mid;
-        }
-    }
-    return low;
-}
-```
-
-# Binary Search on Answer
-
-Binary Search isn't always used on arrays. In some problems, we need to search for the answer itself. This is called **Binary Search on the Answer**, where the search space is a range of potential answers, and we determine whether a particular value satisfies a condition.
-
-## Examples
-- **Minimizing Maximum Distance:** Find the maximum minimum distance between elements.
-- **Minimizing Time or Cost:** Solve problems like minimizing the maximum load, distance, or time.
-
-## How to Identify
-- The problem asks for the minimum/maximum of some criteria.
-- You need to satisfy certain conditions by varying the possible answers.
-
-## Example: Binary Search on Answer Template in Java
-
-```java
-public boolean canSatisfyCondition(int mid, int[] conditions) {
-    // Implement the logic to check if mid satisfies the problem's conditions.
-    return true; // or false depending on whether the condition is satisfied
-}
-
-public int binarySearchOnAnswer(int[] arr) {
-    int low = 1, high = arr.length, answer = -1;
-    while (low <= high) {
-        int mid = low + (high - low) / 2;
-        if (canSatisfyCondition(mid, arr)) {
-            answer = mid; // Update answer if condition is met
-            high = mid - 1; // Adjust for minimizing
-        } else {
-            low = mid + 1; // Adjust for maximizing
-        }
-    }
-    return answer;
-}
-```
-# Binary Search Templates
-
-## Standard Binary Search
-Use this template when searching for an element in a sorted array.
-
-```java
-public int binarySearch(int[] nums, int target) {
-    int low = 0, high = nums.length - 1;
-    while (low <= high) {
-        int mid = low + (high - low) / 2;
-        if (nums[mid] == target) {
-            return mid; // Element found
-        } else if (nums[mid] < target) {
-            low = mid + 1;
-        } else {
-            high = mid - 1;
-        }
-    }
-    return -1; // Element not found
-}
-```
-# Binary Search on Answer Template
-
-This template is useful for problems that involve minimizing or maximizing a result. It provides a structured approach to implement binary search over a defined range.
-
-## Code Template
-
-The following Java code demonstrates the basic structure for performing a binary search on a specified range.
-
-```java
-public int binarySearchOnRange(int low, int high, int[] arr) {
-    int answer = -1;
-    while (low <= high) {
-        int mid = low + (high - low) / 2;
-        if (isValid(mid, arr)) {
-            answer = mid;
-            high = mid - 1; // Minimizing answer
-        } else {
-            low = mid + 1;
-        }
-    }
-    return answer;
-}
-
-public boolean isValid(int mid, int[] arr) {
-    // Implement problem-specific condition
-    return true; // Change this based on your criteria
-}
-```
-
-## Explanation
-
-- **`binarySearchOnRange(int low, int high, int[] arr)`**:
-    - This method performs binary search within the range defined by `low` and `high` indices.
-    - It initializes the variable `answer` to keep track of the most recent valid `mid` value that meets the conditions specified in the `isValid` method.
-    - The search continues as long as `low` is less than or equal to `high`. The midpoint `mid` is calculated, and if it is valid, `answer` is updated, and the search space is narrowed to the lower half (`high = mid - 1`). If it is not valid, the search space is adjusted to the upper half (`low = mid + 1`).
-
-- **`isValid(int mid, int[] arr)`**:
-    - This method is a placeholder that needs to be customized to implement the specific conditions required by the problem at hand.
-    - It should return a boolean value indicating whether the current `mid` value satisfies the necessary criteria.
-
-
-## Practice Questions
-
-### Easy Questions
-1. [Binary Search](https://leetcode.com/problems/binary-search/)
-2. [Search Insert Position](https://leetcode.com/problems/search-insert-position/)
-3. [Search a 2D Matrix](https://leetcode.com/problems/search-a-2d-matrix/)
-4. [Sqrt(x)](https://leetcode.com/problems/sqrtx/)
-5. [First Bad Version](https://leetcode.com/problems/first-bad-version/)
-6. [Find Minimum in Rotated Sorted Array](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/)
-7. [Find Smallest Letter Greater Than Target](https://leetcode.com/problems/find-smallest-letter-greater-than-target/)
-
-### Medium Questions
-1. [Find First and Last Position of Element in Sorted Array](https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/)
-2. [Find Peak Element](https://leetcode.com/problems/find-peak-element/)
-3. [Koko Eating Bananas](https://leetcode.com/problems/koko-eating-bananas/)
-4. [Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array/)
-5. [Minimum Speed to Arrive on Time](https://leetcode.com/problems/minimum-speed-to-arrive-on-time/)
-6. [Split Array Largest Sum](https://leetcode.com/problems/split-array-largest-sum/)
-
-### Hard Questions
-1. [Median of Two Sorted Arrays](https://leetcode.com/problems/median-of-two-sorted-arrays/)
-2. [Find in Mountain Array](https://leetcode.com/problems/find-in-mountain-array/)
-3. [Find a Peak Element II](https://leetcode.com/problems/find-a-peak-element-ii/)
-
-### Classical Problems
-1. [Aggressive Cows (SPOJ)](https://www.spoj.com/problems/aggrcows/)
-2. [Painter Partition Problem (GFG)](https://www.geeksforgeeks.org/painter-partition-problem/)
-
-
-
----
-
-# Week 1 Task: Let's Master "Subarray" Related Problems 🚀
-
-## 1. Understand the Problem Clearly:
-
-- Carefully read the problem and break it down.
-- Are you asked to find a subarray with certain properties (e.g., smallest, largest sum, divisible sum)?
-- Are you asked to maximize, minimize, or check for the existence of a condition?
-- Does the problem allow for negative numbers or only positive ones?
-
-Understanding these questions is the first step towards identifying which algorithm or technique might work best for solving the problem.
-
----
-
-## 2. Analyze the Subarray Nature:
-
-Subarrays are contiguous parts of an array, and different categories of subarray-related problems exist. 
-- *Key Point*: Each category has specific patterns and hints towards a particular type of solution, so recognizing the subarray nature in the problem is crucial.
-
----
-
-## 3. Look for Common Patterns:
-
-### 1) Sliding Window or Two-Pointer Technique:
-
-- *When to Use*:
-  - Finding a subarray with a fixed sum or length.
-  - Finding a subarray with conditions that can be checked as you move from one end of the array to another.
-  
-- *Why It Works*: This technique is efficient because it processes the array in linear time, expanding and contracting the window as needed.
-
-- *Common Problem Types*:
-  - Finding the smallest subarray with a sum greater than X.
-  - Longest subarray with distinct elements or fixed-length subarrays.
-
-- *Example*:
-  - If you’re asked to find the longest subarray with sum ≤ k, sliding window is often the best approach.
-
----
-
-### 2) Kadane’s Algorithm (Dynamic Programming):
-
-- *When to Use*:
-  - Finding the maximum subarray sum.
-
-- *Why It Works*:
-  - This algorithm efficiently tracks the maximum subarray sum ending at each index.
-  - It's optimal as it builds solutions to subproblems (maximum sums ending at earlier indices) and extends them to solve larger problems.
-
-- *Common Problem Types*:
-  - Finding the maximum subarray sum, especially when there are no constraints on subarray length or when negative values are allowed.
-
-- *Example*:
-  - Given an array, find the maximum sum of any subarray.
-
----
-
-### 3) Prefix Sum & HashMap:
-
-- *When to Use*:
-  - Modulo arithmetic (e.g., sum divisible by a number).
-  - Checking sums over subarrays (especially when the subarray can be of any size).
-
-- *Why It Works*:
-  - The prefix sum allows us to break down a subarray sum into differences between two prefix sums.
-  - HashMaps are used for fast lookups of previously seen sums, especially useful for problems with conditions like "sum divisible by k."
-
-- *Common Problem Types*:
-  - Finding subarrays that sum to k, or removing a subarray to make a sum divisible by a given value.
-
-- *Example*:
-  - Find the smallest subarray whose sum is divisible by a number p.
-
----
-
-## 4. Practice Questions
-
-### Easy Problems:
-
-1. [Assign Cookies](https://leetcode.com/problems/assign-cookies/)
-2. [Buy Two Chocolates](https://leetcode.com/problems/buy-two-chocolates/)
-3. [Count Elements with Maximum Frequency](https://leetcode.com/problems/count-elements-with-maximum-frequency/)
-4. [Divide Array into Arrays with Max Difference](https://leetcode.com/problems/divide-array-into-arrays-with-max-difference/)
-5. [Find Common Characters](https://leetcode.com/problems/find-common-characters/)
-6. [Lemonade Change](https://leetcode.com/problems/lemonade-change/)
-7. [Minimum Common Value](https://leetcode.com/problems/minimum-common-value/)
-
----
-
-### Two-Pointer Problems:
-
-1. [3Sum](https://leetcode.com/problems/3sum/)
-2. [3Sum Closest](https://leetcode.com/problems/3sum-closest/)
-3. [Longest Mountain in Array](https://leetcode.com/problems/longest-mountain-in-array/)
-4. [Maximum Erasure Value](https://leetcode.com/problems/maximum-erasure-value/)
-5. [Max Consecutive Ones II](https://leetcode.com/problems/max-consecutive-ones-ii/)
-
----
-
-### Prefix Sum Problems:
-
-1. [Contiguous Array](https://leetcode.com/problems/contiguous-array/)
-2. [Continuous Subarray Sum](https://leetcode.com/problems/continuous-subarray-sum/)
-3. [Count Number of Nice Subarrays](https://leetcode.com/problems/count-number-of-nice-subarrays)
-4. [Find Pivot Index](https://leetcode.com/problems/find-pivot-index/)
-5. [K-radius Subarray Averages](https://leetcode.com/problems/k-radius-subarray-averages/)
-
----
-
-## 5. Let's Solve Some Problems:
-
-### Leetcode Problems:
-
-1. [Container With Most Water](https://leetcode.com/problems/container-with-most-water/)
-2. [Maximum Product Subarray](https://leetcode.com/problems/maximum-product-subarray/)
-3. [Subarray Sum Equals K](https://leetcode.com/problems/subarray-sum-equals-k/description/)
-4. [Count Number of Nice Subarrays](https://leetcode.com/problems/count-number-of-nice-subarrays/description/)
-
-### OA Problem:
-
-1. LinkedIn - SDE Intern:
-   - *Question*: Given a list of words, if any two adjacent characters in a word are equal, change one of them. Determine the minimum number of substitutions so the final string contains no adjacent equal characters.
-   
-   Example:  
-   Input: ['add', 'boook', 'break']  
-   Output: [1, 1, 0]
-
----
diff --git a/Solution.java b/Solution.java
new file mode 100644
index 00000000..c9257b68
--- /dev/null
+++ b/Solution.java
@@ -0,0 +1,42 @@
+
+class Solution {
+    public int islandPerimeter(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        int ans = 0;
+        int up, down, left, right;
+
+        for (int r = 0; r < rows; r++) {
+            for (int c = 0; c < cols; c++) {
+                if (grid[r][c] == 1) {
+                    if (r == 0) {
+                        up = 1;
+                    } else {
+                        up = (grid[r - 1][c] == 0) ? 1 : 0;
+                    }
+
+                    if (c == 0) {
+                        left = 1;
+                    } else {
+                        left = (grid[r][c - 1] == 0) ? 1 : 0;
+                    }
+
+                    if (r == rows - 1) {
+                        down = 1;
+                    } else {
+                        down = (grid[r + 1][c] == 0) ? 1 : 0;
+                    }
+
+                    if (c == cols - 1) {
+                        right = 1;
+                    } else {
+                        right = (grid[r][c + 1] == 0) ? 1 : 0;
+                    }
+
+                    ans += up + left + down + right;
+                }
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/Stopwatch.java b/Stopwatch.java
new file mode 100644
index 00000000..fc6e37df
--- /dev/null
+++ b/Stopwatch.java
@@ -0,0 +1,14 @@
+
+import java.util.*;
+public class Stopwatch {
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        int n=sc.nextInt();
+        count(n,1);
+    }
+    public static void count(int n,int n2){
+        if(n2>n) return;
+        count(n,n2+1);
+        System.out.print(n2+" ");
+    }    
+}
diff --git a/binarySearch.java b/binarySearch.java
new file mode 100644
index 00000000..ae463e46
--- /dev/null
+++ b/binarySearch.java
@@ -0,0 +1,12 @@
+// class binarySearch{
+//     public static void main(String[] args) {
+        
+//     }
+//     public int func(int []arr,int tar){
+//         int i=0;
+//         int n=arr.length-1;
+//         while(i<n){
+//             int mid
+//         }
+//     }
+// }
\ No newline at end of file
diff --git a/code1.java b/code1.java
new file mode 100644
index 00000000..c856d398
--- /dev/null
+++ b/code1.java
@@ -0,0 +1,62 @@
+
+import java.util.*;
+import java.io.*;
+
+class code2 {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int tc = Integer.parseInt(br.readLine().trim());
+
+        while (tc-- > 0) {
+            String[] str = br.readLine().trim().split(" ");
+            int[] a = new int[str.length];
+            for (int i = 0; i < str.length; i++) {
+                a[i] = Integer.parseInt(str[i]);
+            }
+            String[] nk = br.readLine().trim().split(" ");
+            int k = Integer.parseInt(nk[0]);
+
+            Solution sln = new Solution();
+            int ans = sln.aggresiveCows(a, k);
+
+            System.out.println(ans);
+            System.out.println("~");
+        }
+    }
+}
+
+class Solution {
+    public static int aggresiveCows(int[] stalls, int k) {
+        Arrays.sort(stalls);
+        int low = 0;
+        int ans = 0;
+        int high = stalls[stalls.length - 1] - stalls[0];
+
+        while (low <= high) {
+            int mid = low + (high - low) / 2;
+            if (possible(stalls, mid, k)) {
+                ans = mid;
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+        return ans;
+    }
+
+    public static boolean possible(int[] stalls, int dist, int cows) {
+        int count = 1;
+        int last_cow = stalls[0];
+
+        for (int i = 1; i < stalls.length; i++) {
+            if (stalls[i] - last_cow >= dist) {
+                count++;
+                last_cow = stalls[i];
+            }
+            if (count >= cows) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/code3.java b/code3.java
new file mode 100644
index 00000000..e69de29b
diff --git a/code4.java b/code4.java
new file mode 100644
index 00000000..0a72e52e
--- /dev/null
+++ b/code4.java
@@ -0,0 +1,33 @@
+
+public class code4 {
+    public int[] findPeakGrid(int[][] mat) {
+        int low=0;
+        int high=mat[0].length-1;
+        while(low<=high){
+            int mid=low+(high-low)/2;
+            int row=maxele(mat,mid);
+            int leftele=mid-1>0?mat[row][mid-1]:-1;
+            int rightele=mid+1<mat[0].length?mat[row][mid+1]:-1;
+            if(mat[row][mid]>leftele && mat[row][mid]>rightele){
+                return new int[]{row,mid};
+            }
+            else if(mat[row][mid]<leftele){
+                high=mid-1;
+            }else{
+                low=mid+1;
+            }
+        }
+        return new int[]{-1,-1};
+    }
+    public static int maxele(int[][] mat,int col){
+        int max=0;
+        int idx=0;
+        for(int i=0;i<mat.length;i++){
+            if(mat[i][col]>max){
+                max=mat[i][col];
+                idx=i;
+            }
+        }
+        return idx;
+    }
+}
\ No newline at end of file
diff --git a/code5.java b/code5.java
new file mode 100644
index 00000000..6b04eee8
--- /dev/null
+++ b/code5.java
@@ -0,0 +1,35 @@
+
+public class code5 {
+        public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+            if(nums1.length>nums2.length){
+                return findMedianSortedArrays(nums2,nums1);
+            }
+            int m=nums1.length;
+            int n=nums2.length;
+            int low=0;
+            int high=nums1.length;
+            while(low<=high){
+                int mid=low+(high-low)/2;
+                int py=(m+n+1)/2-mid;
+                int x1= mid==0? Integer.MIN_VALUE:nums1[mid-1];
+                int x2= py==0 ? Integer.MIN_VALUE:nums2[py-1];
+                int x3= mid==m?Integer.MAX_VALUE:nums1[mid];
+                int x4= py==n? Integer.MAX_VALUE:nums2[py];
+                if(x1<=x4 && x2<=x3){
+                    if((m+n)%2==1){
+                        return Math.max(x1,x2);
+                    }
+                    else{
+                        return (Math.max(x1,x2)+Math.min(x3,x4))/2.0;
+                    }
+                }
+                if(x1>x4){
+                    high=mid-1;
+                }
+                else{
+                    low=mid+1;
+                }
+            }
+            return -1.0;
+        }
+    }
\ No newline at end of file
diff --git a/code6.java b/code6.java
new file mode 100644
index 00000000..e69de29b
diff --git a/count.java b/count.java
new file mode 100644
index 00000000..ab0be0a5
--- /dev/null
+++ b/count.java
@@ -0,0 +1,10 @@
+class count {
+    public static void main(String[] args) {
+        count(5);
+    }
+    public static void count(int n){
+        if(n==0) return;
+        System.out.print(n+" ");
+        count(n-1);
+    }
+}
diff --git a/countElementMaximumSum.java b/countElementMaximumSum.java
new file mode 100644
index 00000000..29a16da4
--- /dev/null
+++ b/countElementMaximumSum.java
@@ -0,0 +1,23 @@
+
+import java.util.HashMap;
+
+class CountElementsWithMaximumFrequency {
+    public static void main(String[] args){
+        int[] nums={1,2,2,1,3,4};
+        HashMap<Integer,Integer> map=new HashMap<>();
+        for(int i:nums){
+            map.put(i,map.getOrDefault(i, 0)+1);
+        }
+        int max=Integer.MIN_VALUE;
+        int cnt=0;
+        for(int i:map.values()){
+            max=Math.max(i, max);
+        }
+        for(int i:map.values()){
+            if(i==max){
+                cnt++;
+            }
+        }
+        System.err.println(cnt*max);
+    }
+}
\ No newline at end of file
diff --git a/findPeakElement.java b/findPeakElement.java
new file mode 100644
index 00000000..e69de29b
diff --git a/generate.java b/generate.java
new file mode 100644
index 00000000..e69de29b
diff --git a/lemonadeChange.java b/lemonadeChange.java
new file mode 100644
index 00000000..ee09de30
--- /dev/null
+++ b/lemonadeChange.java
@@ -0,0 +1,33 @@
+
+import java.util.*;
+class Solution {
+    public boolean lemonadeChange(int[] bills) {
+        int five=0;
+        int ten=0;
+        for(int i=0;i<bills.length;i++){
+              if(bills[i]==5){
+                five++;
+              }
+              else if(bills[i]==10){
+                if(five==0){
+                    return false;
+                }
+                five--; 
+                ten++;
+              }
+              else{
+                if(five>0 && ten>0){
+                    five--;
+                    ten--;
+                }
+                else if(five>=3){
+                    five-=3;
+                }
+                else{
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
diff --git a/listpair.java b/listpair.java
new file mode 100644
index 00000000..a5949693
--- /dev/null
+++ b/listpair.java
@@ -0,0 +1,4 @@
+
+public class listpair {
+    
+}
diff --git a/reverseStack.java b/reverseStack.java
new file mode 100644
index 00000000..9f10031d
--- /dev/null
+++ b/reverseStack.java
@@ -0,0 +1,34 @@
+import java.util.Stack;
+class reverse{
+    public static void main(String[] args) {
+        Stack<Integer> stack=new Stack<>();
+        func(5,stack);
+        // Stack<Integer> st=new Stack<>();
+        System.out.println(stack.size());
+        reverse(stack);
+        while (!stack.isEmpty()) {
+            System.out.print(stack.pop()+" ");
+        }
+    }
+    public static void func(int i,Stack<Integer> st){
+        if(i<=0) return;
+        st.push(i);
+        func(i-1, st);
+    }
+    public static void reverse(Stack<Integer> st){
+        if(st.isEmpty()) return;
+        int a=st.pop();
+        reverse(st);
+        // st.insertElementAt(a,0);
+        bottom(st,a);
+    }
+    public static void bottom(Stack<Integer> st,int a){
+        if (st.isEmpty()) {
+            st.push(a);
+            return;
+        }
+        int i=st.pop();
+        bottom(st, a);
+        st.push(i);
+    }
+}
\ No newline at end of file
diff --git a/searchRange.java b/searchRange.java
new file mode 100644
index 00000000..5ff90a05
--- /dev/null
+++ b/searchRange.java
@@ -0,0 +1,49 @@
+
+public class searchRange {
+    
+    public int[] searchRange(int[] nums, int target) {
+        int  first=firstidx(nums,target);
+        if(first==-1){
+            return new int[]{-1,-1};
+        }
+        int last=lastidx(nums,target);
+        return new int[]{first,last};
+    }
+    public static int firstidx(int[] arr,int k){
+        int low=0;
+        int high=arr.length-1;
+        int f=-1;
+        while(low<=high){
+            int mid=low+(high-low)/2;
+            if(arr[mid]==k){
+                f=mid;
+                high=mid-1;
+            }
+            else if(arr[mid]<k){
+                low=mid+1;
+            }else{
+                high =mid-1;
+            }
+        }
+        return f;
+    }
+
+    public static int lastidx(int[] arr,int k){
+        int low=0;
+        int high=arr.length-1;
+        int l=-1;
+        while(low<=high){
+            int mid=(low+high)/2;
+            if(arr[mid]==k){
+                l=mid;
+                low=mid+1;
+            }
+            else if(arr[mid]<k){
+                low=mid+1;
+            }else{
+                high=mid-1;
+            }
+        }
+        return l;
+    }
+}
\ No newline at end of file