diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..9f97022
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+target/
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index ef3b9a5..f2d9fc2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -30,6 +30,12 @@
         <artifactId>jackson-databind</artifactId>
         <version>2.14.1</version>
     </dependency>
+    <dependency>
+        <groupId>org.junit.jupiter</groupId>
+        <artifactId>junit-jupiter</artifactId>
+        <version>RELEASE</version>
+        <scope>test</scope>
+    </dependency>
 
 </dependencies>
 
diff --git a/src/main/java/Adobe/findIndicesOfParticularSum.java b/src/main/java/Adobe/findIndicesOfParticularSum.java
new file mode 100644
index 0000000..f2c99e5
--- /dev/null
+++ b/src/main/java/Adobe/findIndicesOfParticularSum.java
@@ -0,0 +1,45 @@
+package Adobe;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Given a list of integers and a target sum, write a function to find the indices of the two numbers in the list that add up to the target sum. You may assume that each input would have exactly one solution, and you may not use the same element twice.
+ * Example:
+ * int[] nums = {3, 2, 4}
+ * target=6;
+ * Output: [1, 2]
+ *
+ * Shared by Sahil Kapoor on Linkedin ===> https://www.linkedin.com/posts/sahil-kapoor25_sdet-activity-7213582581366235136-YBG0?utm_source=share&utm_medium=member_desktop
+ */
+public class findIndicesOfParticularSum {
+
+    public static int[] findSumIndices(int [] nums, int target){
+        Map<Integer,Integer> sumMap = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            int complement = target - nums[i];
+            if (sumMap.containsKey(complement)) {
+                return new int[] { sumMap.get(complement), i };
+            }
+            sumMap.put(nums[i], i);
+        }
+
+        throw new IllegalArgumentException("No two sum solution");
+    }
+
+    public static void main(String [] args){
+
+        int[] nums = {3, 2, 4};
+        int targetSum = 6;
+        int[] result = findSumIndices(nums, targetSum);
+        System.out.println("[" + result[0] + ", " + result[1] + "]");
+
+        int[] nums2 = {1, 8, 11, 15, 21, 32};
+        int target2 = 40;
+
+        int[] result1 = findSumIndices(nums2, target2);
+        System.out.println("[" + result1[0] + ", " + result1[1] + "]");
+    }
+
+
+}
diff --git a/src/main/java/Adobe/moveNegNumbersToLeft.java b/src/main/java/Adobe/moveNegNumbersToLeft.java
new file mode 100644
index 0000000..0bbff39
--- /dev/null
+++ b/src/main/java/Adobe/moveNegNumbersToLeft.java
@@ -0,0 +1,45 @@
+package Adobe;
+
+/**
+ * Given an array of integers, write a function to move all the negative numbers to the left end of the array without changing the relative order of the non-negative numbers. The function should do this in place with a minimum number of operations.
+ * Example:
+ * int[] nums = {1, -1, 3, -2, -3, 5, 6, -7}
+ * Output: [-1, -2, -3, -7, 1, 3, 5, 6]
+ *
+ * Shared by Sahil Kapoor on Linkedin ===> https://www.linkedin.com/posts/sahil-kapoor25_sdet-activity-7213582581366235136-YBG0?utm_source=share&utm_medium=member_desktop
+ */
+public class moveNegNumbersToLeft {
+
+    public static void moveNegativesToLeft(int [] nums){
+        int n = nums.length;
+
+        for (int i = 0; i < n; i++) {
+            if (nums[i] < 0) {
+                int temp = nums[i];
+                // Shift non-negative numbers to the right
+                int j = i;
+                while (j > 0 && nums[j - 1] >= 0) {
+                    nums[j] = nums[j - 1];
+                    j--;
+                }
+                nums[j] = temp;
+            }
+        }
+    }
+
+    public static void main(String [] args){
+        int[] nums = {1, -1, 3, -2, -3, 5, 6, -7};
+        moveNegativesToLeft(nums);
+        for(int num : nums){
+            System.out.print(num+ " ");
+        }
+
+        System.out.println("\n");
+
+        int[] nums2 = {2, -3, 4, -1, -4, 5, -2, 3};
+        moveNegativesToLeft(nums2);
+        for(int num : nums2){
+            System.out.print(num+ " ");
+        }
+    }
+}
diff --git a/src/main/java/Adobe/shareSellAndBuy.java b/src/main/java/Adobe/shareSellAndBuy.java
new file mode 100644
index 0000000..ee9a84d
--- /dev/null
+++ b/src/main/java/Adobe/shareSellAndBuy.java
@@ -0,0 +1,32 @@
+package Adobe;
+
+/**
+ * Asked in Round -1 of Adobe
+ *
+ */
+public class shareSellAndBuy {
+    public int maxProfit(int [] prices){
+        if(prices==null || prices.length==0) return 0;
+        int minPrice = prices[0];
+        int maxProfit = 0;
+
+        for(int i=1;i<prices.length;i++){
+            if(prices[i] < minPrice){
+                minPrice = prices[i];
+            }else{
+                maxProfit = Math.max(maxProfit,prices[i]-minPrice);
+            }
+        }
+        return maxProfit;
+
+    }
+
+    public static void main(String [] args){
+        shareSellAndBuy sbuy = new shareSellAndBuy();
+        int[] prices1 = {7, 1, 5, 3, 6, 4};
+        int[] prices2 = {7, 6, 4, 3, 1};
+
+        System.out.println(sbuy.maxProfit(prices1));
+        System.out.println(sbuy.maxProfit(prices2));
+    }
+}
diff --git a/src/main/java/Amazon/largestSumInSubArray.java b/src/main/java/Amazon/largestSumInSubArray.java
new file mode 100644
index 0000000..3fd2837
--- /dev/null
+++ b/src/main/java/Amazon/largestSumInSubArray.java
@@ -0,0 +1,28 @@
+package Amazon;
+
+/**
+ * In an given array, find the sub array that has the maximum sum and print the sum
+ * For eg [-2,1,-3,4,-1,2,1,-5,4] has subarray [4,-1,2,1] whose sum is 6
+ */
+public class largestSumInSubArray {
+    public int MaxSubArray(int [] nums){
+        if(nums == null || nums.length==0) return 0;
+
+        int prev = nums[0];
+        int max = prev;
+        for(int i=1;i<nums.length;i++){
+            if(prev<0){
+                prev=0;
+            }
+            prev+=nums[i];
+            if (prev > max)max = prev;
+        }
+        return max;
+    }
+
+    public static void main(String [] args){
+        int[] arr = {-2,1,-3,4,-1,2,1,-5,4};
+        largestSumInSubArray msm = new largestSumInSubArray();
+        System.out.println(msm.MaxSubArray(arr));
+    }
+}
diff --git a/src/main/java/Amazon/largestSuminSubArray2.java b/src/main/java/Amazon/largestSuminSubArray2.java
new file mode 100644
index 0000000..814c494
--- /dev/null
+++ b/src/main/java/Amazon/largestSuminSubArray2.java
@@ -0,0 +1,50 @@
+package Amazon;
+
+/**
+ * In an given array, find the sub array that has the maximum sum and print the sum
+ * For eg [-2,1,-3,4,-1,2,1,-5,4] has subarray [4,-1,2,1] whose sum is 6
+ * Also return the sub array that constitutes this sum
+ */
+public class largestSuminSubArray2 {
+
+    public int[] MaxSubArray(int [] nums){
+        if(nums==null || nums.length==0) return new int[0];
+
+        int prev = nums[0];
+        int max = prev;
+        int start = 0;
+        int end = 0;
+        int tempStart = 0;
+
+        for(int i=1;i<nums.length;i++){
+            if(prev < 0){
+                prev = nums[i];
+                tempStart = i;
+            }else {
+                prev+=nums[i];
+            }
+            if(prev > max){
+                max = prev;
+                start = tempStart;
+                end = i;
+            }
+        }
+
+        int [] result = new int[end-start+1];
+        for(int i=start;i<=end;i++){
+            result[i-start] = nums[i];
+        }
+        System.out.println("Maximum sum subarray: " + max);
+        return result;
+    }
+    public static void main(String[] args) {
+        int[] arr = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
+        largestSuminSubArray2 msm = new largestSuminSubArray2();
+        int[] result = msm.MaxSubArray(arr);
+
+        System.out.print("Elements of the subarray with the maximum sum: ");
+        for (int num : result) {
+            System.out.print(num + " ");
+        }
+    }
+}
diff --git a/src/main/java/Amazon/longestCommonPrefix.java b/src/main/java/Amazon/longestCommonPrefix.java
new file mode 100644
index 0000000..8e1b505
--- /dev/null
+++ b/src/main/java/Amazon/longestCommonPrefix.java
@@ -0,0 +1,35 @@
+package Amazon;
+
+/**
+ * Amazon Round -2 Find the largest common prefix string if available. Return an empty string
+ * if there is no common prefix.
+ *
+ * For eg - ["flower", "flow", "flight"] --> each has a common prefix "fl"
+ * Another eg - ["dog", "racecar", "car"] --> no common prefix although last two words have common prefix
+ *
+ */
+public class longestCommonPrefix {
+
+    public static String returnCommonPrefix(String [] strArr){
+        if(strArr == null || strArr.length==0) return "";
+        String prefix = strArr[0];
+
+        for(int i =1;i<strArr.length;i++){
+            while (strArr[i].indexOf(prefix)!=0){
+                prefix = prefix.substring(0,prefix.length()-1);
+                if(prefix.isEmpty()){
+                    return "";
+                }
+            }
+        }
+        return prefix;
+    }
+
+    public static void main(String [] args){
+        String [] str = {"flower", "flow", "flight"};
+        System.out.println("Longest common prefix is "+returnCommonPrefix(str));
+
+        String [] str2 = {"dog", "racecar", "car"};
+        System.out.println("Longest common prefix is "+returnCommonPrefix(str2));
+    }
+}
diff --git a/src/main/java/Amazon/reverseCharactersInString.java b/src/main/java/Amazon/reverseCharactersInString.java
new file mode 100644
index 0000000..cf44220
--- /dev/null
+++ b/src/main/java/Amazon/reverseCharactersInString.java
@@ -0,0 +1,48 @@
+package Amazon;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+/**
+ * String input : "Hi my name is ABCD"
+ * String output : "iH ym eman si DCBA"
+ */
+public class reverseCharactersInString {
+
+    // Approach 1 without using any default method
+    public static String reverseApproach1(String str){
+        if(str == null || str.isEmpty()){
+            return str;
+        }
+
+        String [] tokens = str.split(" ");
+        StringBuilder sb = new StringBuilder("");
+        for(String string1 : tokens){
+            sb.append(reverseString(string1)+" ");
+        }
+        return sb.substring(0,sb.length()-1);
+    }
+
+    public static String reverseString(String input){
+        if(input == null || input.isEmpty()) return input;
+        char [] charArr = input.toCharArray();
+        for(int i=0;i<charArr.length/2;i++){
+            char temp = charArr[i];
+            charArr[i] = charArr[charArr.length-1-i];
+            charArr[charArr.length-1-i] = temp;
+        }
+        return new String(charArr);
+    }
+
+    public static String reverseApproach2(String str){
+        // Approach 2 using Streams
+        return Arrays.stream(str.split(" "))
+                .map(reverseCharactersInString :: reverseString)
+                .collect(Collectors.joining(" "));
+    }
+
+    public static void main(String [] args){
+        System.out.println(reverseApproach1("Welcome to Java"));
+        System.out.println(reverseApproach2("Hi my name is ABCD"));
+    }
+}
diff --git a/src/main/java/Arrays/PrintAlternateNumber.java b/src/main/java/Arrays/PrintAlternateNumber.java
new file mode 100644
index 0000000..72c6676
--- /dev/null
+++ b/src/main/java/Arrays/PrintAlternateNumber.java
@@ -0,0 +1,24 @@
+package Arrays;
+
+public class PrintAlternateNumber {
+    public static void printAlternate(int [] arr){
+        for (int i = 0; i < arr.length; i += 2) {
+            System.out.print(arr[i] + " ");
+        }
+        System.out.println(); //
+    }
+
+    public static void main(String [] args){
+        int[] arr1 = {3, 1, 5, 7, 8, 1};
+        System.out.print("Input: {3, 1, 5, 7, 8, 1} => Output: ");
+        printAlternate(arr1);
+
+        int[] arr2 = {10, 25, 33, 48, 51};
+        System.out.print("Input: {10, 25, 33, 48, 51} => Output: ");
+        printAlternate(arr2);
+
+        int[] arr3 = {99};
+        System.out.print("Input: {99} => Output: ");
+        printAlternate(arr3);
+    }
+}
diff --git a/src/main/java/Bhaskar/Bhaskar.java b/src/main/java/Bhaskar/Bhaskar.java
new file mode 100644
index 0000000..485191d
--- /dev/null
+++ b/src/main/java/Bhaskar/Bhaskar.java
@@ -0,0 +1,52 @@
+package Bhaskar;
+
+import java.util.*;
+
+/***
+ * Given a string s and a string array dictionary, return the longest string in the dictionary that can be formed by deleting some of the given string characters. If there is more than one possible result, return the longest word with the smallest lexicographical order. If there is no possible result, return the empty string.
+ *
+ * // Example 1:
+ *
+ * // Input: s = "abpcplea", dictionary = ["ale","apple","monkey","plea"]
+ * // Output: "apple"
+ */
+public class Bhaskar {
+    public String findLongestWord(String str, List<String> dict){
+        List<String> mutableDictionary = new ArrayList<>(dict);
+        Collections.sort(mutableDictionary, new Comparator<String>() {
+            @Override
+            public int compare(String s, String t1) {
+                if(s.length() !=t1.length()){
+                    return t1.length() - s.length();
+                }else{
+                    return s.compareTo(t1);
+                }
+            }
+        });
+        for(String word:mutableDictionary){
+            if(isSubSequence(str,word)){
+                return word;
+            }
+        }
+        return "";
+    }
+
+    private boolean isSubSequence(String s, String word){
+        int i = 0, j = 0;
+        while (i < s.length() && j < word.length()) {
+            if (s.charAt(i) == word.charAt(j)) {
+                j++;
+            }
+            i++;
+        }
+        return j == word.length();
+    }
+
+    public static void main(String [] args){
+        Bhaskar bsk = new Bhaskar();
+        List<String> dictionary = List.of("ale","apple","monkey","plea");
+        String s = "abpcplea";
+        System.out.println(bsk.findLongestWord(s, dictionary));
+    }
+
+}
diff --git a/src/main/java/Coursera/findTriplets.java b/src/main/java/Coursera/findTriplets.java
new file mode 100644
index 0000000..60fc3f6
--- /dev/null
+++ b/src/main/java/Coursera/findTriplets.java
@@ -0,0 +1,11 @@
+package Coursera;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class findTriplets {
+    public static List<List<Integer>> findTriplets(List<Integer> arr, int sum){
+        List<List<Integer>> triplets = new ArrayList<>();
+        return null;
+    }
+}
diff --git a/src/main/java/Fox/subArraySum.java b/src/main/java/Fox/subArraySum.java
new file mode 100644
index 0000000..41891e6
--- /dev/null
+++ b/src/main/java/Fox/subArraySum.java
@@ -0,0 +1,41 @@
+package Fox;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Asked in Fox SDET-II Interview Round -1
+ * If there is an array [arr], find all the sub-arrays whose sum equals an integer K
+ * e.g - [1,2,1,3], k=4 -> [1,3],[1,2,1]
+ *
+ */
+public class subArraySum {
+
+    public int subArray(int [] arr, int k){
+        int count = 0;
+        int totalSum = 0;
+
+        Map<Integer, Integer> mp = new HashMap<>();
+        mp.put(0,1);
+        for(int num : arr){
+            totalSum+= num;
+            if(mp.containsKey(totalSum-k)){
+                count+= mp.get(totalSum-k);
+            }
+            mp.put(totalSum,mp.getOrDefault(totalSum,0)+1);
+        }
+
+        return count;
+
+    }
+    public static void main(String [] args){
+        subArraySum solution = new subArraySum();
+        int[] nums1 = {1,2,1,3};
+        int k1 = 4;
+        System.out.println(solution.subArray(nums1, k1));
+
+        int[] nums2 = {1, 2, 3};
+        int k2 = 3;
+        System.out.println(solution.subArray(nums2, k2));
+    }
+}
diff --git a/src/main/java/Microsoft/TwoSumArr.java b/src/main/java/Microsoft/TwoSumArr.java
new file mode 100644
index 0000000..8f7480a
--- /dev/null
+++ b/src/main/java/Microsoft/TwoSumArr.java
@@ -0,0 +1,30 @@
+package Microsoft;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
+ */
+public class TwoSumArr {
+    public int [] twoSumProblem(int [] arr, int target){
+        Map<Integer,Integer> mp = new HashMap<>();
+        for(int i=0;i<arr.length;i++){
+            int comp = target - arr[i];
+            if(mp.containsKey(comp)){
+                return new int[]{mp.get(comp),i};
+            }
+            mp.put(arr[i],i);
+        }
+        throw new IllegalArgumentException("No two sum solution");
+    }
+
+    public static void main(String[] args) {
+        TwoSumArr solution = new TwoSumArr();
+        int[] nums = {2,7,11,15};
+        int target = 18;
+
+        int[] result = solution.twoSumProblem(nums, target);
+        System.out.println("Indices: " + result[0] + ", " + result[1]);
+    }
+}
diff --git a/src/main/java/Microsoft/TwoSumProblem.java b/src/main/java/Microsoft/TwoSumProblem.java
new file mode 100644
index 0000000..f9ae5d6
--- /dev/null
+++ b/src/main/java/Microsoft/TwoSumProblem.java
@@ -0,0 +1,67 @@
+package Microsoft;
+
+import java.util.List;
+
+class ListNode{
+int val;
+ListNode next;
+ListNode(){};
+ListNode(int val){
+    this.val = val;
+}
+ListNode(int val, ListNode next){
+    this.val = val;
+    this.next = next;
+    }
+}
+
+/**
+ *
+ */
+public class TwoSumProblem {
+    public ListNode addTwoSumProblem(ListNode l1, ListNode l2){
+        ListNode dummyhead = new ListNode(0);
+        ListNode current = dummyhead;
+        int carry = 0;
+        while(l1 != null || l2 !=null || carry !=0){
+            int x = (l1 !=null) ? l1.val : 0;
+            int y = (l2 !=null) ? l2.val : 0;
+            int sum = x + y + carry;
+
+            carry = sum/10;
+            current.next = new ListNode(sum %10);
+            current = current.next;
+
+            if(l1 !=null) l1 = l1.next;
+            if(l2 !=null) l2 = l2.next;
+        }
+
+        return dummyhead.next;
+
+    }
+    public static ListNode createLinkedList(int [] arr){
+        ListNode dummyhead = new ListNode(0);
+        ListNode current = dummyhead;
+        for (int num : arr){
+            current.next = new ListNode(num);
+            current = current.next;
+        }
+
+        return dummyhead.next;
+    }
+
+    public static void main(String [] args){
+        int[] arr1 = {9, 9, 9, 9, 9, 9, 9};
+        int[] arr2 = {9, 9, 9, 9};
+        ListNode l1 = createLinkedList(arr1);
+        ListNode l2 = createLinkedList(arr2);
+
+        TwoSumProblem tw = new TwoSumProblem();
+        ListNode result = tw.addTwoSumProblem(l1,l2);
+
+        while(result!= null){
+            System.out.print(result.val + "->");
+            result = result.next;
+        }
+    }
+}
diff --git a/src/main/java/Microsoft/maxSubArraySum.java b/src/main/java/Microsoft/maxSubArraySum.java
new file mode 100644
index 0000000..a21c83c
--- /dev/null
+++ b/src/main/java/Microsoft/maxSubArraySum.java
@@ -0,0 +1,23 @@
+package Microsoft;
+
+/**
+ * If there is an array [arr],you have to get the sub array with the maximum sum and return the sum
+ * arr =[5,4,-1,7,8], sum = 23 , sub array = [5,4,-1,7,8]
+ */
+public class maxSubArraySum {
+    public static int maxArraySum(int [] arr){
+        int maxSum = arr[0];
+        int maxEndingHere = arr[0];
+
+        for(int i=1;i<arr.length;i++){
+            maxEndingHere = Math.max(arr[i],maxEndingHere+arr[i]);
+            maxSum = Math.max(maxSum,maxEndingHere);
+        }
+        return maxSum;
+    }
+
+    public static void main(String [] args){
+        int[] nums = {5,4,-1,7,8};
+        System.out.println(maxArraySum(nums)); // Output: 6
+    }
+}
diff --git a/src/main/java/Others/CompareJSONStrings.java b/src/main/java/Others/CompareJSONStrings.java
new file mode 100644
index 0000000..949eeed
--- /dev/null
+++ b/src/main/java/Others/CompareJSONStrings.java
@@ -0,0 +1,55 @@
+package Others;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class CompareJSONStrings {
+
+    public static Map<String,String> parsingJSON(String jsonValue){
+        jsonValue = jsonValue.trim();
+        if(jsonValue.startsWith("{")) jsonValue = jsonValue.substring(1);
+        if(jsonValue.endsWith("}")) jsonValue = jsonValue.substring(0, jsonValue.length()-1);
+
+
+        Map<String, String> result = new HashMap<>();
+        String [] jsonPairs = jsonValue.split(", ");
+        for (String pairs : jsonPairs){
+            String [] keyVal = pairs.split(": ");
+            String key = keyVal[0].replaceAll("\"", "");
+            String value  = keyVal[1].replaceAll("\"", "");
+            result.put(key, value);
+
+        }
+
+        return result;
+
+    }
+    public static List<String> findDiffKeys(String json1, String json2){
+        Map<String, String> map1 = parsingJSON(json1);
+        Map<String, String> map2 = parsingJSON(json2);
+
+        List<String> diffKeys = new ArrayList<>();
+        for (String key : map1.keySet()){
+            if(map2.containsKey(key) && !map1.get(key).equals(map2.get(key))){
+                diffKeys.add(key);
+            }
+        }
+        return diffKeys;
+    }
+
+    public static void main(String [] args){
+        String jsonStr1 = "{\"a\": 1, \"b\": 2, \"c\": 3}";
+        String jsonStr2 = "{\"a\": 1, \"b\": 3, \"c\": 3, \"d\": 4}";
+        List<String> differingKeys = findDiffKeys(jsonStr1, jsonStr2);
+        System.out.println(differingKeys);  // Output: [b]
+
+        String jsonStr3 = "{\"name\": \"Alice\", \"age\": 25, \"city\": \"New York\"}";
+        String jsonStr4 = "{\"name\": \"Alice\", \"age\": 30, \"city\": \"Los Angeles\", \"country\": \"USA\"}";
+        differingKeys = findDiffKeys(jsonStr3, jsonStr4);
+        System.out.println(differingKeys);  // Output: [age,
+    }
+
+
+}
diff --git a/src/main/java/Strings/ExtractNumberOnly.java b/src/main/java/Strings/ExtractNumberOnly.java
new file mode 100644
index 0000000..e266379
--- /dev/null
+++ b/src/main/java/Strings/ExtractNumberOnly.java
@@ -0,0 +1,23 @@
+package Strings;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ExtractNumberOnly {
+
+    public static String extractNumber(String input){
+        Pattern pattern = Pattern.compile("\\d+");
+        Matcher matcher = pattern.matcher(input);
+
+        if(matcher.find()){
+            return matcher.group();
+        }else{
+            return "No number found";
+        }
+    }
+    public static void main(String [] args){
+        System.out.println(extractNumber("JavaLearning2024")); // Output: 2024
+        System.out.println(extractNumber("Version1.5"));     // Output: 15
+        System.out.println(extractNumber("NoNumbersHere"));
+    }
+}
diff --git a/src/main/java/Strings/GroupAnagrams.java b/src/main/java/Strings/GroupAnagrams.java
new file mode 100644
index 0000000..445c7a5
--- /dev/null
+++ b/src/main/java/Strings/GroupAnagrams.java
@@ -0,0 +1,35 @@
+package Strings;
+
+import java.util.*;
+
+public class GroupAnagrams {
+
+    public List<List<String>> groupAnagrams(String[] strs) {
+        Map<String, List<String>> anagramGroups = new HashMap<>();
+
+        for (String str : strs) {
+            // Creat a character array from the string
+            char[] charArray = str.toCharArray();
+
+            // Sort the character array
+            Arrays.sort(charArray);
+
+            // Convert the sorted character array back to a String
+            String sortedStr = new String(charArray);
+
+            // If this sorted string is not already in the map, add it
+            anagramGroups.computeIfAbsent(sortedStr, k -> new ArrayList<>()).add(str);
+        }
+
+        return new ArrayList<>(anagramGroups.values());
+    }
+
+    public static void main(String[] args) {
+        String[] strs = {"eat", "tea", "tan", "ate", "nat", "bat"};
+
+        GroupAnagrams grouper = new GroupAnagrams();
+        List<List<String>> result = grouper.groupAnagrams(strs);
+
+        System.out.println(result); // Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
+    }
+}
diff --git a/src/main/java/Strings/SplitNumbersStrings.java b/src/main/java/Strings/SplitNumbersStrings.java
new file mode 100644
index 0000000..f6d798a
--- /dev/null
+++ b/src/main/java/Strings/SplitNumbersStrings.java
@@ -0,0 +1,26 @@
+package Strings;
+
+public class SplitNumbersStrings {
+
+    public static void splitIntegerString(String input){
+        String[] parts = input.split("-");
+        for (String part : parts) {
+            System.out.print("[" + part + "] ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        String input1 = "JavaLearning-2024";
+        System.out.print("Input: \"JavaLearning-2024\" => Output: ");
+        splitIntegerString(input1);
+
+        String input2 = "Best-Course-Ever";
+        System.out.print("Input: \"Best-Course-Ever\" => Output: ");
+        splitIntegerString(input2);
+
+        String input3 = "NoHyphenHere";
+        System.out.print("Input: \"NoHyphenHere\" => Output: ");
+        splitIntegerString(input3);
+    }
+}
diff --git a/src/main/java/Youtube/MooreAlgo.java b/src/main/java/Youtube/MooreAlgo.java
new file mode 100644
index 0000000..2cbc354
--- /dev/null
+++ b/src/main/java/Youtube/MooreAlgo.java
@@ -0,0 +1,65 @@
+package Youtube;
+
+/**
+ * The question asked in Round 1 of Youtube SDET interview - The interviewer explained Moore's voting algo and
+ * wanted to approach the problem wrt Java code.
+ *
+ * Moores Voting Algorithm is used to find the majority element from a group
+ */
+public class MooreAlgo {
+    public static Integer findMajorityElementinArray(int [] nums){
+        // Initialise the first element as the majority element
+        int majorityEle = nums[0];
+
+        // Give the first majority element a vote count of 1
+        int voteCount = 1;
+
+        // Traverse the array and vote on the majority element
+        for (int i=1;i<nums.length;i++){
+            // if the element is equal to the majority element, then increase the count
+            if(nums[i]==majorityEle){
+                voteCount++;
+            }else{
+                voteCount--;
+                if(voteCount==0){
+                    //if vote count becomes 0 then make the ith element as majority element
+                    majorityEle=nums[i];
+                    voteCount=1;
+                }
+            }
+        }
+
+        // verify that the majority element is indeed a majority element. If the element is > then [n/2], then it is
+        // a majority element
+
+        int count = 0;
+        for (int n : nums){
+            if(n ==majorityEle){
+                count++;
+            }
+        }
+        if(count > nums.length / 2){
+            return majorityEle;
+        }else{
+            return null; // return null in case of no majority element
+        }
+    }
+    public static void main(String [] args){
+        int [] nums = {2,3,2,1,3,2,2,5,7}; // there is no majority element in this array
+        Integer result = findMajorityElementinArray(nums);
+        if(result!=null){
+            System.out.println("Majority element is ====>"+result);
+        }else{
+            System.out.println("Majority element not found");
+        }
+
+        int [] nums1 = {1,1,1,1,2,3,5};
+        Integer result1 = findMajorityElementinArray(nums1);
+        if(result1!=null){
+            System.out.println("Majority element is ====>"+result1);
+        }else{
+            System.out.println("Majority element not found");
+        }
+    }
+
+}
diff --git a/src/main/java/Youtube/RotateLinkedList.java b/src/main/java/Youtube/RotateLinkedList.java
new file mode 100644
index 0000000..a4a8c44
--- /dev/null
+++ b/src/main/java/Youtube/RotateLinkedList.java
@@ -0,0 +1,74 @@
+package Youtube;
+
+import java.util.List;
+
+class ListNode{
+    int val;
+    ListNode next;
+    ListNode(int val){
+        this.val = val;
+        this.next = null;
+    }
+}
+/**
+ * Given the head of a LinkedList, rotate it to the right by K places
+ * head = [1,4,5,7,8,9], k=2 : Output : [8,9,1,4,5,7]
+ * head = [0,1,2], k=4 : Output = [2,0,1]
+ */
+public class RotateLinkedList {
+    public static ListNode rotateRightByKPlaces(ListNode head, int k){
+        if(head == null || head.next == null || k==0){
+            return head;
+        }
+
+        // Get the length of the list
+        ListNode current = head;
+        int length = 1;
+        while(current.next !=null){
+            current = current.next;
+            length++;
+        }
+        current.next = head;
+
+        // After rotation, find new head and tail
+        k = k % length;
+        int newHead = length -k;
+        ListNode newTail  = current;
+        while (newHead --> 0){
+            newTail = newTail.next;
+
+        }
+        ListNode newListHead = newTail.next;
+        newTail.next = null;
+        return  newListHead;
+
+    }
+    private static void printList(ListNode head) {
+        ListNode current = head;
+        while (current != null) {
+            System.out.print(current.val + " ");
+            current = current.next;
+        }
+        System.out.println();
+    }
+    public static void main(String [] args){
+        ListNode head1 = new ListNode(1);
+        head1.next = new ListNode(4);
+        head1.next.next = new ListNode(5);
+        head1.next.next.next = new ListNode(7);
+        head1.next.next.next.next = new ListNode(8);
+        head1.next.next.next.next.next = new ListNode(9);
+        int k1 = 2;
+        ListNode result1 = rotateRightByKPlaces(head1, k1);
+        printList(result1); // Output: [8, 9, 1, 4, 5, 7]
+
+        // Test case 2
+        ListNode head2 = new ListNode(0);
+        head2.next = new ListNode(1);
+        head2.next.next = new ListNode(2);
+        int k2 = 4;
+        ListNode result2 = rotateRightByKPlaces(head2, k2);
+        printList(result2); // Output: [2, 0, 1]
+    }
+
+}
diff --git a/src/main/java/Youtube/indexOfFirstOccurance.java b/src/main/java/Youtube/indexOfFirstOccurance.java
new file mode 100644
index 0000000..225aed5
--- /dev/null
+++ b/src/main/java/Youtube/indexOfFirstOccurance.java
@@ -0,0 +1,8 @@
+package Youtube;
+
+/**
+ * Given two strings x and y, return the index of the first occurence of x in y or
+ * -1 if x is not a part of y
+ */
+public class indexOfFirstOccurance {
+}
diff --git a/src/main/java/partech/longestPalindrome.java b/src/main/java/partech/longestPalindrome.java
index 76bd7b6..4b541aa 100644
--- a/src/main/java/partech/longestPalindrome.java
+++ b/src/main/java/partech/longestPalindrome.java
@@ -7,7 +7,7 @@ public class longestPalindrome {
 
     static String findLongestPalindrome(String str){
 
-        if(str == null || str.length()==0){
+        if(str == null || str.isEmpty()){
             return "";
         }
 
@@ -54,7 +54,7 @@ static boolean isPalin(String st){
     }
 
     public static void main(String [] args){
-        String str = "aab";
+        String str = "cbb";
         System.out.println(findLongestPalindrome(str));
         System.out.println(findLongestSubstring(str));
     }
diff --git a/src/test/java/SampleClass.java b/src/test/java/SampleClass.java
new file mode 100644
index 0000000..8faea9c
--- /dev/null
+++ b/src/test/java/SampleClass.java
@@ -0,0 +1,19 @@
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+
+@Nested
+@Timeout(3)
+public class SampleClass {
+    @Test
+    void thisWillFailInThreeSeconds() throws InterruptedException {
+        Thread.sleep(10_000);
+    }
+
+    @Test
+    @Timeout(6)
+    void thisWillFailInSixSecond() throws InterruptedException {
+        Thread.sleep(10_000);
+    }
+}
diff --git a/target/classes/Arrays/PrintAlternateNumber.class b/target/classes/Arrays/PrintAlternateNumber.class
new file mode 100644
index 0000000..65c46e8
Binary files /dev/null and b/target/classes/Arrays/PrintAlternateNumber.class differ
diff --git a/target/classes/Arrays/commonElementsinArray.class b/target/classes/Arrays/commonElementsinArray.class
new file mode 100644
index 0000000..b24e69e
Binary files /dev/null and b/target/classes/Arrays/commonElementsinArray.class differ
diff --git a/target/classes/Arrays/intersectionofArrays.class b/target/classes/Arrays/intersectionofArrays.class
new file mode 100644
index 0000000..01750b9
Binary files /dev/null and b/target/classes/Arrays/intersectionofArrays.class differ
diff --git a/target/classes/Arrays/rotateAnArraybyNumber.class b/target/classes/Arrays/rotateAnArraybyNumber.class
new file mode 100644
index 0000000..d610dfe
Binary files /dev/null and b/target/classes/Arrays/rotateAnArraybyNumber.class differ
diff --git a/target/classes/BlackRock/balancedString.class b/target/classes/BlackRock/balancedString.class
new file mode 100644
index 0000000..fffbde2
Binary files /dev/null and b/target/classes/BlackRock/balancedString.class differ
diff --git a/target/classes/BlackRock/fizzBuzz.class b/target/classes/BlackRock/fizzBuzz.class
new file mode 100644
index 0000000..b146aaa
Binary files /dev/null and b/target/classes/BlackRock/fizzBuzz.class differ
diff --git a/target/classes/Labs49/compareTwoMapsJava8.class b/target/classes/Labs49/compareTwoMapsJava8.class
new file mode 100644
index 0000000..8684694
Binary files /dev/null and b/target/classes/Labs49/compareTwoMapsJava8.class differ
diff --git a/target/classes/Labs49/employeeClassProblem$1.class b/target/classes/Labs49/employeeClassProblem$1.class
new file mode 100644
index 0000000..7f59655
Binary files /dev/null and b/target/classes/Labs49/employeeClassProblem$1.class differ
diff --git a/target/classes/Labs49/employeeClassProblem$2.class b/target/classes/Labs49/employeeClassProblem$2.class
new file mode 100644
index 0000000..eee5416
Binary files /dev/null and b/target/classes/Labs49/employeeClassProblem$2.class differ
diff --git a/target/classes/Labs49/employeeClassProblem$3.class b/target/classes/Labs49/employeeClassProblem$3.class
new file mode 100644
index 0000000..3266d55
Binary files /dev/null and b/target/classes/Labs49/employeeClassProblem$3.class differ
diff --git a/target/classes/Labs49/employeeClassProblem.class b/target/classes/Labs49/employeeClassProblem.class
new file mode 100644
index 0000000..9c96995
Binary files /dev/null and b/target/classes/Labs49/employeeClassProblem.class differ
diff --git a/target/classes/Search/greaterThanNeigbhour.class b/target/classes/Search/greaterThanNeigbhour.class
new file mode 100644
index 0000000..f21c0cd
Binary files /dev/null and b/target/classes/Search/greaterThanNeigbhour.class differ
diff --git a/target/classes/Strings/ExtractNumberOnly.class b/target/classes/Strings/ExtractNumberOnly.class
new file mode 100644
index 0000000..7175877
Binary files /dev/null and b/target/classes/Strings/ExtractNumberOnly.class differ
diff --git a/target/classes/Strings/SplitNumbersStrings.class b/target/classes/Strings/SplitNumbersStrings.class
new file mode 100644
index 0000000..274d816
Binary files /dev/null and b/target/classes/Strings/SplitNumbersStrings.class differ
diff --git a/target/classes/Strings/findCountOfEmojis.class b/target/classes/Strings/findCountOfEmojis.class
new file mode 100644
index 0000000..a89db51
Binary files /dev/null and b/target/classes/Strings/findCountOfEmojis.class differ
diff --git a/target/classes/Strings/gayatriProblemLinkedin.class b/target/classes/Strings/gayatriProblemLinkedin.class
new file mode 100644
index 0000000..8ac9522
Binary files /dev/null and b/target/classes/Strings/gayatriProblemLinkedin.class differ
diff --git a/target/classes/Strings/longestDistinctSubstring.class b/target/classes/Strings/longestDistinctSubstring.class
new file mode 100644
index 0000000..a845111
Binary files /dev/null and b/target/classes/Strings/longestDistinctSubstring.class differ
diff --git a/target/classes/Strings/printCharsAtEvenPosition.class b/target/classes/Strings/printCharsAtEvenPosition.class
new file mode 100644
index 0000000..caeda6c
Binary files /dev/null and b/target/classes/Strings/printCharsAtEvenPosition.class differ
diff --git a/target/classes/Strings/printSpacesIndex.class b/target/classes/Strings/printSpacesIndex.class
new file mode 100644
index 0000000..9f0f008
Binary files /dev/null and b/target/classes/Strings/printSpacesIndex.class differ
diff --git a/target/classes/Strings/removeUpperCaseCharacters.class b/target/classes/Strings/removeUpperCaseCharacters.class
new file mode 100644
index 0000000..dab23fb
Binary files /dev/null and b/target/classes/Strings/removeUpperCaseCharacters.class differ
diff --git a/target/classes/hub/countCharactersInString.class b/target/classes/hub/countCharactersInString.class
new file mode 100644
index 0000000..d009ff6
Binary files /dev/null and b/target/classes/hub/countCharactersInString.class differ
diff --git a/target/classes/maths/armStrongNumber.class b/target/classes/maths/armStrongNumber.class
new file mode 100644
index 0000000..fc8af2f
Binary files /dev/null and b/target/classes/maths/armStrongNumber.class differ
diff --git a/target/classes/maths/checkNumisPrime.class b/target/classes/maths/checkNumisPrime.class
new file mode 100644
index 0000000..f8874e4
Binary files /dev/null and b/target/classes/maths/checkNumisPrime.class differ
diff --git a/target/classes/maths/checkPalindromNumber.class b/target/classes/maths/checkPalindromNumber.class
new file mode 100644
index 0000000..9bca97f
Binary files /dev/null and b/target/classes/maths/checkPalindromNumber.class differ
diff --git a/target/classes/maths/countEvenOddDigits.class b/target/classes/maths/countEvenOddDigits.class
new file mode 100644
index 0000000..916883a
Binary files /dev/null and b/target/classes/maths/countEvenOddDigits.class differ
diff --git a/target/classes/maths/digitsInANumber.class b/target/classes/maths/digitsInANumber.class
new file mode 100644
index 0000000..1386b95
Binary files /dev/null and b/target/classes/maths/digitsInANumber.class differ
diff --git a/target/classes/maths/factorialOfNumber.class b/target/classes/maths/factorialOfNumber.class
new file mode 100644
index 0000000..2bd3f1e
Binary files /dev/null and b/target/classes/maths/factorialOfNumber.class differ
diff --git a/target/classes/maths/fibonacciSeries.class b/target/classes/maths/fibonacciSeries.class
new file mode 100644
index 0000000..b4ff849
Binary files /dev/null and b/target/classes/maths/fibonacciSeries.class differ
diff --git a/target/classes/maths/findGCD.class b/target/classes/maths/findGCD.class
new file mode 100644
index 0000000..d1bc017
Binary files /dev/null and b/target/classes/maths/findGCD.class differ
diff --git a/target/classes/maths/generateRandom.class b/target/classes/maths/generateRandom.class
new file mode 100644
index 0000000..7303b1f
Binary files /dev/null and b/target/classes/maths/generateRandom.class differ
diff --git a/target/classes/maths/largestofThreeNumbers.class b/target/classes/maths/largestofThreeNumbers.class
new file mode 100644
index 0000000..847c2a9
Binary files /dev/null and b/target/classes/maths/largestofThreeNumbers.class differ
diff --git a/target/classes/maths/longestDoubleDigit.class b/target/classes/maths/longestDoubleDigit.class
new file mode 100644
index 0000000..eba5a51
Binary files /dev/null and b/target/classes/maths/longestDoubleDigit.class differ
diff --git a/target/classes/maths/printNumbersAppearingOnlyOnce.class b/target/classes/maths/printNumbersAppearingOnlyOnce.class
new file mode 100644
index 0000000..47be452
Binary files /dev/null and b/target/classes/maths/printNumbersAppearingOnlyOnce.class differ
diff --git a/target/classes/maths/reverseANumber.class b/target/classes/maths/reverseANumber.class
new file mode 100644
index 0000000..3f09344
Binary files /dev/null and b/target/classes/maths/reverseANumber.class differ
diff --git a/target/classes/maths/strongNumber.class b/target/classes/maths/strongNumber.class
new file mode 100644
index 0000000..2275f00
Binary files /dev/null and b/target/classes/maths/strongNumber.class differ
diff --git a/target/classes/maths/sumOfDigits.class b/target/classes/maths/sumOfDigits.class
new file mode 100644
index 0000000..821b97f
Binary files /dev/null and b/target/classes/maths/sumOfDigits.class differ
diff --git a/target/classes/maths/swapTwoIntswXOR.class b/target/classes/maths/swapTwoIntswXOR.class
new file mode 100644
index 0000000..bb56841
Binary files /dev/null and b/target/classes/maths/swapTwoIntswXOR.class differ
diff --git a/target/classes/maths/swapWithoutThirdVar.class b/target/classes/maths/swapWithoutThirdVar.class
new file mode 100644
index 0000000..02834e9
Binary files /dev/null and b/target/classes/maths/swapWithoutThirdVar.class differ
diff --git a/target/classes/outputs/A.class b/target/classes/outputs/A.class
new file mode 100644
index 0000000..05e2a64
Binary files /dev/null and b/target/classes/outputs/A.class differ
diff --git a/target/classes/outputs/AClass.class b/target/classes/outputs/AClass.class
new file mode 100644
index 0000000..87cb052
Binary files /dev/null and b/target/classes/outputs/AClass.class differ
diff --git a/target/classes/outputs/AInterface.class b/target/classes/outputs/AInterface.class
new file mode 100644
index 0000000..bae18ef
Binary files /dev/null and b/target/classes/outputs/AInterface.class differ
diff --git a/target/classes/outputs/Abase.class b/target/classes/outputs/Abase.class
new file mode 100644
index 0000000..32cd9d3
Binary files /dev/null and b/target/classes/outputs/Abase.class differ
diff --git a/target/classes/outputs/Abase1.class b/target/classes/outputs/Abase1.class
new file mode 100644
index 0000000..4e7459e
Binary files /dev/null and b/target/classes/outputs/Abase1.class differ
diff --git a/target/classes/outputs/Abase2.class b/target/classes/outputs/Abase2.class
new file mode 100644
index 0000000..cc4301d
Binary files /dev/null and b/target/classes/outputs/Abase2.class differ
diff --git a/target/classes/outputs/Aclass2.class b/target/classes/outputs/Aclass2.class
new file mode 100644
index 0000000..7f913ce
Binary files /dev/null and b/target/classes/outputs/Aclass2.class differ
diff --git a/target/classes/outputs/Aclass3.class b/target/classes/outputs/Aclass3.class
new file mode 100644
index 0000000..bf2cadb
Binary files /dev/null and b/target/classes/outputs/Aclass3.class differ
diff --git a/target/classes/outputs/B.class b/target/classes/outputs/B.class
new file mode 100644
index 0000000..bfbcf3b
Binary files /dev/null and b/target/classes/outputs/B.class differ
diff --git a/target/classes/outputs/BaseClass.class b/target/classes/outputs/BaseClass.class
new file mode 100644
index 0000000..1e09a0b
Binary files /dev/null and b/target/classes/outputs/BaseClass.class differ
diff --git a/target/classes/outputs/Bbase.class b/target/classes/outputs/Bbase.class
new file mode 100644
index 0000000..96771d8
Binary files /dev/null and b/target/classes/outputs/Bbase.class differ
diff --git a/target/classes/outputs/Bbase1.class b/target/classes/outputs/Bbase1.class
new file mode 100644
index 0000000..dc8c987
Binary files /dev/null and b/target/classes/outputs/Bbase1.class differ
diff --git a/target/classes/outputs/Bbase2.class b/target/classes/outputs/Bbase2.class
new file mode 100644
index 0000000..2526a1c
Binary files /dev/null and b/target/classes/outputs/Bbase2.class differ
diff --git a/target/classes/outputs/Bclass.class b/target/classes/outputs/Bclass.class
new file mode 100644
index 0000000..191a988
Binary files /dev/null and b/target/classes/outputs/Bclass.class differ
diff --git a/target/classes/outputs/Bclass2.class b/target/classes/outputs/Bclass2.class
new file mode 100644
index 0000000..6b38e88
Binary files /dev/null and b/target/classes/outputs/Bclass2.class differ
diff --git a/target/classes/outputs/Bclass3.class b/target/classes/outputs/Bclass3.class
new file mode 100644
index 0000000..13654cc
Binary files /dev/null and b/target/classes/outputs/Bclass3.class differ
diff --git a/target/classes/outputs/CClass.class b/target/classes/outputs/CClass.class
new file mode 100644
index 0000000..ab7fa22
Binary files /dev/null and b/target/classes/outputs/CClass.class differ
diff --git a/target/classes/outputs/ExtendedB.class b/target/classes/outputs/ExtendedB.class
new file mode 100644
index 0000000..dbf7a44
Binary files /dev/null and b/target/classes/outputs/ExtendedB.class differ
diff --git a/target/classes/outputs/problem1.class b/target/classes/outputs/problem1.class
new file mode 100644
index 0000000..2c71538
Binary files /dev/null and b/target/classes/outputs/problem1.class differ
diff --git a/target/classes/outputs/problem2.class b/target/classes/outputs/problem2.class
new file mode 100644
index 0000000..0cf607f
Binary files /dev/null and b/target/classes/outputs/problem2.class differ
diff --git a/target/classes/outputs/problem3.class b/target/classes/outputs/problem3.class
new file mode 100644
index 0000000..2e9c6b2
Binary files /dev/null and b/target/classes/outputs/problem3.class differ
diff --git a/target/classes/outputs/problem4.class b/target/classes/outputs/problem4.class
new file mode 100644
index 0000000..9951496
Binary files /dev/null and b/target/classes/outputs/problem4.class differ
diff --git a/target/classes/outputs/problem5.class b/target/classes/outputs/problem5.class
new file mode 100644
index 0000000..3c7e4fa
Binary files /dev/null and b/target/classes/outputs/problem5.class differ
diff --git a/target/classes/outputs/problem6.class b/target/classes/outputs/problem6.class
new file mode 100644
index 0000000..efbe7de
Binary files /dev/null and b/target/classes/outputs/problem6.class differ
diff --git a/target/classes/outputs/problem7.class b/target/classes/outputs/problem7.class
new file mode 100644
index 0000000..30416b8
Binary files /dev/null and b/target/classes/outputs/problem7.class differ
diff --git a/target/classes/outputs/problem8.class b/target/classes/outputs/problem8.class
new file mode 100644
index 0000000..1387c48
Binary files /dev/null and b/target/classes/outputs/problem8.class differ
diff --git a/target/classes/partech/longestPalindrome.class b/target/classes/partech/longestPalindrome.class
new file mode 100644
index 0000000..eac6532
Binary files /dev/null and b/target/classes/partech/longestPalindrome.class differ
diff --git a/target/classes/saaslabs/findKthLargest.class b/target/classes/saaslabs/findKthLargest.class
new file mode 100644
index 0000000..4f8a801
Binary files /dev/null and b/target/classes/saaslabs/findKthLargest.class differ
diff --git a/target/classes/saaslabs/triangleProblem.class b/target/classes/saaslabs/triangleProblem.class
new file mode 100644
index 0000000..d640616
Binary files /dev/null and b/target/classes/saaslabs/triangleProblem.class differ
diff --git a/target/test-classes/Others/SerializeAndDeserialize.class b/target/test-classes/Others/SerializeAndDeserialize.class
new file mode 100644
index 0000000..1308827
Binary files /dev/null and b/target/test-classes/Others/SerializeAndDeserialize.class differ
diff --git a/target/test-classes/SampleClass.class b/target/test-classes/SampleClass.class
new file mode 100644
index 0000000..9cd6088
Binary files /dev/null and b/target/test-classes/SampleClass.class differ