diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index d541fb7..0000000
--- a/.gitignore
+++ /dev/null
@@ -1,133 +0,0 @@
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-lerna-debug.log*
-.pnpm-debug.log*
-
-#Tempcoderunner
-tempCodeRunnerFile.js
-
-# Diagnostic reports (https://nodejs.org/api/report.html)
-report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
-
-# Runtime data
-pids
-*.pid
-*.seed
-*.pid.lock
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
-
-# Coverage directory used by tools like istanbul
-coverage
-*.lcov
-
-# nyc test coverage
-.nyc_output
-
-# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# Bower dependency directory (https://bower.io/)
-bower_components
-
-# node-waf configuration
-.lock-wscript
-
-# Compiled binary addons (https://nodejs.org/api/addons.html)
-build/Release
-
-# Dependency directories
-node_modules/
-jspm_packages/
-
-# Snowpack dependency directory (https://snowpack.dev/)
-web_modules/
-
-# TypeScript cache
-*.tsbuildinfo
-
-# Optional npm cache directory
-.npm
-
-# Optional eslint cache
-.eslintcache
-
-# Optional stylelint cache
-.stylelintcache
-
-# Microbundle cache
-.rpt2_cache/
-.rts2_cache_cjs/
-.rts2_cache_es/
-.rts2_cache_umd/
-
-# Optional REPL history
-.node_repl_history
-
-# Output of 'npm pack'
-*.tgz
-
-# Yarn Integrity file
-.yarn-integrity
-
-# dotenv environment variable files
-.env
-.env.development.local
-.env.test.local
-.env.production.local
-.env.local
-
-# parcel-bundler cache (https://parceljs.org/)
-.cache
-.parcel-cache
-
-# Next.js build output
-.next
-out
-
-# Nuxt.js build / generate output
-.nuxt
-dist
-
-# Gatsby files
-.cache/
-# Comment in the public line in if your project uses Gatsby and not Next.js
-# https://nextjs.org/blog/next-9-1#public-directory-support
-# public
-
-# vuepress build output
-.vuepress/dist
-
-# vuepress v2.x temp and cache directory
-.temp
-.cache
-
-# Docusaurus cache and generated files
-.docusaurus
-
-# Serverless directories
-.serverless/
-
-# FuseBox cache
-.fusebox/
-
-# DynamoDB Local files
-.dynamodb/
-
-# TernJS port file
-.tern-port
-
-# Stores VSCode versions used for testing VSCode extensions
-.vscode-test
-
-# yarn v2
-.yarn/cache
-.yarn/unplugged
-.yarn/build-state.yml
-.yarn/install-state.gz
-.pnp.*
diff --git a/.vscode/settings.json b/.vscode/settings.json
index b3f0b37..81be708 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,3 +1,6 @@
 {
-  "cSpell.words": ["duplicateelements"]
+  "cSpell.words": [
+    "Namaste",
+    "Uttrakhand"
+  ]
 }
diff --git a/Arrays/10ShuffleArrRandom.js b/Arrays/10ShuffleArrRandom.js
deleted file mode 100644
index 07667d5..0000000
--- a/Arrays/10ShuffleArrRandom.js
+++ /dev/null
@@ -1,38 +0,0 @@
-// 10. **Implement a function to shuffle an array randomly.**
-
-/*Shuffling an Array:
-
-Definition:
-
-Shuffling an array involves randomly rearranging the order of its elements to create a random permutation.
-Algorithm: Fisher-Yates Shuffle
-
-Iterates through the array from the end to the beginning.
-At each step, swaps the current element with a randomly chosen element that precedes it.
-Purpose:
-
-Introduces randomness and unpredictability to the order of elements in the array.
-Applications:
-
-Commonly used in games for randomizing elements.
-Useful in statistical experiments.
-Ensures fairness in algorithms or applications requiring randomization. */
-
-function shuffleArray(arr) {
-    // Create a copy to avoid modifying the original array
-    let shuffledArray = arr;
-    for (let i = shuffledArray.length - 1; i > 0; i--) {
-        // Pick a random index from 0 to i inclusive
-        let j = Math.floor(Math.random() * (i + 1));
-
-        // Swap arr[i] with the element
-        // at random index
-        [shuffledArray[i], shuffledArray[j]] = [shuffledArray[j], shuffledArray[i]];
-    }
-    return shuffledArray;
-}
-
-// Example usage:
-const originalArray = [1, 2, 3, 4, 5];
-const shuffledResult = shuffleArray(originalArray);
-console.log(shuffledResult);
diff --git a/Arrays/11FindDuplicate.js b/Arrays/11FindDuplicate.js
deleted file mode 100644
index 61a23f7..0000000
--- a/Arrays/11FindDuplicate.js
+++ /dev/null
@@ -1,28 +0,0 @@
-// 11. ** Determine if there are any duplicate elements in an array.**
-
-const findDuplicatesInArray = (arr) => {
-    let elementsCount = {};
-    let duplicateElements = [];
-    for (let i = 0; i < arr.length; i++) {
-        if (elementsCount[arr[i]]) {
-            elementsCount[arr[i]] += 1;
-        } else {
-            elementsCount[arr[i]] = 1;
-        }
-    }
-
-    for (const key in elementsCount) {
-        if (elementsCount[key] > 1) {
-            duplicateElements.push(Number(key));
-            console.log();
-        }
-    }
-
-    return (duplicateElements);
-};
-
-const inputArray = [1, 2, 3, 2, 1, 5, 0, 6, 0];
-console.log("Array has duplicates:", findDuplicatesInArray(inputArray));
-
-const arrayWithOutDuplicates = [1, 2, 3, 4, 5];
-console.log("Array has duplicates:", findDuplicatesInArray(arrayWithOutDuplicates)); 
\ No newline at end of file
diff --git a/Arrays/11InterSectionOfArray.js b/Arrays/11InterSectionOfArray.js
deleted file mode 100644
index 7102286..0000000
--- a/Arrays/11InterSectionOfArray.js
+++ /dev/null
@@ -1,30 +0,0 @@
-// 12. **Find the intersection of two arrays.**
-
-
-function findIntersection(arr1, arr2) {
-    let intersection = [];
-    let i = 0, j = 0;
-
-    // Sorting arrays (if not already sorted)
-    arr1.sort((a, b) => a - b);
-    arr2.sort((a, b) => a - b);
-
-    while (i < arr1.length && j < arr2.length) {
-        if (arr1[i] === arr2[j]) {
-            intersection.push(arr1[i]);
-            i++;
-            j++;
-        } else if (arr1[i] < arr2[j]) {
-            i++;
-        } else {
-            j++;
-        }
-    }
-
-    return intersection;
-}
-
-// Example usage:
-const arr1 = [1, 3, 4, 6, 5, 2, 7];
-const arr2 = [2, 3, 5, 7];
-console.log("Intersection:", findIntersection(arr1, arr2));
diff --git a/Arrays/13.LinerSearch.js b/Arrays/13.LinerSearch.js
deleted file mode 100644
index 5eaacd6..0000000
--- a/Arrays/13.LinerSearch.js
+++ /dev/null
@@ -1,17 +0,0 @@
-// 13. **Implement a simple linear search in an array.**
-
-
-
-const linerSearchInArray = (arr, n) => {
-    for (let i = 0; i < arr.length; i++) {
-        if (n === arr[i]) {
-            return `The Element ${n} exists in the array at index ${i}`;
-        }
-    }
-    return `The Element ${n} does not exist in the given array.`;
-}
-
-let element = 8;
-const inputArray = [1, 2, 5, 3, 4, 6, 7, 8];
-const result = linerSearchInArray(inputArray, element);
-console.log(result);
diff --git a/Arrays/14.AvergaeOfElements.js b/Arrays/14.AvergaeOfElements.js
deleted file mode 100644
index 75a55b0..0000000
--- a/Arrays/14.AvergaeOfElements.js
+++ /dev/null
@@ -1,21 +0,0 @@
-// 14. **Calculate the average of elements in an array.**
-
-
-const averageOfElements = ((arr) => {
-    let avg = 0;
-    let n = arr.length;
-    let sum = 0;
-    for (let i = 0; i < arr.length; i++) {
-
-        sum += arr[i]
-    }
-
-    avg = sum / n;
-    return avg;
-
-});
-
-
-const inputArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
-const result = averageOfElements(inputArray);
-console.log(result);
\ No newline at end of file
diff --git a/Arrays/15.SubArrayWithGivenSomeExist.js b/Arrays/15.SubArrayWithGivenSomeExist.js
deleted file mode 100644
index ddcb281..0000000
--- a/Arrays/15.SubArrayWithGivenSomeExist.js
+++ /dev/null
@@ -1,25 +0,0 @@
-// 15. **Check if a subarray with given sum exists.**
-
-function subarrayWithGivenSum(arr, targetSum) {
-    let currentSum = 0;
-    let start = 0;
-
-    for (let i = 0; i < arr.length; i++) {
-        currentSum += arr[i];
-        while (currentSum > targetSum) {
-            currentSum -= arr[start];
-            start++;
-        }
-
-        if (currentSum === targetSum) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-// Example usage:
-const arr = [11, 4, 1, 20, 3, 10, 5];
-const targetSum = 5;
-console.log("Subarray with given sum exists:", subarrayWithGivenSum(arr, targetSum));
diff --git a/Arrays/1MaximuElementInArray.js b/Arrays/1MaximuElementInArray.js
deleted file mode 100644
index 5916d85..0000000
--- a/Arrays/1MaximuElementInArray.js
+++ /dev/null
@@ -1,20 +0,0 @@
-// 1. **Find the maximum element in an array.**
-
-function findMaxElement(arr) {
-    if (arr.length === 0) {
-        return null; // Handle empty array case
-    }
-    let maxElement = arr[0];
-
-    for (const element of arr) {
-        if (element > maxElement) {
-            maxElement = element;
-        }
-    }
-    return maxElement;
-}
-
-// Example usage:
-const myArray = [3, 7, 1, 9, 4, 6];
-const result = findMaxElement(myArray);
-console.log("Maximum element in the array:", result);
diff --git a/Arrays/20.isArrayPalindrome.js b/Arrays/20.isArrayPalindrome.js
deleted file mode 100644
index 7616d6b..0000000
--- a/Arrays/20.isArrayPalindrome.js
+++ /dev/null
@@ -1,22 +0,0 @@
-// 20. **Determine if a given array is a palindrome.**
-
-//palidrome means if we revrese and array it should be same
-
-const checkIsArrayPalindrome = (arr) => {
-    let i = 0;
-    let j = arr.length - 1;
-
-    while (i < j) {
-        if (arr[i] !== arr[j]) {
-            return console.log(`given array ${arr} is not palindrome"`);
-        }
-        i++;
-        j--;
-    }
-    return console.log(`given array ${arr} is palindrome"`);
-};
-
-const inputArray1 = [1, 2, 3, 2, 1];
-const inputArray2 = [1, 2, 3, 2, 1, 0];
-checkIsArrayPalindrome(inputArray1);
-checkIsArrayPalindrome(inputArray2);
diff --git a/Arrays/2SumofElements.js b/Arrays/2SumofElements.js
deleted file mode 100644
index 677372d..0000000
--- a/Arrays/2SumofElements.js
+++ /dev/null
@@ -1,16 +0,0 @@
-// 2. ** Calculate the sum of elements in an array.**
-
-
-const sumOfElemets = ((array) => {
-    let sum = 0;
-    for (const iterator of array) {
-        sum += iterator;
-    }
-
-    return sum;
-
-});
-
-const array = [2, 5, -4, 7, 6]
-const result = sumOfElemets(array);
-console.log("sum of given elements ", result);
\ No newline at end of file
diff --git a/Arrays/2dArrays/flattne2darry.js b/Arrays/2dArrays/flattne2darry.js
deleted file mode 100644
index 2abd686..0000000
--- a/Arrays/2dArrays/flattne2darry.js
+++ /dev/null
@@ -1,17 +0,0 @@
-function flatten2DArray(arr) {
-    let flattened = [];
-    for (let i = 0; i < arr.length; i++) {
-        for (let j = 0; j < arr[i].length; j++) {
-            flattened.push(arr[i][j]);
-        }
-    }
-    return flattened;
-}
-
-const twoDArray = [
-    [1, 2, 3],
-    [4, 5, 6],
-    [7, 8, 9]
-];
-const flattenedArray = flatten2DArray(twoDArray);
-console.log(flattenedArray);
diff --git a/Arrays/2dArrays/initilize2dArr.js b/Arrays/2dArrays/initilize2dArr.js
deleted file mode 100644
index 292c400..0000000
--- a/Arrays/2dArrays/initilize2dArr.js
+++ /dev/null
@@ -1,17 +0,0 @@
-// nitialize a 2D array with zeros
-
-function initialize2DArray(rows, cols) {
-    let array = [];
-    for (let i = 0; i < rows; i++) {
-        array[i] = [];
-        for (let j = 0; j < cols; j++) {
-            array[i][j] = 0;
-        }
-    }
-    return array;
-}
-
-const rows = 4;
-const cols = 4;
-const matrix = initialize2DArray(rows, cols);
-console.log(matrix);
diff --git a/Arrays/2dArrays/product2darr.js b/Arrays/2dArrays/product2darr.js
deleted file mode 100644
index eaff44f..0000000
--- a/Arrays/2dArrays/product2darr.js
+++ /dev/null
@@ -1,26 +0,0 @@
-function matrixProduct(matrix1, matrix2) {
-    let result = [];
-    for (let i = 0; i < matrix1.length; i++) {
-        result[i] = [];
-        for (let j = 0; j < matrix2[0].length; j++) {
-            let sum = 0;
-            for (let k = 0; k < matrix1[0].length; k++) {
-                sum += matrix1[i][k] * matrix2[k][j];
-            }
-            result[i][j] = sum;
-        }
-    }
-    return result;
-}
-
-const matrix1 = [
-    [1, 2, 3],
-    [4, 5, 6]
-];
-const matrix2 = [
-    [7, 8],
-    [9, 10],
-    [11, 12]
-];
-const product = matrixProduct(matrix1, matrix2);
-console.log(product);
diff --git a/Arrays/2dArrays/reverese2daarry.js b/Arrays/2dArrays/reverese2daarry.js
deleted file mode 100644
index 9603391..0000000
--- a/Arrays/2dArrays/reverese2daarry.js
+++ /dev/null
@@ -1,18 +0,0 @@
-function reverse2DArray(arr) {
-    const reversedArray = [];
-    for (let i = 0; i < arr.length; i++) {
-        reversedArray[i] = [];
-        for (let j = arr[i].length - 1; j >= 0; j--) {
-            reversedArray[i].push(arr[i][j]);
-        }
-    }
-    return reversedArray;
-}
-
-const twoDArray = [
-    [1, 2, 3],
-    [4, 5, 6],
-    [7, 8, 9]
-];
-const reversedArray = reverse2DArray(twoDArray);
-console.log(reversedArray);
diff --git a/Arrays/3ReverseArray.js b/Arrays/3ReverseArray.js
deleted file mode 100644
index de3c9a5..0000000
--- a/Arrays/3ReverseArray.js
+++ /dev/null
@@ -1,16 +0,0 @@
-// **Reverse an array.**
-
-
-const reverseGivenArray = ((arr) => {
-    const reverseArray = [];
-    for (let index = arr.length - 1; index > 0; index--) {
-        reverseArray.push(arr[index])
-
-    }
-    return reverseArray;
-})
-
-let arr = [1, 2, 3, 4, 5];
-const result = reverseGivenArray(arr)
-console.log("Actual array ", arr);
-console.log("Reverse Array ", result);
\ No newline at end of file
diff --git a/Arrays/4IsArraySorted.js b/Arrays/4IsArraySorted.js
deleted file mode 100644
index b7e4cd1..0000000
--- a/Arrays/4IsArraySorted.js
+++ /dev/null
@@ -1,20 +0,0 @@
-function isSorted(arr) {
-    const n = arr.length;
-
-    if (n <= 0) {
-        return `${arr} is Emty  array`;
-    }
-
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i] < arr[i - 1]) return `${arr} is not a soted array`;
-    }
-
-    return `${arr} is  a soted array`;
-}
-
-// Example usage:
-const arr1 = [1, 2, 3, 4, 5];
-const arr2 = [5, 2, 8, 1, 3];
-
-console.log(isSorted(arr1)); // Output: true
-console.log(isSorted(arr2)); // Output: false
diff --git a/Arrays/5FindSecoundLargestNum.js b/Arrays/5FindSecoundLargestNum.js
deleted file mode 100644
index b2356a5..0000000
--- a/Arrays/5FindSecoundLargestNum.js
+++ /dev/null
@@ -1,28 +0,0 @@
-// 5. **Find the second largest element in an array.**
-
-function findSecondLargest(arr) {
-    if (arr.length < 2) {
-        return "Array should have at least two elements";
-    }
-
-    let largest = arr[0];
-    let secondLargest = -Infinity;
-
-    for (let i = 1; i < arr.length; i++) {
-        if (arr[i] > largest) {
-            secondLargest = largest;
-            largest = arr[i];
-        } else if (arr[i] > secondLargest) {
-            secondLargest = arr[i];
-        }
-    }
-
-    return secondLargest !== -Infinity
-        ? secondLargest
-        : "There is no second largest element in the array";
-}
-
-// Example usage:
-const array = [8, 4, 7, 1, 9, 3];
-const secondLargest = findSecondLargest(array);
-console.log("Second Largest Element:", secondLargest);
diff --git a/Arrays/6removeDuplicate.js b/Arrays/6removeDuplicate.js
deleted file mode 100644
index 9de387f..0000000
--- a/Arrays/6removeDuplicate.js
+++ /dev/null
@@ -1,20 +0,0 @@
-// 6. **Remove duplicates from an array.**
-
-function removeDuplicates(arr) {
-    const uniqueArray = [];
-
-    for (const element of arr) {
-        if (!uniqueArray.includes(element)) {
-            uniqueArray.push(element);
-        }
-    }
-
-    return uniqueArray;
-}
-
-// Example usage:
-const array = [1, 1, 2, 5, 6, 5, 6];
-const uniqueArray = removeDuplicates(array);
-console.log("Array with duplicates:", array);
-
-console.log("Array without duplicates:", uniqueArray);
diff --git a/Arrays/7CounteElemetFrequescy.js b/Arrays/7CounteElemetFrequescy.js
deleted file mode 100644
index 60bd21f..0000000
--- a/Arrays/7CounteElemetFrequescy.js
+++ /dev/null
@@ -1,18 +0,0 @@
-// 7. **Count the occurrences of a specific element in an array.**
-
-
-const countElelemtyFrequency = (arr) => {
-    let frequency = {};
-
-    for (let i = 0; i < arr.length; i++) {
-        frequency[arr[i]] ?
-            frequency[arr[i]] += 1
-            :
-            frequency[arr[i]] = 1
-    }
-    console.log("frequency", frequency);
-
-}
-
-const inputArray = [1, 2, 1, 0, 1, 2, 1];
-countElelemtyFrequency(inputArray);
diff --git a/Arrays/8MergeTwoSorteArray.js b/Arrays/8MergeTwoSorteArray.js
deleted file mode 100644
index c6d0a08..0000000
--- a/Arrays/8MergeTwoSorteArray.js
+++ /dev/null
@@ -1,37 +0,0 @@
-// Merge two sorted arrays
-
-function mergeSortedArrays(arr1, arr2) {
-    let mergedArray = [];
-    let i = 0;
-    let j = 0;
-
-    while (i < arr1.length && j < arr2.length) {
-        if (arr1[i] < arr2[j]) {
-            mergedArray.push(arr1[i]);
-            i++;
-        } else {
-            mergedArray.push(arr2[j]);
-            j++;
-        }
-    }
-
-    // Push remaining elements of arr1, if any
-    while (i < arr1.length) {
-        mergedArray.push(arr1[i]);
-        i++;
-    }
-
-    // Push remaining elements of arr2, if any
-    while (j < arr2.length) {
-        mergedArray.push(arr2[j]);
-        j++;
-    }
-
-    return mergedArray;
-}
-
-// Example usage:
-const arr1 = [2, 4, 6, 8];
-const arr2 = [1, 3, 5, 7];
-console.log(mergeSortedArrays(arr1, arr2));
-
diff --git a/Arrays/9RotateArrByK-Steps.js b/Arrays/9RotateArrByK-Steps.js
deleted file mode 100644
index 50a9b49..0000000
--- a/Arrays/9RotateArrByK-Steps.js
+++ /dev/null
@@ -1,19 +0,0 @@
-// Rotate an array to the right by k steps.
-// input inputArray = [1,2,3,4,5,6,7];
-// k=3
-// step 1 : if k =1 output = [7,1,2,3,4,5,6]
-// step 2 : if k =2 output = [7,6,1,2,3,4,5]
-// step 3 : if k =3 output = [7,6,5,2,3,4,]
-
-function rotateArray(arr, k) {
-
-    for (let i = 0; i < k; i++) {
-        arr.unshift(arr.pop())
-        console.log(`step ${i + 1}:`, arr);
-    }
-}
-
-
-const k = 10;
-const inputArray = [1, 2, 3, 4, 5, 6, 7];
-// rotateArray(inputArray, k)
\ No newline at end of file
diff --git a/Arrays/ARRAYSproblem.md b/Arrays/ARRAYSproblem.md
deleted file mode 100644
index 75a9bfa..0000000
--- a/Arrays/ARRAYSproblem.md
+++ /dev/null
@@ -1,126 +0,0 @@
-# Data Structures and Algorithms Practice
-
-This repository contains a collection of array-related questions categorized by difficulty level. These questions are designed to help you practice data structures and algorithms concepts, especially related to arrays.
-
-## Table of Contents
-
-1. [Basic](#basic-questions)
-2. [Mid-Level](#mid-level-questions)
-3. [Advanced](#advanced-questions)
-4. [Expert](#expert-questions)
-
-## Basic Questions
-
-1. **Find the maximum element in an array.**
-2. **Calculate the sum of elements in an array.**
-3. **Reverse an array.**
-4. **Check if an array is sorted.**
-5. **Find the second largest element in an array.**
-6. **Remove duplicates from an array.**
-7. **Count the occurrences of a specific element in an array.**
-8. **Merge two sorted arrays.**
-9. **Rotate an array to the right by k steps.**
-10. **Implement a function to shuffle an array randomly.**
-11. **Determine if there are any duplicate elements in an array.**
-12. **Find the intersection of two arrays.**
-13. **Implement a simple linear search in an array.**
-14. **Calculate the average of elements in an array.**
-15. **Check if a subarray with given sum exists.**
-16. **Implement a basic sorting algorithm (e.g., bubble sort).**
-17. **Implement a basic searching algorithm (e.g., linear search).**
-18. **Find the missing number in an array of 1 to N.**
-19. **Move all zeroes to the end of the array.**
-20. **Determine if a given array is a palindrome.**
-21. **Implement a function to rotate a matrix.**
-22. **Rearrange positive and negative numbers in an array.**
-23. **Implement an algorithm to find the majority element.**
-24. **Calculate the product of all elements in an array.**
-25. **Implement a stack using an array.**
-
-## Mid-Level Questions
-
-26. **Implement a binary search in a sorted array.**
-27. **Find the peak element in an array.**
-28. **Determine the minimum window size containing all distinct elements.**
-29. **Implement quicksort on an array.**
-30. **Find the longest increasing subsequence in an array.**
-31. **Search in a rotated sorted array.**
-32. **Implement a priority queue using an array.**
-33. **Implement an algorithm to find the Kth smallest/largest element.**
-34. **Implement a function to perform matrix multiplication.**
-35. **Determine if there are three elements in an array that sum to a specific value.**
-36. **Implement merge sort on an array.**
-37. **Calculate the maximum subarray sum (Kadane's algorithm).**
-38. **Implement a function to generate all possible subsets of an array.**
-39. **Find the equilibrium index of an array.**
-40. **Implement a min heap using an array.**
-41. **Implement counting sort on an array of integers.**
-42. **Determine the longest common subsequence of two arrays.**
-43. **Implement an algorithm to rotate an array by a given pivot.**
-44. **Sort an array of 0s, 1s, and 2s (Dutch National Flag problem).**
-45. **Implement a circular queue using an array.**
-46. **Find the first non-repeating element in an array.**
-47. **Implement an algorithm to find the shortest path in a maze.**
-48. **Determine if an array can be partitioned into two equal sum subarrays.**
-49. **Implement an algorithm to find the next greater element for each element in an array.**
-50. **Perform matrix exponentiation for fast exponentiation.**
-
-## Advanced Questions
-
-51. **Implement an efficient algorithm for matrix transposition.**
-52. **Solve the 3SUM problem in less than O(n^2) time complexity.**
-53. **Implement an algorithm to find the longest palindrome substring.**
-54. **Determine the maximum profit from buying and selling stocks.**
-55. **Implement an algorithm for in-place array rearrangement.**
-56. **Solve the maximum sum rectangle in a 2D matrix problem.**
-57. **Implement an efficient algorithm for finding all pairs with a given sum.**
-58. **Determine the shortest path in a weighted graph using Dijkstra's algorithm.**
-59. **Implement a persistent data structure for arrays.**
-60. **Solve the longest common subarray problem for multiple arrays.**
-61. **Implement an efficient algorithm for counting inversions in an array.**
-62. **Solve the maximum subarray sum using divide and conquer.**
-63. **Implement an algorithm to find the k closest points to the origin in 2D space.**
-64. **Solve the kth element in a matrix sorted row-wise and column-wise.**
-65. **Implement an algorithm for randomized selection in an array.**
-66. **Solve the largest rectangular area in a histogram problem.**
-67. **Implement a cache-conscious matrix transpose algorithm.**
-68. **Solve the largest rectangular area in a histogram problem.**
-69. **Implement an algorithm for finding the majority element in a stream.**
-70. **Solve the minimum swaps required to bring elements less than or equal to k together.**
-71. **Implement an algorithm for finding the longest subarray with at most two distinct elements.**
-72. **Solve the maximum sum increasing subsequence problem.**
-73. **Implement an algorithm for finding the longest increasing subarray.**
-74. **Solve the egg dropping puzzle with minimum attempts.**
-75. **Implement an algorithm for efficient matrix exponentiation.**
-76. **Solve the minimum number of jumps to reach the end of an array.**
-77. **Implement a memory-efficient algorithm for in-place array rotation.**
-78. **Solve the number of paths in a matrix problem.**
-79. **Implement an algorithm for finding the minimum number of platforms required at a railway station.**
-80. **Solve the longest zigzag subsequence problem.**
-
-## Expert Questions
-
-81. **Implement an algorithm for solving the sliding window maximum problem.**
-82. **Solve the edit distance problem for two strings.**
-83. **Implement an efficient algorithm for finding the longest subarray with sum at least k.**
-84. **Solve the maximum profit with at most k transactions in stock market.**
-85. **Implement an algorithm for finding the shortest path in a graph using Floyd-Warshall.**
-86. **Solve the traveling salesman problem using dynamic programming.**
-87. **Implement a persistent data structure for arrays with efficient updates.**
-88. **Solve the maximum sum rectangle in a 2D matrix using Kadane's algorithm.**
-89. **Implement an algorithm for in-place array transformation with O(1) extra space.**
-90. **Solve the number of ways to partition a set into k subsets.**
-91. **Implement an algorithm for counting the number of subarrays with a given XOR.**
-92. **Solve the shortest common supersequence problem.**
-93. **Implement an efficient algorithm for generating random permutations of an array.**
-94. **Solve the maximum subarray sum using segment trees.**
-95. **Implement an algorithm for finding the longest palindromic subsequence.**
-96. **Solve the minimum cost to connect all points in a grid problem.**
-97. **Implement an efficient algorithm for finding the GCD of subarray products.**
-98. **Solve the longest common increasing subsequence problem.**
-99. **Implement an algorithm for finding the number of distinct subsequences.**
-100.  **Solve the maximum length of a bitonic subarray problem.**
-
-These questions cover a wide range of array-related topics and difficulty levels. Feel free to adapt them based on your preferences and the specific requirements of your learning or interview preparation.
-
-Happy coding!
diff --git a/Arrays/UnionOfSortedArrays.js b/Arrays/UnionOfSortedArrays.js
deleted file mode 100644
index 574fe03..0000000
--- a/Arrays/UnionOfSortedArrays.js
+++ /dev/null
@@ -1,45 +0,0 @@
-function findUnion(arr1, arr2) {
-    const union = [];
-    let i = 0;
-    let j = 0;
-
-    // Iterate through both arrays simultaneously
-    while (i < arr1.length && j < arr2.length) {
-        // If the current elements are equal, add one of them to the union and move both pointers
-        if (arr1[i] === arr2[j]) {
-            union.push(arr1[i]);
-            i++;
-            j++;
-        }
-        // If arr1[i] is smaller, add it to the union and move the pointer
-        else if (arr1[i] < arr2[j]) {
-            union.push(arr1[i]);
-            i++;
-        }
-        // If arr2[j] is smaller, add it to the union and move the pointer
-        else {
-            union.push(arr2[j]);
-            j++;
-        }
-    }
-
-    // Add remaining elements from arr1, if any
-    while (i < arr1.length) {
-        union.push(arr1[i]);
-        i++;
-    }
-
-    // Add remaining elements from arr2, if any
-    while (j < arr2.length) {
-        union.push(arr2[j]);
-        j++;
-    }
-
-    return union;
-}
-
-// Example usage:
-const arr1 = [1, 3, 4, 5, 7];
-const arr2 = [2, 3, 5, 6];
-const union = findUnion(arr1, arr2);
-console.log(union); 
diff --git a/Arrays/UniqueValue.js b/Arrays/UniqueValue.js
deleted file mode 100644
index ec2b29f..0000000
--- a/Arrays/UniqueValue.js
+++ /dev/null
@@ -1,26 +0,0 @@
-function countUniqueValues(arr) {
-    // Check if the array is empty
-    if (arr.length === 0) {
-        return 0;
-    }
-
-    // Use two pointers approach
-    let i = 0;
-
-    for (let j = 1; j < arr.length; j++) {
-        // If values at pointers are different, move the first pointer and update the value
-        if (arr[i] !== arr[j]) {
-            i++;
-            arr[i] = arr[j];
-        }
-    }
-
-    // The count of unique values is the index of the first pointer + 1
-    return i + 1;
-}
-
-// Test cases
-console.log(countUniqueValues([1, 1, 1, 1, 1, 2])); // Output: 2
-console.log(countUniqueValues([1, 2, 3, 4, 4, 4, 7, 7, 12, 12, 13])); // Output: 7
-console.log(countUniqueValues([])); // Output: 0
-console.log(countUniqueValues([-2, -1, -1, 0, 1])); // Output: 4
diff --git a/Arrays/tempCodeRunnerFile.js b/Arrays/tempCodeRunnerFile.js
new file mode 100644
index 0000000..b26628a
--- /dev/null
+++ b/Arrays/tempCodeRunnerFile.js
@@ -0,0 +1 @@
+currentSum
\ No newline at end of file
diff --git a/Basic/Factorial.js b/Basic/Factorial.js
deleted file mode 100644
index ee1c89c..0000000
--- a/Basic/Factorial.js
+++ /dev/null
@@ -1,11 +0,0 @@
-const number = 5;
-
-const factorialOfNumber = ((number) => {
-    let factorial = 1; // Initialize factorial to 1
-    for (let index = 1; index <= number; index++) {
-        factorial *= index;
-    }
-    return factorial;
-});
-
-console.log("Factorial of number:", factorialOfNumber(number));
diff --git a/Basic/FibnacciSeries.js b/Basic/FibnacciSeries.js
deleted file mode 100644
index c78111d..0000000
--- a/Basic/FibnacciSeries.js
+++ /dev/null
@@ -1,13 +0,0 @@
-const number = 10; let n1 = 0, n2 = 1, nextTerm;
-
-const printFibonacciSeries = () => {
-    for (let i = 1; i < number; i++) {
-        console.log(n1);
-        nextTerm = n1 + n2;
-        n1 = n2;
-        n2 = nextTerm;
-    }
-};
-
-console.log("Fibonacci Series:", printFibonacciSeries());
-
diff --git a/Basic/SumOf-N-Numbers.js b/Basic/SumOf-N-Numbers.js
deleted file mode 100644
index 3f5e598..0000000
--- a/Basic/SumOf-N-Numbers.js
+++ /dev/null
@@ -1,10 +0,0 @@
-const arr = [12, 12, 68, 0, 9, 3, 9];
-
-let sum = 0; // Initialize a variable to hold the  sum
-
-const cumulativeSum = arr.map((value) => {
-    sum += value;
-    return sum;
-});
-
-console.log("cumulative sum", cumulativeSum);
diff --git a/Basic/TriangleNumber.js b/Basic/TriangleNumber.js
deleted file mode 100644
index e6cf82d..0000000
--- a/Basic/TriangleNumber.js
+++ /dev/null
@@ -1,19 +0,0 @@
-// make stars pattern something like this  :
-// 1
-// 12
-// 123
-// 1234
-
-
-const printSquareStarPatter = ((rows) => {
-
-    for (let i = 0; i < rows; i++) {
-        let pattern = ""
-        for (let j = 1; j <= i; j++) {
-            pattern += `${j}`
-        }
-        console.log(pattern);
-    }
-})
-let i = 10;
-printSquareStarPatter(i)
\ No newline at end of file
diff --git a/BlockScope.js b/BlockScope.js
new file mode 100644
index 0000000..849be44
--- /dev/null
+++ b/BlockScope.js
@@ -0,0 +1,33 @@
+// {
+
+
+
+//     var a = 10;
+//     let b = 20;
+//     const c = 30;
+//     console.log(a);
+//     console.log(b);
+//     console.log(c);
+// }
+
+
+// console.log(a);
+// console.log(b);
+// console.log(c);
+
+// Shadowing 
+// var a = 100;
+let b = 200;
+{
+
+
+
+    var a = 10;
+    let b = 20;
+    const c = 30;
+    console.log(a);
+    console.log(b);
+    console.log(c);
+}
+console.log(b);
+
diff --git a/ClosureQuestion.js b/ClosureQuestion.js
new file mode 100644
index 0000000..ded4023
--- /dev/null
+++ b/ClosureQuestion.js
@@ -0,0 +1,13 @@
+function outset() {
+    var c = 20;
+    function outer(b) {
+        function inner() {
+            console.log(a, b, c);
+        }
+        return inner;
+    }
+    return outer;
+}
+let a = 100;
+var close = outset()("hello world");
+close()
diff --git a/Closures .js b/Closures .js
new file mode 100644
index 0000000..b917486
--- /dev/null
+++ b/Closures .js	
@@ -0,0 +1,13 @@
+function z() {
+    var b = 100;
+    function x() {
+        var a = 7;
+        function y() {
+            console.log(a, b);
+        }
+        y()
+    }
+    x()
+}
+
+z()
\ No newline at end of file
diff --git a/DivideandConquer Dsa/DivideAndConquer.md b/DivideandConquer Dsa/DivideAndConquer.md
deleted file mode 100644
index 23f4f01..0000000
--- a/DivideandConquer Dsa/DivideAndConquer.md	
+++ /dev/null
@@ -1,83 +0,0 @@
-# Divide and Conquer Method
-
-## Introduction
-
-The Divide and Conquer method is an algorithmic paradigm that involves breaking down a problem into smaller, more manageable subproblems. It is widely used in designing efficient algorithms to solve a variety of computational problems.
-
-## Steps of Divide and Conquer
-
-### 1. Divide
-
-- **Description:** Break the problem into smaller subproblems.
-- **Implementation:** Identify the base case or the smallest input for which the solution is known. Divide the problem into two or more smaller instances of the same problem.
-
-### 2. Conquer
-
-- **Description:** Solve the subproblems recursively.
-- **Implementation:** If the subproblems are small enough, solve them directly. Otherwise, apply the same Divide and Conquer approach to each subproblem.
-
-### 3. Combine
-
-- **Description:** Merge the solutions of the subproblems to obtain the solution to the original problem.
-- **Implementation:** Combine the results of the subproblems to construct the final solution. This step often involves straightforward merging or combining strategies.
-
-## Examples of Divide and Conquer Algorithms
-
-### 1. Merge Sort
-
-- **Description:** Sorts an array by dividing it into two halves, recursively sorting each half, and then merging the sorted halves.
-- **Application:** Efficient sorting algorithm with a time complexity of O(n log n).
-
-### 2. QuickSort
-
-- **Description:** Chooses a pivot element, partitions the array into two subarrays, recursively sorts the subarrays, and then combines them.
-- **Application:** Sorting algorithm with an average-case time complexity of O(n log n).
-
-### 3. Binary Search
-
-- **Description:** Searches for a target value in a sorted array by dividing it into halves and eliminating half of the remaining elements at each step.
-- **Application:** Efficient searching algorithm with a time complexity of O(log n).
-
-## Example Problem: Maximum Element in an Array
-
-### Problem Statement
-
-Given an array of numbers, find the maximum element.
-
-### Divide
-
-- Break the array into two halves.
-
-### Conquer
-
-- Recursively find the maximum element in each half.
-
-### Combine
-
-- Compare the maximum elements from the two halves and return the larger one as the overall maximum.
-
-### JavaScript Implementation
-
-```javascript
-function findMax(arr, start, end) {
-  // Base case: when the array has only one element
-  if (start === end) {
-    return arr[start];
-  }
-
-  // Divide: Find the middle index
-  const mid = Math.floor((start + end) / 2);
-
-  // Conquer: Recursively find the maximum in each half
-  const maxLeft = findMax(arr, start, mid);
-  const maxRight = findMax(arr, mid + 1, end);
-
-  // Combine: Compare and return the larger of the two maximums
-  return Math.max(maxLeft, maxRight);
-}
-
-// Example usage
-const array = [3, 7, 1, 9, 5, 2, 8, 4];
-const maxElement = findMax(array, 0, array.length - 1);
-console.log("Maximum element:", maxElement);
-```
diff --git a/DivideandConquer Dsa/FinfMaxArraySum.js b/DivideandConquer Dsa/FinfMaxArraySum.js
deleted file mode 100644
index f1610c6..0000000
--- a/DivideandConquer Dsa/FinfMaxArraySum.js	
+++ /dev/null
@@ -1,16 +0,0 @@
-// : Find the maximum subarray sum
-
-function maxSubarraySum(arr) {
-    let maxSum = arr[0];
-    let currentSum = arr[0];
-
-    for (let i = 1; i < arr.length; i++) {
-        currentSum = Math.max(arr[i], currentSum + arr[i]);
-        maxSum = Math.max(maxSum, currentSum);
-    }
-
-    return maxSum;
-}
-
-const arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4];
-console.log(maxSubarraySum(arr));
diff --git a/DivideandConquer Dsa/findMaximum.js b/DivideandConquer Dsa/findMaximum.js
deleted file mode 100644
index bb505a3..0000000
--- a/DivideandConquer Dsa/findMaximum.js	
+++ /dev/null
@@ -1,19 +0,0 @@
-// Given an array of numbers, find the maximum element.
-
-function findMax(arr, start, end) {
-    if (start === end) {
-        return arr[start];
-    }
-
-    const mid = Math.floor((start + end) / 2);
-
-    const maxLeft = findMax(arr, start, mid);
-    const maxRight = findMax(arr, mid + 1, end);
-
-    return Math.max(maxLeft, maxRight);
-}
-
-// Example usage
-const array = [3, 7, 1, 9, 5, 2, 8, 4];
-const maxElement = findMax(array, 0, array.length - 1);
-console.log("Maximum element:", maxElement);
\ No newline at end of file
diff --git a/DivideandConquer Dsa/mergeSortedArray.js b/DivideandConquer Dsa/mergeSortedArray.js
deleted file mode 100644
index 9923922..0000000
--- a/DivideandConquer Dsa/mergeSortedArray.js	
+++ /dev/null
@@ -1,33 +0,0 @@
-//merged two sorted arrays 
-
-const mergeSortedArrays = (arr1, arr2) => {
-    let mergedArray = [];
-    let i = 0;
-    let j = 0;
-
-    while (i < arr1.length && j < arr2.length) {
-        if (arr1[i] < arr2[j]) {
-            mergedArray.push(arr1[i]);
-            i++;
-        } else {
-            mergedArray.push(arr2[j]);
-            j++;
-        }
-    }
-    while (i < arr1.length) {
-        mergedArray.push(arr1[i]);
-        i++;
-    }
-    while (j < arr2.length) {
-        mergedArray.push(arr2[j]);
-        j++;
-    }
-
-    return mergedArray;
-}
-
-const arr1 = [5, 6, 9, 12];
-const arr2 = [2, 4, 6, 8];
-console.log("array 1", arr1);
-console.log("array 2", arr2);
-console.log("merged sorted array", mergeSortedArrays(arr1, arr2)); 
diff --git a/Filter.js b/Filter.js
new file mode 100644
index 0000000..9e4d759
--- /dev/null
+++ b/Filter.js
@@ -0,0 +1,13 @@
+
+
+// The filter function is used to create a new array containing only the elements of the original array that
+//  satisfy a given condition.
+
+const arr = [-1, 2, -6, 0, 3, 4, 5, 6];
+
+function isOdd(x) {
+    return x % 2 == 0;
+}
+
+const output = arr.filter(isOdd);
+console.log("output", output);
\ No newline at end of file
diff --git a/FirstClassFunction.js b/FirstClassFunction.js
new file mode 100644
index 0000000..1e20422
--- /dev/null
+++ b/FirstClassFunction.js
@@ -0,0 +1,25 @@
+
+// Function Statement   aka function declaration
+
+function funStateMent() {
+    console.log("this is function statement");
+}
+
+// Function Expression
+var fun = function () {
+
+}
+
+    //anonymous declaration
+    (function () {
+
+    })
+
+
+// named Function Expression
+var fun1 = function cc() {
+
+}
+
+
+
diff --git a/FrequencyCounter/Anagram.js b/FrequencyCounter/Anagram.js
deleted file mode 100644
index 674be8d..0000000
--- a/FrequencyCounter/Anagram.js
+++ /dev/null
@@ -1,32 +0,0 @@
-/*An anagram is a word or phrase formed by rearranging the letters of another word or phrase,
-using all the original letters exactly once. Essentially,
- it's a permutation of the letters of a word or phrase to create a new word or phrase.
-
-For example, the word "listen" and "silent" are anagrams of each other because they contain
-the exact same letters.*/
-
-
-
-const checkIsGivenStringAnaGram = (inputString1, inputString12) => {
-    if (inputString1.length !== inputString12.length) {
-        return false; // If the lengths are different, they can't be anagrams
-    }
-    const frequencyCounter = {};
-    // Create frequency counter for str1
-    for (let char of str1) {
-        frequencyCounter[char] = (frequencyCounter[char] || 0) + 1;
-    }
-    // Compare the frequency of each character in both frequency counters
-    for (let char of inputString12) {
-        if (!frequencyCounter[char]) {
-            return false; // If a character is missing or its frequency is 0, they are not anagrams
-        } else {
-            frequencyCounter[char] -= 1; // Decrement the frequency count
-        }
-    }
-    return true; // If all checks pass, the strings are anagrams
-}
-
-console.log(checkIsGivenStringAnaGram("abcd", "dcba")); // Output: true
-console.log(checkIsGivenStringAnaGram("abcd", "abcde")); // Output: false
-console.log(checkIsGivenStringAnaGram("apple", "papel")); // Output: true
diff --git a/FrequencyCounter/ArrayUniqueValue.js b/FrequencyCounter/ArrayUniqueValue.js
deleted file mode 100644
index baac6b2..0000000
--- a/FrequencyCounter/ArrayUniqueValue.js
+++ /dev/null
@@ -1,26 +0,0 @@
-
-// Write a function countFrequency(arr) that takes an array of elements as
-//  input and returns an object representing the frequency of each unique element in the array.
-
-
-function countFrequency(arr) {
-    // Create an empty object to store frequencies
-    const frequencyCounter = {};
-
-    // Loop through the array
-    for (let element of arr) {
-        // If the element is already in the counter, increment its count
-        if (frequencyCounter[element]) {
-            frequencyCounter[element]++;
-        } else {
-            // If the element is not in the counter, add it with a count of 1
-            frequencyCounter[element] = 1;
-        }
-    }
-    // Return the frequency counter object
-    return frequencyCounter;
-}
-
-// Example usage:
-const arr = [1, 2, 3, 4, 1, 2, 2, 3, 4, 5, 5];
-console.log(countFrequency(arr));
diff --git a/FrequencyCounter/FrequencyCounter.md b/FrequencyCounter/FrequencyCounter.md
deleted file mode 100644
index 27188c3..0000000
--- a/FrequencyCounter/FrequencyCounter.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# Frequency Counter Pattern: Use Cases and Guidelines
-
-The frequency counter pattern is a technique used in programming to efficiently solve problems involving the frequency of values or patterns within data structures like arrays, strings, or objects. It involves using objects or maps to collect the frequencies of distinct values or patterns, enabling faster comparison and analysis.
-
-## Use Cases
-
-### 1. Comparing Arrays or Strings
-
-- **Scenario**: Compare two arrays or strings to determine if they have the same elements/characters in different orders or if one is a transformation of the other (e.g., anagrams).
-- **Example Uses**:
-  - Checking if two arrays contain the same elements (ignoring order).
-  - Determining if two strings are anagrams.
-
-### 2. Searching/Filtering
-
-- **Scenario**: Efficiently find duplicates, unique elements, or certain patterns within a collection.
-- **Example Uses**:
-  - Finding duplicate elements in an array.
-  - Counting the frequency of each unique element in an array.
-
-### 3. Optimizing Runtime
-
-- **Scenario**: Improve the efficiency of code by reducing nested loops or avoiding inefficient comparisons.
-- **Example Uses**:
-  - Situations where avoiding nested iterations can improve runtime.
-
-## When to Use
-
-- Use the frequency counter when dealing with collections of data where you need to compare, count occurrences, or search for patterns efficiently.
-- It's helpful for scenarios where you want to avoid nested iterations, making the solution more optimized and improving runtime.
-
-## When to Avoid
-
-- For very small datasets or situations where simplicity and readability of code are more important than optimization, using more straightforward approaches might be preferred.
-- If additional space complexity becomes a concern, as the frequency counter often uses extra space to store frequencies.
-
-### Example
-
-Consider an example of finding if two arrays contain the same elements (ignoring the order). Using the frequency counter pattern:
diff --git a/FrequencyCounter/FrequencyCounterArrayComparison.js b/FrequencyCounter/FrequencyCounterArrayComparison.js
deleted file mode 100644
index e30a06a..0000000
--- a/FrequencyCounter/FrequencyCounterArrayComparison.js
+++ /dev/null
@@ -1,24 +0,0 @@
-const frequencyCountofTwoArray = (array1, array2) => {
-    if (array1.length !== array2.length) {
-        return console.log("Both arrays should be of the same length");
-    }
-
-    let frequencyCounts = {};
-
-    for (const value of array1) {
-        const square = value * value;
-        frequencyCounts[square]
-            ? frequencyCounts[square]++
-            : (frequencyCounts[square] = 1);
-    }
-    console.log("frequencyCounts", frequencyCounts);
-    for (const value of array2) {
-        if (frequencyCounts[value]) frequencyCounts[value]--;
-        else return console.log("false");
-    }
-    console.log("true");
-    console.log("frequencyCounts", frequencyCounts);
-};
-
-frequencyCountofTwoArray([1, 2, 3, 4], [1, 4, 9, 16]);
-
diff --git a/Let&ConstTempoZone.js b/Let&ConstTempoZone.js
new file mode 100644
index 0000000..aab8e5c
--- /dev/null
+++ b/Let&ConstTempoZone.js
@@ -0,0 +1,19 @@
+
+/*Temporal Dead Zone (TDZ):
+let and const have block scope:
+Unlike var, which is function-scoped or globally scoped, let and const are
+ block-scoped. This means they are only accessible within the block, statement, or expression where they are declared.
+Temporal Dead Zone (TDZ):
+When you use let and const, the variables are hoisted to the top of
+ their block, but they remain uninitialized until the actual declaration is 
+ reached in the code. Accessing the variable before the declaration results in a ReferenceError.
+This time between the start of the block and the actual declaration 
+is called the "Temporal Dead Zone" (TDZ). During this period, 
+any attempt to access the variable leads to an error.
+When we try to access the value which we declare with let and const 
+ it hoisted to thor local memory area when we access it so the time when  between initialized undefine to value called temporal dead zone*/
+
+
+console.log(b);
+let a = 10;
+var b = 100;
\ No newline at end of file
diff --git a/Map.js b/Map.js
new file mode 100644
index 0000000..82c8825
--- /dev/null
+++ b/Map.js
@@ -0,0 +1,14 @@
+
+/* The map function is used to transform each element of an array into a new element, based on a given 
+transformation function.
+// It creates a new array with the same length as the original array, where each element is the 
+result of applying the transformation function to the corresponding element of the original array.*/
+
+const arr = [2, 3, 4, 5, 6];
+
+function double(x) {
+    return x * 2;
+}
+
+const output = arr.map(double);
+console.log("output", output);
diff --git a/Maths/ArmstrongNumber.js b/Maths/ArmstrongNumber.js
deleted file mode 100644
index 8cff52d..0000000
--- a/Maths/ArmstrongNumber.js
+++ /dev/null
@@ -1,21 +0,0 @@
-// if n = 371  = 3cube + 7 cube + 1 cube = 371  then number is armstrong number 
-
-
-const isArmStrongNumber = (n) => {
-    let originalNumber = n;
-    let sum = 0;
-
-    while (n > 0) {
-        let digit = n % 10;
-        sum += Math.pow(digit, 3);
-        n = Math.floor(n / 10);
-    }
-
-    if (sum === originalNumber) {
-        console.log(`${originalNumber} is an Armstrong Number.`);
-    } else {
-        console.log(`${originalNumber} is not an Armstrong Number.`);
-    }
-};
-
-isArmStrongNumber(1);
diff --git a/Maths/EuclideanAlgorithm.js b/Maths/EuclideanAlgorithm.js
deleted file mode 100644
index 6101edb..0000000
--- a/Maths/EuclideanAlgorithm.js
+++ /dev/null
@@ -1,25 +0,0 @@
-/*Euclidean Algorithm:
-
-Take two numbers, say a and b.
-Divide the larger number by the smaller one.
-Replace the larger number with the smaller one and the smaller number with the remainder.
-Repeat the process until the remainder is zero.
-The last non-zero remainder is the GCD*/
-
-// gcd(n1,n2)=  gcd(n1-n2,n2)
-
-const GcdByEuclidean = (a, b) => {
-    while (a > 0 && b > 0) {
-        if (a > b) a = a % b;
-        else b = b % a;
-    }
-    if (a == 0) return b;
-    return a;
-};
-
-// Example usage:
-const num1 = 11;
-const num2 = 13;
-const result = GcdByEuclidean(num1, num2);
-
-console.log(`The GCD of ${num1} and ${num2} is: ${result}`);
diff --git a/Maths/GCD.js b/Maths/GCD.js
deleted file mode 100644
index c791f21..0000000
--- a/Maths/GCD.js
+++ /dev/null
@@ -1,20 +0,0 @@
-/*The greatest common divisor (GCD), also known as the greatest common factor (GCF) or highest common
- factor (HCF), is the largest positive integer that divides two or more numbers without leaving a remainder.
-  There are various methods to find the GCD of two or more numbers.*/
-
-
-
-function gcd(a, b) {
-    for (let i = Math.min(a, b); i >= 1; i--) {
-        if (a % i === 0 && b % i == 0) {
-            return i;
-        }
-    }
-}
-
-// Example usage:
-const num1 = 20;
-const num2 = 50;
-const result = gcd(num1, num2);
-
-console.log(`The GCD of ${num1} and ${num2} is: ${result}`);
diff --git a/Maths/NumberOfDigits.js b/Maths/NumberOfDigits.js
deleted file mode 100644
index 4ba1755..0000000
--- a/Maths/NumberOfDigits.js
+++ /dev/null
@@ -1,17 +0,0 @@
-// given a number addEventListener. find out  and return the number of digits in a number
-
-const countsDigits = (n) => {
-    let numberOfDigits = 0;
-
-    while (n > 0) {
-        numberOfDigits = numberOfDigits + 1;
-        n = Math.floor(n / 10); //Math.floor is a JavaScript function that rounds a number down to the nearest integer.
-    }
-
-    return numberOfDigits;
-};
-
-const result = countsDigits(7789);
-console.log("result", result);
-
-// time complexity  O(log10(n))
diff --git a/Maths/PalindromeNumber.js b/Maths/PalindromeNumber.js
deleted file mode 100644
index 6c96c5d..0000000
--- a/Maths/PalindromeNumber.js
+++ /dev/null
@@ -1,19 +0,0 @@
-// palindrome of  number
-
-const reverseDigits = (n) => {
-    let reverseOfDigits = "";
-    let checkForPalindrome = n;
-
-    while (checkForPalindrome > 0) {
-        reverseOfDigits += checkForPalindrome % 10;
-        checkForPalindrome = Math.floor(checkForPalindrome / 10);
-    }
-
-    if (reverseOfDigits === n.toString()) {
-        console.log(`${n} is Palindrome.`);
-    } else {
-        console.log(`${n} is not Palindrome.`);
-    }
-};
-
-const result = reverseDigits(121);
diff --git a/Maths/PrintAllDevision.js b/Maths/PrintAllDevision.js
deleted file mode 100644
index f5f4c76..0000000
--- a/Maths/PrintAllDevision.js
+++ /dev/null
@@ -1,11 +0,0 @@
-// if number complete divide but reminder should be zero
-
-const printAllDivisor = (n) => {
-    for (let i = 1; i <= n; i++) {
-        if (n % i === 0) {
-            console.log(i);
-        }
-    }
-};
-
-printAllDivisor(60);
diff --git a/Maths/ReverseNumber.js b/Maths/ReverseNumber.js
deleted file mode 100644
index 2c2fcb0..0000000
--- a/Maths/ReverseNumber.js
+++ /dev/null
@@ -1,20 +0,0 @@
-
-// reverse number 
-
-
-const reverseDigits = (x) => {
-    let rev = 0;
-    const sign = x < 0 ? -1 : 1;
-    x = Math.abs(x);
-    while (x !== 0) {
-        const digit = x % 10;
-        rev = rev * 10 + digit;
-        x = Math.floor(x / 10);
-    }
-    const result = sign * rev;
-    if (result > 2 ** 31 - 1 || result < -(2 ** 31)) return 0;
-    return result;
-};
-
-const result = reverseDigits(666976541230);
-console.log("result : ", result);
\ No newline at end of file
diff --git a/Maths/intersection.js b/Maths/intersection.js
deleted file mode 100644
index d4bc692..0000000
--- a/Maths/intersection.js
+++ /dev/null
@@ -1,33 +0,0 @@
-//   find unique and command array in two gien arraty
-
-
-function intersection(arr1, arr2) {
-    // Sort the arrays (if they are not already sorted)
-    arr1.sort((a, b) => a - b);
-    arr2.sort((a, b) => a - b);
-
-    const result = [];
-    let i = 0;
-    let j = 0;
-
-    while (i < arr1.length && j < arr2.length) {
-        if (arr1[i] < arr2[j]) {
-            i++;
-        } if (arr1[i] > arr2[j]) {
-            j++;
-        }
-        else {
-            result.push(arr1[i]);
-            i++;
-            j++;
-        }
-    }
-
-    return result;
-}
-
-
-const arr1 = [1, 5, 7, 6, 7, 4, 6, 9, 3];
-const arr2 = [5, 4, 0, 88, 3, 6, 2, 4, 1]
-const result = intersection(arr1, arr2);
-console.log("result", result)
\ No newline at end of file
diff --git a/Maths/isPrimse.js b/Maths/isPrimse.js
deleted file mode 100644
index 7658e2f..0000000
--- a/Maths/isPrimse.js
+++ /dev/null
@@ -1,23 +0,0 @@
-
-/*A prime number is a natural number greater than 1 that is not a product of two smaller 
-natural numbers. In other words, a prime number is a positive integer greater than 1 that has
- no positive divisors other than 1 and itself.*/
-
-
-function isPrime(number) {
-    if (number <= 1) {
-        console.log(`${yourNumber} is not a prime number.`);
-    }
-    for (let i = 2; i <= Math.sqrt(number); i++) {
-        if (number % i === 0) {
-            console.log(`${yourNumber} is not a prime number.`);
-        }
-    }
-
-    console.log(`${yourNumber} is a prime number.`);
-}
-
-// Example: Check if a number is prime
-const n = 17;
-isPrime(n)
-
diff --git a/Maths/unionoftwoarrays.js b/Maths/unionoftwoarrays.js
deleted file mode 100644
index 56dc512..0000000
--- a/Maths/unionoftwoarrays.js
+++ /dev/null
@@ -1,33 +0,0 @@
-//union of two arrays in js
-function mergeArrays(arr1, arr2) {
-    let pointer1 = 0;
-    let pointer2 = 0;
-    const merged = [];
-
-    while (pointer1 < arr1.length && pointer2 < arr2.length) {
-        if (arr1[pointer1] <= arr2[pointer2]) {
-            merged.push(arr1[pointer1]);
-            pointer1++;
-        } else {
-            merged.push(arr2[pointer2]);
-            pointer2++;
-        }
-    }
-
-    while (pointer1 < arr1.length) {
-        merged.push(arr1[pointer1]);
-        pointer1++;
-    }
-
-    while (pointer2 < arr2.length) {
-        merged.push(arr2[pointer2]);
-        pointer2++;
-    }
-
-    return merged;
-}
-
-// Example usage
-const arr1 = [1, 3, 5, 7];
-const arr2 = [2, 4, 6, 8, 3, 3];
-console.log(mergeArrays(arr1, arr2)); 
diff --git a/Oops.js b/Oops.js
new file mode 100644
index 0000000..e69de29
diff --git a/Patterns/QuareStars.js b/Patterns/QuareStars.js
deleted file mode 100644
index 91bcb99..0000000
--- a/Patterns/QuareStars.js
+++ /dev/null
@@ -1,18 +0,0 @@
-// make stars pattern something like this  :
-// ****
-// ****
-// ****
-// ****
-
-const printSquareStarPatter = ((rows) => {
-
-    for (let i = 0; i < rows; i++) {
-        let pattern = '';
-        for (let j = 0; j < 5; j++) {
-            pattern += '* ';
-        }
-        console.log(pattern);
-    }
-})
-let i = 5;
-printSquareStarPatter(i)
\ No newline at end of file
diff --git a/Patterns/ReversPattern.js b/Patterns/ReversPattern.js
deleted file mode 100644
index e7ae157..0000000
--- a/Patterns/ReversPattern.js
+++ /dev/null
@@ -1,162 +0,0 @@
-// *****
-// ****
-// ***
-// **
-// *
-
-const pattern1 = (n) => {
-    for (let i = 0; i < n; i++) {
-        let pattern = "";
-        for (let j = 0; j < n - i + 1; j++) {
-            pattern += "*";
-        }
-        console.log(pattern);
-    }
-};
-
-// pattern1(5);
-
-const pattern2 = (n) => {
-    for (let i = 1; i <= n; i++) {
-        let pattern = "";
-        for (let j = 1; j <= n - i + 1; j++) {
-            pattern += j;
-        }
-        console.log(pattern);
-    }
-};
-
-// pattern2(5);
-
-const pattern3 = (n) => {
-    for (let i = 0; i < n; i++) {
-        let pattern = "";
-
-        // Add spaces before the asterisks
-        for (let j = 0; j < n - i - 1; j++) {
-            pattern += " ";
-        }
-
-        // Add asterisks
-        for (let j = 0; j < 2 * i + 1; j++) {
-            pattern += "*";
-        }
-
-        // Add spaces after the asterisks
-        for (let j = 0; j < n - i - 1; j++) {
-            pattern += " ";
-        }
-
-        console.log(pattern);
-    }
-};
-
-// pattern3(5);
-
-const pattern4 = (n) => {
-    for (let i = 0; i < n; i++) {
-        let pattern = "";
-
-        // Add spaces before the asterisks
-        for (let j = 0; j < i; j++) {
-            pattern += " ";
-        }
-
-        // Add asterisks
-        for (let j = 0; j < 2 * (n - i) - 1; j++) {
-            pattern += "*";
-        }
-
-        // Add spaces after the asterisks
-        for (let j = 0; j < i; j++) {
-            pattern += " ";
-        }
-
-        console.log(pattern);
-    }
-};
-
-// pattern4(5);
-// *********
-// *******
-//  *****
-//   ***
-//    *
-const pattern5 = (n) => {
-    for (let i = 0; i < n; i++) {
-        let pattern = "";
-
-        // Add spaces before the asterisks
-        for (let j = 0; j < n - i - 1; j++) {
-            pattern += " ";
-        }
-
-        // Add asterisks
-        for (let j = 0; j < 2 * i + 1; j++) {
-            pattern += "*";
-        }
-
-        // Add spaces after the asterisks
-        for (let j = 0; j < n - i - 1; j++) {
-            pattern += " ";
-        }
-
-        console.log(pattern);
-    }
-    for (let i = 0; i < n; i++) {
-        let pattern = "";
-
-        // Add spaces before the asterisks
-        for (let j = 0; j < i; j++) {
-            pattern += " ";
-        }
-
-        // Add asterisks
-        for (let j = 0; j < 2 * (n - i) - 1; j++) {
-            pattern += "*";
-        }
-
-        // Add spaces after the asterisks
-        for (let j = 0; j < i; j++) {
-            pattern += " ";
-        }
-
-        console.log(pattern);
-    }
-};
-
-// pattern5(6);
-
-const pattern6 = (n) => {
-    for (let i = 0; i < n; i++) {
-        let pattern = "";
-        let start = 1;
-        if (i % 2 === 0) {
-            start = 1;
-        } else {
-            start = 0;
-        }
-        for (let j = 0; j < i; j++) {
-            pattern += start;
-            start = 1 - start;
-        }
-        console.log(pattern);
-    }
-};
-
-// pattern6(6);
-
-const pattern7 = (n) => {
-    let num = 1;
-
-    for (let i = 1; i <= n; i++) {
-        let pattern = "";
-        for (let j = 1; j <= i; j++) {
-            pattern += num + " ";
-            num++;
-        }
-        console.log(pattern);
-    }
-};
-
-pattern7(6);
diff --git a/Patterns/Triangle1.js b/Patterns/Triangle1.js
deleted file mode 100644
index 47c429e..0000000
--- a/Patterns/Triangle1.js
+++ /dev/null
@@ -1,18 +0,0 @@
-// make stars pattern something like this  :
-// *
-// **
-// ***
-// ****
-
-const printSquareStarPatter = ((rows) => {
-
-    for (let i = 0; i < rows; i++) {
-        let pattern = '';
-        for (let j = 0; j < i; j++) {
-            pattern += '* ';
-        }
-        console.log(pattern);
-    }
-})
-let i = 10;
-printSquareStarPatter(i)
\ No newline at end of file
diff --git a/Patterns/nqueen.js b/Patterns/nqueen.js
deleted file mode 100644
index f88806a..0000000
--- a/Patterns/nqueen.js
+++ /dev/null
@@ -1,46 +0,0 @@
-const solveNQueens = (n) => {
-    const result = [];
-    const board = Array.from({ length: n }, () => Array.from({ length: n }, () => '.'));
-
-    function isSafe(row, col) {
-        // Check if there is a queen in the same column
-        for (let i = 0; i < row; i++) {
-            if (board[i][col] === 'Q') return false;
-        }
-
-        // Check upper left diagonal
-        for (let i = row, j = col; i >= 0 && j >= 0; i--, j--) {
-            if (board[i][j] === 'Q') return false;
-        }
-
-        // Check upper right diagonal
-        for (let i = row, j = col; i >= 0 && j < n; i--, j++) {
-            if (board[i][j] === 'Q') return false;
-        }
-
-        return true;
-    }
-
-    function solve(row) {
-        if (row === n) {
-            const solution = board.map(row => row.join(''));
-            result.push(solution);
-            return;
-        }
-
-        for (let col = 0; col < n; col++) {
-            if (isSafe(row, col)) {
-                board[row][col] = 'Q';
-                solve(row + 1);
-                board[row][col] = '.';
-            }
-        }
-    }
-
-    solve(0);
-    return result;
-}
-
-const n = 4;
-const solutions = solveNQueens(n);
-console.log(`Solutions for ${n} queens:`, solutions);
diff --git a/Practies/ArmStrongNum.js b/Practies/ArmStrongNum.js
deleted file mode 100644
index 6229da4..0000000
--- a/Practies/ArmStrongNum.js
+++ /dev/null
@@ -1,25 +0,0 @@
-//  if n = 371  then if 3qb +7qb+1qb  =371 then armstrong  nums
-
-function isArmStrong(num) {
-    let sum = 0;
-    let n = num;
-    while (n > 0) {
-        let digit = n % 10;
-        sum += Math.pow(digit, 3);
-        n = Math.floor(n / 10);
-
-    }
-    if (num === sum) {
-        return `${num} is armStrong number`;
-    }
-    else {
-        return `${num} is not armStrong number`;
-    }
-
-}
-
-
-const n = 372;
-const result = isArmStrong(n);
-console.log(result);
-
diff --git a/Practies/CountChartInString.js b/Practies/CountChartInString.js
deleted file mode 100644
index a19c9b8..0000000
--- a/Practies/CountChartInString.js
+++ /dev/null
@@ -1,21 +0,0 @@
-function charCount(str) {
-    let countObject = {};
-
-    if (typeof str !== "string") {
-        return console.log("Given input is not a valid string");
-    }
-
-    let charCountString = str.replace(/[^a-zA-Z]/g, "").toLowerCase();
-
-    for (let i = 0; i < charCountString.length; i++) {
-        let char = charCountString[i];
-        if (countObject[char]) {
-            countObject[char] = +1;
-        } else {
-            countObject[char] = 1;
-        }
-    }
-    console.log("countObject", countObject);
-}
-
-charCount("Suman   Singh is a software engineer");
diff --git a/Practies/FibnacciSeries.js b/Practies/FibnacciSeries.js
deleted file mode 100644
index bf5c72d..0000000
--- a/Practies/FibnacciSeries.js
+++ /dev/null
@@ -1,13 +0,0 @@
-
-function generateFibonacci(n) {
-    let fibSeries = [0, 1];
-
-    for (let i = 2; i < n; i++) {
-        fibSeries[i] = fibSeries[i - 1] + fibSeries[i - 2];
-    }
-
-    return fibSeries;
-}
-
-// Example: Generate the first 10 Fibonacci numbers
-console.log(generateFibonacci(10));
diff --git a/Practies/FrequencyCounter.js b/Practies/FrequencyCounter.js
deleted file mode 100644
index ee556d7..0000000
--- a/Practies/FrequencyCounter.js
+++ /dev/null
@@ -1,34 +0,0 @@
-const frequencyCount = (arr1, arr2) => {
-    if (arr1.length !== arr2.length) {
-        console.log("Arrays have different lengths. Cannot compare.");
-        return;
-    }
-
-    const squaredMap = {}; // Store the frequency of squares of elements in arr1
-
-    // Count the frequency of squares of elements in arr1
-    for (let i = 0; i < arr1.length; i++) {
-        const square = arr1[i] * arr1[i];
-        if (squaredMap[square]) {
-            squaredMap[square]++;
-        } else {
-            squaredMap[square] = 1;
-        }
-    }
-    console.log("squaredMap", squaredMap);
-    // Check if elements in arr2 are squares of elements in arr1
-    for (let i = 0; i < arr2.length; i++) {
-        if (squaredMap[arr2[i]]) {
-            squaredMap[arr2[i]]--;
-        } else {
-            console.log("squaredMap", squaredMap);
-            console.log("false");
-            return;
-        }
-    }
-    console.log("squaredMap", squaredMap);
-    console.log("true");
-};
-
-// Test the function
-frequencyCount([1, 2, 3, 4], [1, 4, 5, 16]); // Output: true
diff --git a/Practies/PermutationOfpalindrome.js b/Practies/PermutationOfpalindrome.js
deleted file mode 100644
index 0b73f66..0000000
--- a/Practies/PermutationOfpalindrome.js
+++ /dev/null
@@ -1,28 +0,0 @@
-
-// Given a string, write a function to check if it is a permutation of a palindrome.
-// A palindrome is a word or phrase that is the same forwards and backwards.
-//  A permutation is a rearrangement of letters.
-//  The palindrome does not need to be limited to just dictionary words.
-
-function isPermutationOfPalindrome(str) {
-    str = str.replace(/ /g, '').toLowerCase();
-    let charCount = {};
-    for (let char of str) {
-        charCount[char] = (charCount[char] || 0) + 1;
-    }
-    let oddCount = 0;
-
-    for (let count of Object.values(charCount)) {
-        if (count % 2 !== 0) {
-            oddCount++;
-            if (oddCount > 1) {
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
-console.log(isPermutationOfPalindrome("Tact Coa"));
-console.log(isPermutationOfPalindrome("hello")); 
diff --git a/Practies/ReverseStringWords.js b/Practies/ReverseStringWords.js
deleted file mode 100644
index 29ecf5b..0000000
--- a/Practies/ReverseStringWords.js
+++ /dev/null
@@ -1,14 +0,0 @@
-
-const reverseWordsInString = ((str) => {
-    let newStr = str.split(' ');
-    let result = "";
-    for (let i = newStr.length - 1; i >= 0; i--) {
-        result += `${newStr[i]} `;
-    }
-    return result;
-})
-
-const inputString = "This is a java Program";
-const result = reverseWordsInString(inputString)
-console.log("result", result);
-//Program java a is This
\ No newline at end of file
diff --git a/Practies/TwoSoredArray.js b/Practies/TwoSoredArray.js
deleted file mode 100644
index 105a81d..0000000
--- a/Practies/TwoSoredArray.js
+++ /dev/null
@@ -1,35 +0,0 @@
-// mere two sorted array and make new sorted array
-
-
-
-const mergingTwoSortedArray = (sortedArray1, sortedArray2) => {
-
-    let mergedArray = [];
-    let i = 0;
-    let j = 0;
-    while (i < sortedArray1.length && j < sortedArray2.length) {
-        if (sortedArray1[i] < sortedArray2[j]) {
-            mergedArray.push(sortedArray1[i])
-            i++;
-        }
-        else {
-            mergedArray.push(sortedArray2[j]);
-            j++;
-        }
-    }
-    while (i < sortedArray1.length) {
-        mergedArray.push(sortedArray1[i])
-        i++;
-    }
-    while (j < sortedArray2.length) {
-        mergedArray.push(sortedArray2[j])
-        j++
-    }
-    return mergedArray;
-}
-
-const sortedArray1 = [1,5,6,8,10,12];
-const sortedArray2 = [0,2,3,5,7];
-
-const result = mergingTwoSortedArray(sortedArray1,sortedArray2);
-console.log("result",result);
diff --git a/Practies/armstrong.js b/Practies/armstrong.js
deleted file mode 100644
index 8cff52d..0000000
--- a/Practies/armstrong.js
+++ /dev/null
@@ -1,21 +0,0 @@
-// if n = 371  = 3cube + 7 cube + 1 cube = 371  then number is armstrong number 
-
-
-const isArmStrongNumber = (n) => {
-    let originalNumber = n;
-    let sum = 0;
-
-    while (n > 0) {
-        let digit = n % 10;
-        sum += Math.pow(digit, 3);
-        n = Math.floor(n / 10);
-    }
-
-    if (sum === originalNumber) {
-        console.log(`${originalNumber} is an Armstrong Number.`);
-    } else {
-        console.log(`${originalNumber} is not an Armstrong Number.`);
-    }
-};
-
-isArmStrongNumber(1);
diff --git a/Practies/countCharsInStrArray.js b/Practies/countCharsInStrArray.js
deleted file mode 100644
index 01e366e..0000000
--- a/Practies/countCharsInStrArray.js
+++ /dev/null
@@ -1,18 +0,0 @@
-// count number of chars in given array of string 
-
-
-const countCharsInGivenArray = (arr) => {
-
-    let length = 0;
-    for (const value of arr) {
-
-        for (const _ of value) {
-            length += 1;
-        }
-    }
-    return length;
-}
-
-const arr = ["char1", "char2", "char3", "char4"];
-const result = countCharsInGivenArray(arr);
-console.log("result", result);
\ No newline at end of file
diff --git a/Practies/mergeTwoSortedArray.js b/Practies/mergeTwoSortedArray.js
deleted file mode 100644
index cbb0dce..0000000
--- a/Practies/mergeTwoSortedArray.js
+++ /dev/null
@@ -1,31 +0,0 @@
-function mergeSortedArrays(arr1, arr2) {
-    const mergedArray = [];
-    let pointer1 = 0;
-    let pointer2 = 0;
-
-    while (pointer1 < arr1.length && pointer2 < arr2.length) {
-        if (arr1[pointer1] < arr2[pointer2]) {
-            mergedArray.push(arr1[pointer1]);
-            pointer1++;
-        } else {
-            mergedArray.push(arr2[pointer2]);
-            pointer2++;
-        }
-    }
-
-    while (pointer1 < arr1.length) {
-        mergedArray.push(arr1[pointer1]);
-        pointer1++;
-    }
-
-    while (pointer2 < arr2.length) {
-        mergedArray.push(arr2[pointer2]);
-        pointer2++;
-    }
-
-    return mergedArray;
-}
-
-const arr1 = [1, 3, 5, 7, 9];
-const arr2 = [2, 4, 6, 8, 10];
-console.log(mergeSortedArrays(arr1, arr2)); 
diff --git a/Practies/minimumarray.js b/Practies/minimumarray.js
deleted file mode 100644
index b0b6371..0000000
--- a/Practies/minimumarray.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/* Input: 3 sorted arrays of variable length
-
-const input1 = [3, 6, 8, 10, 15];
-const input2 = [1, 5, 12];
-const input3 = [4, 8, 15, 16];
-
-Output: Minimum range is 4-7   solve this question and define problem in breif and solution also */
-
-function findMinimumRange(arr1, arr2, arr3) {
-    let ptr1 = 0,
-        ptr2 = 0,
-        ptr3 = 0;
-    let minRangeStart = 0,
-        minRangeEnd = Infinity;
-
-    while (ptr1 < arr1.length && ptr2 < arr2.length && ptr3 < arr3.length) {
-        let minVal = Math.min(arr1[ptr1], arr2[ptr2], arr3[ptr3]);
-        let maxVal = Math.max(arr1[ptr1], arr2[ptr2], arr3[ptr3]);
-
-        if (maxVal - minVal < minRangeEnd - minRangeStart) {
-            minRangeStart = minVal;
-            minRangeEnd = maxVal;
-        }
-
-        if (arr1[ptr1] === minVal) {
-            ptr1++;
-        } else if (arr2[ptr2] === minVal) {
-            ptr2++;
-        } else {
-            ptr3++;
-        }
-    }
-
-    return `Minimum range is ${minRangeStart}-${minRangeEnd}`;
-}
-
-// Test cases
-const input1 = [3, 6, 8, 10, 15];
-const input2 = [1, 5, 12];
-const input3 = [4, 8, 15, 16];
-
-const result1 = findMinimumRange(input1, input2, input3);
-console.log(result1);
-
-const input4 = [2, 3, 4, 8, 10, 15];
-const input5 = [1, 5, 12];
-const input6 = [7, 8, 15, 16];
-
-const result2 = findMinimumRange(input4, input5, input6);
-console.log(result2);
diff --git a/Practies/removeDuplicate.js b/Practies/removeDuplicate.js
deleted file mode 100644
index 23aed75..0000000
--- a/Practies/removeDuplicate.js
+++ /dev/null
@@ -1,23 +0,0 @@
-function removeDuplicate(arr) {
-    const frequency = {};
-    const result = [];
-
-    for (const element of arr) {
-        if (frequency[element]) frequency[element] += 1;
-        else frequency[element] = 1;
-    }
-
-    for (const element of arr) {
-        if (frequency[element] > 0) {
-            result.push(element);
-            frequency[element] = 0;
-        }
-    }
-
-    return result;
-}
-
-const arr = [5, 6, 2, 5, 3, 4, 6];
-const result = removeDuplicate(arr);
-console.log("original array ", arr);
-console.log("remove duplicate ", result);
diff --git a/Practies/sortArray.js b/Practies/sortArray.js
deleted file mode 100644
index b137e6a..0000000
--- a/Practies/sortArray.js
+++ /dev/null
@@ -1,16 +0,0 @@
-function sortArray(arr) {
-    const len = arr.length;
-    for (let i = 0; i < len; i++) {
-        for (let j = 0; j < len - i - 1; j++) {
-            if (arr[j] > arr[j + 1]) {
-                let temp = arr[j];
-                arr[j] = arr[j + 1];
-                arr[j + 1] = temp;
-            }
-        }
-    }
-    return arr;
-}
-
-let array = [5, 2, 8, 1, 4];
-console.log(sortArray(array));
diff --git a/Promise.js b/Promise.js
new file mode 100644
index 0000000..5805858
--- /dev/null
+++ b/Promise.js
@@ -0,0 +1,69 @@
+const cart = ["shoes", "pants", "Kurta"];
+
+// Function to simulate API calls with the same function names
+function apiOperation(data) {
+    return new Promise((resolve) => {
+        setTimeout(function () {
+            // Simulating API response
+            resolve();
+        }, 1000 * 5); // Delayed by 5 seconds for demonstration
+    });
+}
+
+apiOperation(cart)
+    .then(() => {
+        console.log("Order created");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Proceeded to payment");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Order summary displayed");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Wallet updated");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Discount applied");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Payment verified");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Confirmation email sent");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Shipping notified");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Order tracked");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Thank you page shown");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Feedback requested");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Survey shown");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Customer profile updated");
+        return apiOperation(null);
+    })
+    .then(() => {
+        console.log("Analytics logged");
+        console.log("All operations completed!");
+    });
diff --git a/ProtoType.js b/ProtoType.js
new file mode 100644
index 0000000..303fde4
--- /dev/null
+++ b/ProtoType.js
@@ -0,0 +1,29 @@
+
+const arr = ["Suman", "singh", "chauhan"];
+
+function multiplyBy5(n) {
+    return n * 5
+}
+
+console.log(multiplyBy5(5));
+console.log(multiplyBy5.myName = "suman");
+
+
+function createUser(userName, score) {
+    this.userName = userName;
+    this.score = score;
+}
+
+createUser.prototype.increment = function () {
+    this.score++;
+}
+createUser.prototype.printMe = function () {
+    console.log(`score  is  ${this.score}`);
+}
+const chai = new createUser("chai", 25)
+const tea = new createUser("tea", 250)
+
+chai.printMe()
+tea.printMe()
+
+
diff --git a/README.md b/README.md
deleted file mode 100644
index 119d040..0000000
--- a/README.md
+++ /dev/null
@@ -1,1341 +0,0 @@
-# Frontend DSA with JavaScript
-
-Welcome to the Frontend DSA (Data Structures and Algorithms) repository with JavaScript! This repository aims to cover various DSA topics along with JavaScript concepts, providing a resource for front-end developers to enhance their skills.
-
-## Table of Contents
-
-1. [Arrays](#arrays)
-2. [Strings](#strings)
-3. [Sorting Algorithms](#sorting-algorithms)
-4. [Searching](#searching)
-5. [Linked Lists](#linked-lists)
-6. [Stacks](#stacks)
-7. [Queues](#queues)
-8. [Trees](#trees)
-9. [Binary Trees](#binary-trees)
-10. [Heaps](#heaps)
-11. [Hashing](#hashing)
-12. [Dynamic Programming](#dynamic-programming)
-13. [Graphs](#graphs)
-14. [Bit Manipulation](#bit-manipulation)
-15. [Backtracking](#backtracking)
-16. [Greedy Algorithms](#greedy-algorithms)
-17. [Divide and Conquer](#divide-and-conquer)
-18. [Segment Trees](#segment-trees)
-19. [Trie](#trie)
-20. [Graph Algorithms](#graph-algorithms)
-21. [Geometry Algorithms](#geometry-algorithms) 22.[Named Algorithms](#named-algorithms)
-
-## Arrays
-
-### Introduction
-
-Arrays are fundamental data structures that store elements in contiguous memory locations. In JavaScript, arrays can hold various data types and are commonly used to solve a wide range of problems.
-
-### Basic Operations
-
-1. **Accessing Elements:** Accessing elements by index.
-2. **Insertion:** Adding elements to the array.
-3. **Deletion:** Removing elements from the array.
-4. **Traversal:** Iterating through all elements in the array.
-
-### Common Array Methods
-
-1. `push()` and `pop()`: Adding and removing elements from the end of the array.
-2. `unshift()` and `shift()`: Adding and removing elements from the beginning of the array.
-3. `splice()`: Modifying elements at a specific index.
-4. `concat()`: Concatenating arrays.
-5. `slice()`: Extracting a portion of an array.
-6. `indexOf()` and `lastIndexOf()`: Finding the index of an element.
-
-### Array Iteration
-
-1. **for...of loop:** Modern iteration syntax for arrays.
-2. **forEach():** Array method for iterating through elements.
-3. **map():** Creating a new array by transforming each element.
-
-### Multi-dimensional Arrays
-
-Using arrays of arrays to represent grids, matrices, etc.
-
-### Problems and Solutions
-
-1. **Finding Maximum and Minimum:** Searching for the largest and smallest elements.
-2. **Searching:** Linear and binary search algorithms.
-3. **Sorting Algorithms:** Bubble sort, selection sort, insertion sort, and quicksort.
-
-### Advanced Array Topics
-
-1. **Dynamic Arrays:** Resizing arrays to accommodate varying numbers of elements.
-2. **Sparse Arrays:** Optimizing memory usage for arrays with many undefined or null values.
-3. **Circular Arrays:** Implementing a circular buffer using arrays.
-4. **Subarray Sum:** Finding subarrays with a specific sum (Kadane's algorithm).
-
-### Additional Resources
-
-- [MDN Web Docs on Arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
-- [JavaScript Array Methods](https://www.w3schools.com/js/js_array_methods.asp)
-
-Feel free to contribute to this section by adding more topics, examples, or explanations.
-
-...
-
-## Strings
-
-### Introduction
-
-Strings are sequences of characters and are used to represent text in programming. In JavaScript, strings are immutable, meaning their values cannot be changed after creation.
-
-### Basic Operations
-
-1. **Accessing Characters:** Accessing characters by index.
-2. **Concatenation:** Combining two or more strings.
-3. **Substring:** Extracting a portion of a string.
-4. **Length:** Finding the length of a string.
-
-### Common String Methods
-
-1. `charAt()`, `charCodeAt()`, and `substring()`: Retrieving characters and substrings.
-2. `concat()`: Concatenating strings.
-3. `slice()`: Extracting a portion of a string.
-4. `indexOf()` and `lastIndexOf()`: Finding the index of a character or substring.
-5. `toUpperCase()` and `toLowerCase()`: Changing the case of a string.
-6. `trim()`: Removing whitespace from the beginning and end of a string.
-
-### String Iteration
-
-1. **for...of loop:** Iterating through characters in a string.
-2. **forEach():** Using array methods on strings.
-
-### Pattern Matching
-
-1. **Regular Expressions (RegExp):** Defining and using regular expressions for pattern matching.
-
-### Problems and Solutions
-
-1. **Palindrome Check:** Determining if a string is a palindrome.
-2. **Anagram Check:** Checking if two strings are anagrams.
-3. **Reverse String:** Reversing the characters in a string.
-4. **String Compression:** Compressing a string by counting repeated characters.
-
-### Advanced String Topics
-
-1. **String Interpolation:** Building strings dynamically using template literals.
-2. **Internationalization (i18n):** Handling multilingual strings.
-3. **Encoding and Decoding:** Methods like `encodeURI()` and `decodeURI()`.
-
-### Additional Resources
-
-- [MDN Web Docs on Strings](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)
-- [JavaScript String Methods](https://www.w3schools.com/js/js_string_methods.asp)
-
-Feel free to contribute to this section by adding more topics, examples, or explanations.
-
-...
-
-## Sorting Algorithms
-
-### Introduction
-
-Sorting algorithms are essential in computer science and are used to arrange elements in a specific order. Proper understanding of sorting algorithms is crucial for writing efficient code and optimizing performance.
-
-### Common Sorting Algorithms
-
-1. **Bubble Sort:**
-
-   - Basic comparison-based sorting algorithm.
-   - Repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order.
-
-2. **Selection Sort:**
-
-   - In-place comparison-based sorting algorithm.
-   - Divides the input list into two parts: a sorted and an unsorted region.
-
-3. **Insertion Sort:**
-
-   - Simple and intuitive sorting algorithm.
-   - Builds the final sorted array one element at a time.
-
-4. **Merge Sort:**
-
-   - Divide and conquer algorithm.
-   - Divides the unsorted list into `n` sub-lists, each containing one element, and then repeatedly merges sub-lists to produce new sorted sub-lists.
-
-5. **QuickSort:**
-
-   - Divide and conquer algorithm.
-   - Picks a pivot element and partitions the array into two sub-arrays according to the pivot, then recursively sorts the sub-arrays.
-
-6. **Heap Sort:**
-   - Comparison-based sorting algorithm.
-   - Builds a binary heap and repeatedly extracts the maximum element from it.
-
-### Comparison of Sorting Algorithms
-
-- **Time Complexity:** Understand the time complexity of each sorting algorithm in various scenarios (best-case, average-case, worst-case).
-- **Space Complexity:** Analyze the space complexity of sorting algorithms.
-- **Stability:** Consider whether the sorting algorithm preserves the relative order of equal elements.
-
-### When to Use Which Algorithm
-
-- **Small Datasets:** Consider simpler algorithms like Bubble Sort or Insertion Sort.
-- **Nearly Sorted Data:** Insertion Sort may perform well.
-- **Large Datasets:** Merge Sort, QuickSort, or Heap Sort are often preferred.
-- **Stable Sorting:** Use algorithms like Merge Sort or Bubble Sort.
-
-### Advanced Sorting Topics
-
-1. **External Sorting:** Techniques for sorting data that is too large to fit into memory.
-2. **Parallel Sorting:** Strategies for sorting large datasets in parallel.
-3. **Hybrid Sorting Algorithms:** Combining different sorting algorithms for improved performance.
-
-### Additional Resources
-
-- [Visualgo Sorting Algorithm Visualization](https://visualgo.net/en/sorting)
-- [Toptal Sorting Algorithms in Plain English](https://www.toptal.com/developers/sorting-algorithms)
-
-Feel free to contribute to this section by adding more details, examples, or explanations.
-
-...
-
-## Searching
-
-### Introduction
-
-Searching algorithms are used to find the presence or absence of a target value in a collection of items. These algorithms play a crucial role in information retrieval, databases, and various other applications.
-
-### Common Searching Algorithms
-
-1. **Linear Search:**
-
-   - Basic searching algorithm that iterates through each element until the target is found or the end of the array is reached.
-
-2. **Binary Search:**
-
-   - Efficient algorithm for finding an element in a sorted collection.
-   - Divides the search interval in half at each step.
-
-3. **Jump Search:**
-
-   - Improved version of linear search for sorted arrays.
-   - Jumps ahead by a fixed number of steps, then performs linear search in the subset.
-
-4. **Interpolation Search:**
-   - Similar to binary search but uses interpolation to find the probable position of the target.
-
-### Comparison of Searching Algorithms
-
-- **Time Complexity:** Understand the time complexity of each searching algorithm in various scenarios.
-- **Space Complexity:** Analyze the space complexity of searching algorithms.
-
-### When to Use Which Algorithm
-
-- **Unsorted Data:** Linear search is a simple choice.
-- **Sorted Data:** Binary search or interpolation search can be more efficient.
-- **Large Datasets:** Consider advanced techniques like hash-based searching.
-
-### Advanced Searching Topics
-
-1. **Hash-Based Searching:** Utilizing hash functions and data structures for faster searches.
-2. **Ternary Search:** Divide and conquer approach with three search intervals.
-3. **Exponential Search:** Combining binary search with an exponential probe.
-
-### Search in Different Data Structures
-
-#### 1. Searching in Arrays
-
-When dealing with arrays, different searching algorithms can be applied depending on the nature of the data.
-
-- **Linear Search:**
-
-  - Suitable for unsorted arrays.
-  - Time complexity: O(n).
-
-- **Binary Search:**
-
-  - Ideal for sorted arrays.
-  - Time complexity: O(log n).
-
-- **Interpolation Search:**
-  - Effective for uniformly distributed sorted arrays.
-  - Time complexity: O(log log n).
-
-#### 2. Searching in Trees
-
-Searching in trees, especially binary trees, involves navigating through nodes to find a specific value.
-
-- **Binary Search Tree (BST):**
-
-  - Utilizes the properties of a BST to efficiently search for a node.
-  - Time complexity: O(log n) in average case.
-
-- **Depth-First Search (DFS):**
-
-  - Can be applied to traverse through a tree and search for a specific value.
-  - Pre-order, in-order, and post-order variants.
-
-- **Breadth-First Search (BFS):**
-  - Useful for level-order traversal and searching in a tree.
-
-#### 3. Searching in Hash Tables
-
-Hash tables provide a fast and efficient way to retrieve values based on keys using hash functions.
-
-- **Hash Function:**
-
-  - The hash function maps keys to indices in the hash table.
-  - Uniform distribution is essential for optimal performance.
-
-- **Collision Handling:**
-
-  - Techniques like separate chaining or open addressing to handle collisions.
-
-- **Hash-based Search:**
-  - Achieves constant time complexity O(1) on average for retrieving values.
-
-### Additional Resources
-
-- [GeeksforGeeks - Searching in Arrays](https://www.geeksforgeeks.org/searching-algorithms/)
-- [GeeksforGeeks - Searching in Trees](https://www.geeksforgeeks.org/tree-traversals-inorder-preorder-and-postorder/)
-- [GeeksforGeeks - Hashing](https://www.geeksforgeeks.org/hashing-set-1-introduction/)
-- [Khan Academy - Hash Tables](https://www.khanacademy.org/computing/computer-science/hash-tables)
-- [Visualgo - Binary Search Tree Visualization](https://visualgo.net/en/bst)
-- [Visualgo - Hash Table Visualization](https://visualgo.net/en/hashtable)
-
-Feel free to contribute to this section by adding more details, examples, or explanations.
-
-### Additional Resources
-
-- [GeeksforGeeks - Searching Algorithms](https://www.geeksforgeeks.org/searching-algorithms/)
-- [Khan Academy - Linear Search](https://www.khanacademy.org/computing/computer-science/algorithms/binary-search/a/binary-search)
-
-Feel free to contribute to this section by adding more details, examples, or explanations.
-
-...
-
-## Linked Lists
-
-### Introduction
-
-A linked list is a linear data structure consisting of nodes connected by pointers. Each node contains data and a reference to the next node in the sequence. Linked lists offer dynamic memory allocation and efficient insertions and deletions compared to arrays.
-
-### Types of Linked Lists
-
-1. **Singly Linked List:**
-
-   - Each node points to the next node in the sequence.
-   - Simple and memory-efficient.
-
-2. **Doubly Linked List:**
-
-   - Each node has pointers to both the next and the previous nodes.
-   - Supports bidirectional traversal.
-
-3. **Circular Linked List:**
-   - The last node points back to the first node.
-   - Circular structure allows for continuous traversal.
-
-### Basic Operations
-
-1. **Insertion:**
-
-   - Adding a new node to the list.
-   - Common types: insertion at the beginning, end, or a specific position.
-
-2. **Deletion:**
-
-   - Removing a node from the list.
-   - Common types: deletion from the beginning, end, or a specific position.
-
-3. **Traversal:**
-   - Visiting each node in the list.
-
-### Common Linked List Challenges
-
-1. **Detecting a Cycle:**
-
-   - Identifying if a linked list contains a cycle.
-   - Floyd's Tortoise and Hare algorithm.
-
-2. **Finding the Middle Element:**
-
-   - Locating the middle node in a linked list.
-   - Using slow and fast pointers.
-
-3. **Reversing a Linked List:**
-   - Inverting the order of nodes in the list.
-
-### Advanced Linked List Topics
-
-1. **Skip Lists:**
-
-   - Probabilistic data structure for fast search.
-   - Consists of multiple linked lists with varying skip distances.
-
-2. **XOR Linked List:**
-   - Memory-efficient variation using XOR operation for node pointers.
-
-### Implementation Considerations
-
-1. **Memory Management:**
-
-   - Dynamically allocating and freeing memory for nodes.
-   - Avoiding memory leaks.
-
-2. **Choosing the Right Type:**
-   - Selecting the appropriate linked list type based on requirements.
-
-### Additional Resources
-
-- [GeeksforGeeks - Linked List Data Structure](https://www.geeksforgeeks.org/data-structures/linked-list/)
-- [Visualgo - Linked List Visualization](https://visualgo.net/en/list)
-
-Feel free to contribute to this section by adding more details, examples, or explanations.
-
-...
-
-## Stacks
-
-### Introduction
-
-A stack is a fundamental Last In, First Out (LIFO) data structure used in computer science. Elements are added and removed from the top of the stack. It follows the principle of adding new elements on top and removing the most recently added element. Stacks are widely used in various algorithms and applications for their simplicity and efficiency.
-
-### Basic Operations
-
-1. **Push:**
-
-   - Add an element to the top of the stack.
-
-2. **Pop:**
-
-   - Remove the element from the top of the stack.
-
-3. **Peek (or Top):**
-   - Retrieve the top element without removing it.
-
-### Applications
-
-1. **Function Call Management:**
-
-   - Stacks are used to manage function calls and local variables during program execution. Each function call gets a stack frame, and when a function completes, its frame is popped.
-
-2. **Expression Evaluation:**
-
-   - In arithmetic expression evaluation, stacks help process operators and operands. They play a crucial role in converting infix expressions to postfix or prefix forms.
-
-3. **Undo Mechanisms:**
-   - Stacks are employed in implementing undo mechanisms in applications. Each action gets pushed onto the stack, and undoing involves popping the last action.
-
-### Challenges
-
-1. **Balanced Parentheses:**
-
-   - Stacks are used to check if an expression has balanced parentheses. Each opening bracket gets pushed, and when a closing bracket is encountered, it should match the top element.
-
-2. **Next Greater Element:**
-   - Stacks can efficiently find the next greater element for each element in an array. Elements are pushed onto the stack until a greater element is encountered.
-
-### Advanced Topics
-
-1. **Min Stack:**
-
-   - An extension of the stack that supports constant-time retrieval of the minimum element in the stack. It involves maintaining an additional stack for minimum values.
-
-2. **Expression Conversion:**
-   - Stacks are used in converting infix expressions to postfix or prefix forms. Operators are pushed and popped based on their precedence.
-
-### Implementation Considerations
-
-1. **Space Complexity:**
-
-   - Analyze the space requirements of different stack implementations. Array-based implementations may have fixed-size limitations, while linked list-based implementations allow dynamic memory allocation.
-
-2. **Choosing Implementation:**
-   - The choice between array-based and linked list-based implementations depends on usage patterns. Arrays offer constant-time access but may require resizing, while linked lists provide dynamic memory allocation.
-
-### Resources
-
-- [GeeksforGeeks - Stack](https://www.geeksforgeeks.org/stack-data-structure/)
-- [Visualgo - Stack Visualization](https://visualgo.net/en/list)
-
-...
-
-## Queues
-
-### Introduction
-
-A queue is a fundamental First In, First Out (FIFO) data structure that manages elements in a linear order. In a queue, elements are enqueued (added) to the rear and dequeued (removed) from the front. Queues are widely used in algorithms and real-world applications for efficient task scheduling, breadth-first search, and resource management.
-
-### Basic Operations
-
-1. **Enqueue:**
-
-   - Add an element to the rear of the queue.
-
-2. **Dequeue:**
-
-   - Remove an element from the front of the queue.
-
-3. **Front (Peek):**
-   - Retrieve the front element without removal.
-
-### Applications
-
-1. **Task Scheduling:**
-
-   - Queues are used to manage tasks in the order they arrive. The first task added is the first to be processed.
-
-2. **Breadth-First Search:**
-
-   - In graph algorithms like BFS, queues facilitate traversing levels in a hierarchical structure level by level.
-
-3. **Resource Management:**
-   - Queues control access to shared resources, ensuring fair and orderly utilization.
-
-### Challenges
-
-1. **Circular Queue:**
-
-   - In a circular queue, elements are enqueued and dequeued in a circular manner, efficiently utilizing space.
-
-2. **Queue using Stacks:**
-   - Implementing a queue using two stacks, showcasing how queues can be simulated using other data structures.
-
-### Advanced Topics
-
-#### 1. Priority Queue:
-
-- **Definition:**
-  - A variation of a queue where elements have assigned priorities.
-- **Implementation:**
-  - Implemented using a binary heap or other priority queue data structures.
-- **Usage:**
-  - Useful in scenarios where elements need to be processed based on their priority level.
-
-#### 2. Double-ended Queue (Deque):
-
-- **Definition:**
-  - A versatile queue that supports insertion and deletion at both ends.
-- **Operations:**
-  - Allows operations such as `insertFront`, `insertRear`, `deleteFront`, and `deleteRear`.
-- **Usage:**
-  - Provides more flexibility and is suitable for scenarios where elements need to be added or removed from both ends.
-
-#### 3. Circular Queue with Dynamic Resizing:
-
-- **Challenge:**
-  - Overcomes the limitation of fixed-size circular queues.
-- **Dynamic Resizing:**
-  - Dynamically resizes the circular queue when it reaches capacity, allowing for a more adaptable and space-efficient implementation.
-
-### Implementation Considerations
-
-1. **Space Complexity:**
-
-   - Analyze the space requirements of different queue implementations. Array-based implementations may have fixed-size limitations, while linked list-based implementations allow dynamic memory allocation.
-
-2. **Choosing Implementation:**
-   - Choose between array-based and linked list-based implementations based on specific use cases. Arrays offer constant-time access, while linked lists allow for dynamic resizing.
-
-### Resources
-
-- [GeeksforGeeks - Queue](https://www.geeksforgeeks.org/queue-data-structure/)
-- [Visualgo - Queue Visualization](https://visualgo.net/en/list)
-
-...
-
-# Trees
-
-## Introduction
-
-Trees are hierarchical data structures widely used in computer science to represent relationships, hierarchies, and organized data. A tree consists of nodes connected by edges, forming a structure where each node has a parent-child relationship with others.
-
-### Basic Tree Components
-
-1. **Node:**
-   - The fundamental building block of a tree containing data and pointers to child nodes.
-2. **Root:**
-   - The topmost node in a tree, serving as the starting point for traversals.
-3. **Parent and Child:**
-   - Nodes in a tree have relationships; a parent node has child nodes, and child nodes have a parent.
-
-### Types of Trees
-
-1. **Binary Tree:**
-   - Each node can have at most two children: a left child and a right child.
-2. **Binary Search Tree (BST):**
-   - A binary tree with a specific ordering; the left child is less than the parent, and the right child is greater.
-3. **AVL Tree:**
-   - A self-balancing binary search tree to maintain logarithmic height, ensuring efficient operations.
-4. **B-Tree:**
-   - A balanced tree used for efficient searching in databases, particularly in file systems.
-
-### Common Operations
-
-1. **Traversal:**
-   - Traversing the nodes of a tree in a specific order: in-order, pre-order, and post-order traversal.
-2. **Insertion and Deletion:**
-   - Adding and removing nodes while maintaining the hierarchical structure.
-
-### Advanced Topics
-
-1. **Trie:**
-   - A tree-like data structure used for efficient searches of strings and dynamic sets.
-2. **Segment Tree:**
-   - A versatile data structure for handling range query operations on an array.
-
-## Resources
-
-- [GeeksforGeeks - Trees](https://www.geeksforgeeks.org/tree-data-structure/)
-- [Visualgo - Tree Visualization](https://visualgo.net/en/bst)
-
-...
-
-# Binary Trees
-
-## Introduction
-
-Binary trees are hierarchical data structures where each node has at most two children: a left child and a right child. They are fundamental in computer science, serving as the basis for various algorithms and applications.
-
-### Components
-
-1. **Node:**
-   - Fundamental building block containing data and pointers to left and right children.
-2. **Root:**
-   - The topmost node in the binary tree.
-3. **Leaf:**
-   - Nodes without children, located at the bottom of the tree.
-
-### Types of Binary Trees
-
-1. **Full Binary Tree:**
-   - Every node has either 0 or 2 children.
-2. **Perfect Binary Tree:**
-   - All levels are completely filled with nodes.
-3. **Complete Binary Tree:**
-   - All levels, except possibly the last, are completely filled, and nodes are filled from left to right.
-
-### Common Operations
-
-1. **Traversal:**
-   - **In-order:** Left, Root, Right.
-   - **Pre-order:** Root, Left, Right.
-   - **Post-order:** Left, Right, Root.
-2. **Insertion and Deletion:**
-   - Adding and removing nodes while maintaining the binary tree structure.
-
-### Resources
-
-- [GeeksforGeeks - Binary Trees](https://www.geeksforgeeks.org/binary-tree-data-structure/)
-- [Visualgo - Binary Tree Visualization](https://visualgo.net/en/bst)
-
----
-
-# Heaps
-
-## Introduction
-
-Heaps are specialized tree-based data structures with the key property that the value of each node is less than or equal to (or greater than or equal to) the values of its children. This property makes heaps suitable for efficient priority queue implementations.
-
-### Types of Heaps
-
-1. **Min Heap:**
-   - The value of each node is less than or equal to the values of its children. The minimum element is at the root.
-2. **Max Heap:**
-   - The value of each node is greater than or equal to the values of its children. The maximum element is at the root.
-
-### Operations
-
-1. **Insertion:**
-   - Adding a new element to the heap while maintaining the heap property.
-2. **Extraction:**
-   - Removing the minimum (or maximum) element from the heap and rearranging the remaining elements to maintain the heap property.
-
-### Applications
-
-1. **Priority Queues:**
-   - Heaps are widely used for efficient implementation of priority queues, allowing for constant-time retrieval of the minimum (or maximum) element.
-2. **Heap Sort:**
-   - Heap sort is a comparison-based sorting algorithm that builds a max heap and repeatedly extracts the maximum element.
-
-### Resources
-
-- [GeeksforGeeks - Heaps](https://www.geeksforgeeks.org/heap-data-structure/)
-- [Visualgo - Heap Visualization](https://visualgo.net/en/heap)
-
-...
-
-# Hashing
-
-Hashing is a technique used to map data of arbitrary size to fixed-size values, commonly for the purpose of faster data retrieval. It involves the use of a hash function to generate a unique identifier, or hash code, for each input. Here are some key topics related to hashing:
-
-## 1. Hash Functions
-
-A hash function is at the core of hashing. It takes an input (or 'key') and produces a fixed-size string of characters, which is typically a hash code. Some characteristics of a good hash function include:
-
-- **Deterministic:** The same input should always produce the same hash code.
-- **Efficient:** The hash function should be computationally efficient.
-- **Uniform Distribution:** The hash codes should be evenly distributed to avoid collisions.
-
-## 2. Collision Resolution
-
-Collisions occur when two different inputs produce the same hash code. Several methods can be employed to resolve collisions:
-
-- **Open Addressing:**
-
-  - Linear Probing
-  - Quadratic Probing
-  - Double Hashing
-
-- **Separate Chaining:**
-  - Each hash table slot maintains a linked list of collided elements.
-
-## 3. Hash Tables
-
-Hash tables are data structures that use hashing to implement an associative array, a structure that maps keys to values. Key components of hash tables include:
-
-- **Load Factor:** The ratio of the number of stored elements to the size of the table.
-- **Resizing:** Dynamic resizing helps maintain efficiency by adjusting the size of the hash table.
-
-## 4. Applications of Hashing
-
-Hashing is widely used in various computer science applications, including:
-
-- **Databases:** Hash functions index data, enabling faster retrieval.
-- **Cryptography:** Hash functions are essential for creating digital signatures.
-- **Caching:** Hashing is used for quick data lookup in caches.
-
-## 5. Cryptographic Hash Functions
-
-In addition to standard hash functions, cryptographic hash functions provide additional security features. Key characteristics include:
-
-- **Irreversibility:** It should be computationally infeasible to reverse the hash.
-- **Collision Resistance:** It should be difficult to find two inputs producing the same hash.
-
-## 6. Consistent Hashing
-
-Consistent hashing is a technique that minimizes the impact of adding or removing nodes from a distributed system. It provides a way to distribute keys across nodes with minimal rehashing.
-
-## Resources
-
-- [GeeksforGeeks - Hashing](https://www.geeksforgeeks.org/hashing-data-structure/)
-- [Wikipedia - Hash Function](https://en.wikipedia.org/wiki/Hash_function)
-- [Khan Academy - Hash Tables](https://www.khanacademy.org/computing/computer-science/algorithms/hash-tables/a/hash-tables)
-
-...
-
-# Dynamic Programming
-
-Dynamic Programming (DP) is a powerful optimization technique in computer science used to solve problems by breaking them down into smaller overlapping subproblems. It often involves storing solutions to subproblems to avoid redundant computations. Here are key topics related to dynamic programming:
-
-## 1. Introduction to Dynamic Programming
-
-- **Definition:** Understanding the essence of dynamic programming and its role in algorithmic problem-solving.
-- **Optimal Substructure:** Exploring problems that can be broken down into smaller, independent subproblems.
-- **Overlapping Subproblems:** Identifying situations where the same subproblems are solved multiple times.
-
-## 2. Memoization
-
-- **Memoization Concept:** Storing solutions to subproblems to avoid redundant computations.
-- **Top-Down Approach:** Solving problems recursively while caching results for future use.
-- **Memoization in Practice:** Implementing memoization in various algorithms.
-
-## 3. Tabulation (Bottom-Up Approach)
-
-- **Tabulation Concept:** Building solutions iteratively, starting from the smallest subproblems.
-- **Bottom-Up Approach:** Solving problems by constructing a table of solutions.
-- **Advantages and Disadvantages:** Comparing memoization and tabulation.
-
-## 4. Fibonacci Sequence Example
-
-- **Recursive Solution:** Understanding the inefficiency of a naive recursive approach.
-- **Memoized Solution:** Implementing memoization to improve performance.
-- **Tabulated Solution:** Applying a bottom-up approach for further optimization.
-
-## 5. Longest Common Subsequence
-
-- **Problem Definition:** Finding the longest subsequence common to two sequences.
-- **Dynamic Programming Solution:** Developing a dynamic programming solution for the problem.
-- **Implementation:** Writing code to find the longest common subsequence.
-
-## 6. Knapsack Problem
-
-- **0/1 Knapsack Problem:** Understanding the problem of selecting items for a knapsack with weight constraints.
-- **Dynamic Programming Approach:** Solving the 0/1 knapsack problem using dynamic programming.
-- **Variations:** Exploring different versions of the knapsack problem.
-
-## 7. Optimal Binary Search Trees
-
-- **Optimal Binary Search Tree Problem:** Formulating the problem of constructing a binary search tree for efficient searching.
-- **Dynamic Programming Solution:** Applying dynamic programming to find the optimal binary search tree.
-
-## 8. Chain Matrix Multiplication
-
-- **Problem Definition:** Optimizing the multiplication of a sequence of matrices.
-- **Dynamic Programming Solution:** Using dynamic programming to minimize the total number of scalar multiplications.
-
-## Resources
-
-- [GeeksforGeeks - Dynamic Programming](https://www.geeksforgeeks.org/dynamic-programming/)
-- [TopCoder - Introduction to Dynamic Programming](https://www.topcoder.com/community/competitive-programming/tutorials/dynamic-programming-from-novice-to-advanced/)
-- [Hackerearth - Dynamic Programming Tutorial](https://www.hackerearth.com/practice/algorithms/dynamic-programming/introduction-to-dynamic-programming-1/tutorial/)
-
-...
-
-# Graphs
-
-Graphs are versatile data structures used to model relationships between entities. They consist of vertices (nodes) connected by edges. Graphs are essential in various computer science applications. Here are key topics related to graphs:
-
-## 1. Introduction to Graphs
-
-- **Definition:** Understanding the basic concept of graphs as a collection of vertices and edges.
-- **Directed vs. Undirected Graphs:** Differentiating between graphs where edges have directions and those without.
-
-## 2. Types of Graphs
-
-- **Directed Graphs (Digraphs):** Exploring graphs with directed edges.
-- **Undirected Graphs:** Understanding graphs without directed edges.
-- **Weighted Graphs:** Introducing graphs where edges have associated weights.
-- **Cyclic and Acyclic Graphs:** Identifying graphs with and without cycles.
-
-## 3. Graph Representation
-
-- **Adjacency Matrix:** Representing a graph using a 2D matrix.
-- **Adjacency List:** Representing a graph using a list of adjacent vertices.
-- **Comparison:** Understanding the trade-offs between the two representations.
-
-## 4. Graph Traversal
-
-- **Depth-First Search (DFS):** Traversing a graph by exploring as far as possible along each branch before backtracking.
-- **Breadth-First Search (BFS):** Traversing a graph level by level.
-
-## 5. Shortest Path Algorithms
-
-- **Dijkstra's Algorithm:** Finding the shortest path in a weighted graph.
-- **Bellman-Ford Algorithm:** Handling negative weights in graphs.
-
-## 6. Minimum Spanning Tree
-
-- **Kruskal's Algorithm:** Constructing a minimum spanning tree in a connected, undirected graph.
-- **Prim's Algorithm:** Another approach to finding a minimum spanning tree.
-
-## 7. Topological Sorting
-
-- **Topological Order:** Defining a linear ordering of vertices in a directed acyclic graph (DAG).
-- **Applications:** Understanding scenarios where topological sorting is useful.
-
-## 8. Graph Cycle Detection
-
-- **Detecting Cycles:** Identifying cycles in a graph using algorithms like DFS.
-- **Directed Acyclic Graphs (DAGs):** Recognizing acyclic graphs.
-
-## 9. Graph Coloring
-
-- **Graph Coloring Problem:** Assigning colors to vertices of a graph such that no two adjacent vertices share the same color.
-- **Applications:** Exploring scenarios where graph coloring is applicable.
-
-## 10. Network Flow
-
-- **Max Flow and Min Cut:** Defining the maximum flow through a network and the minimum cut required.
-
-## Resources
-
-- [GeeksforGeeks - Graph Data Structure](https://www.geeksforgeeks.org/graph-data-structure-and-algorithms/)
-- [Khan Academy - Graphs](https://www.khanacademy.org/computing/computer-science/algorithms/graph-representation/a/describing-graphs)
-- [Visualgo - Graph Visualization](https://visualgo.net/en/graphds)
-
-...
-
-# Bit Manipulation
-
-Bit manipulation involves manipulating individual bits in a binary representation of numbers. It is a powerful technique widely used in low-level programming, cryptography, and optimization. Here are key topics related to bit manipulation:
-
-## 1. Basics of Binary Representation
-
-- **Binary Numbers:** Understanding binary representation and converting between binary and decimal.
-- **Bitwise Operations:** Exploring basic bitwise operations: AND, OR, XOR, NOT.
-- **Bitwise Shifts:** Left and right shifts for efficiently manipulating bits.
-
-## 2. Bitwise Operations in Programming
-
-- **Setting and Clearing Bits:** Techniques for setting or clearing specific bits.
-- **Checking if a Bit is Set:** Verifying if a particular bit is set in a number.
-- **Toggle a Bit:** Flipping the state of a particular bit.
-
-## 3. Bitwise Tricks
-
-- **Swap Two Numbers:** Swapping two numbers without using a temporary variable.
-- **Detecting Opposite Signs:** Checking if two numbers have opposite signs using bitwise XOR.
-- **Absolute Value of a Number:** Finding the absolute value without branching.
-
-## 4. Bit Manipulation Techniques
-
-- **Counting Set Bits (Hamming Weight):** Determining the number of set bits in a number.
-- **Checking Power of 2:** Verifying if a number is a power of 2 using bitwise operations.
-- **Finding the Most Significant Bit:** Determining the position of the most significant set bit.
-
-## 5. Bitwise Manipulation in Data Structures
-
-- **Bitsets:** Utilizing bitsets for efficient storage of boolean values.
-- **Using Bits for Flags:** Storing multiple boolean flags in a single integer.
-
-## 6. Bitwise Operations in Algorithms
-
-- **Bitwise OR of Range:** Finding the bitwise OR of all elements in a range.
-- **Single Number Problem:** Solving problems where all elements occur twice except one.
-
-## 7. Bitwise Manipulation in Cryptography
-
-- **XOR Encryption:** Basics of XOR-based encryption and decryption.
-- **Bitwise Hashing:** Creating hash functions using bitwise operations.
-
-## Resources
-
-- [GeeksforGeeks - Bitwise Operators](https://www.geeksforgeeks.org/bitwise-operators-in-c-cpp/)
-- [Hacker's Delight (Book)](https://www.hackersdelight.org/)
-- [Bit Manipulation - YouTube Tutorial](https://www.youtube.com/watch?v=NLKQEOgBAnw)
-
-...
-
-# Backtracking
-
-Backtracking is a general algorithmic technique for solving problems that incrementally builds candidates for solutions and abandons a candidate ("backtracks") as soon as it determines that the candidate cannot possibly be completed to a valid solution. Here are key topics related to backtracking:
-
-## 1. Introduction to Backtracking
-
-- **Definition:** Understanding the basic concept of backtracking as an algorithmic technique.
-- **Characteristics:** Identifying problems suitable for backtracking.
-
-## 2. Backtracking Process
-
-- **Decision Space:** Defining the space of possible solutions.
-- **Decision Tree:** Visualizing the exploration of solutions in a tree structure.
-- **Base Case:** Determining when to stop the exploration.
-
-## 3. N-Queens Problem
-
-- **Problem Statement:** Placing N queens on an N×N chessboard so that no two queens threaten each other.
-- **Backtracking Solution:** Using backtracking to find valid arrangements.
-
-## 4. Subset Sum Problem
-
-- **Problem Statement:** Finding a subset of given numbers that adds up to a given sum.
-- **Backtracking Approach:** Exploring different subsets to find a valid solution.
-
-## 5. Sudoku Solver
-
-- **Problem Statement:** Filling a 9×9 grid with digits so that each column, each row, and each of the nine 3×3 subgrids that compose the grid contain all of the digits from 1 to 9.
-- **Backtracking Solution:** Solving Sudoku puzzles using backtracking.
-
-## 6. Hamiltonian Cycle
-
-- **Problem Statement:** Finding a cycle that visits every vertex exactly once in a graph.
-- **Backtracking Algorithm:** Exploring different paths in the graph to find a Hamiltonian cycle.
-
-## 7. Rat in a Maze
-
-- **Problem Statement:** Finding a path for a rat to reach the destination in a maze.
-- **Backtracking Solution:** Navigating through the maze to find a valid path.
-
-## 8. Graph Coloring
-
-- **Problem Statement:** Assigning colors to vertices of a graph such that no two adjacent vertices share the same color.
-- **Backtracking Approach:** Exploring different color assignments.
-
-## 9. Knight's Tour
-
-- **Problem Statement:** Finding a sequence of moves for a knight to visit every square on a chessboard exactly once.
-- **Backtracking Solution:** Exploring different paths for the knight.
-
-## 10. Word Search
-
-- **Problem Statement:** Searching for a word in a 2D grid of characters.
-- **Backtracking Solution:** Exploring different paths to find the word.
-
-## 11. Combination Sum
-
-- **Problem Statement:** Finding all unique combinations in a set of numbers that sum up to a target.
-- **Backtracking Approach:** Generating combinations using backtracking.
-
-## Resources
-
-- [GeeksforGeeks - Backtracking Algorithms](https://www.geeksforgeeks.org/backtracking-algorithms/)
-- [Brilliant.org - Backtracking](https://brilliant.org/wiki/backtracking-basics/)
-- [Backtracking - YouTube Tutorial](https://www.youtube.com/watch?v=DKCbsiDBN6c)
-
-...
-
-# Greedy Algorithms
-
-Greedy algorithms make locally optimal choices at each stage with the hope of finding a global optimum. They are often intuitive, easy to implement, and can be efficient in solving optimization problems. Here are key topics related to greedy algorithms:
-
-## 1. Introduction to Greedy Algorithms
-
-- **Definition:** Understanding the basic concept of greedy algorithms and their approach to problem-solving.
-- **Characteristics:** Identifying problems suitable for greedy strategies.
-
-## 2. Greedy Choice Property
-
-- **Greedy Choice:** Making the locally optimal choice at each stage of the algorithm.
-- **Optimal Substructure:** Solving subproblems independently to achieve the global optimum.
-
-## 3. Activity Selection Problem
-
-- **Problem Statement:** Selecting the maximum number of non-overlapping activities in a schedule.
-- **Greedy Solution:** Choosing activities based on their finish times.
-
-## 4. Huffman Coding
-
-- **Problem Statement:** Efficiently encoding data with variable-length codes to minimize the total encoded length.
-- **Greedy Solution:** Constructing a Huffman tree based on the frequency of characters.
-
-## 5. Kruskal's Minimum Spanning Tree Algorithm
-
-- **Problem Statement:** Finding the minimum spanning tree in a connected, undirected graph.
-- **Greedy Solution:** Sorting edges by weight and adding them to the minimum spanning tree.
-
-## 6. Prim's Minimum Spanning Tree Algorithm
-
-- **Problem Statement:** Another approach to finding the minimum spanning tree in a connected, undirected graph.
-- **Greedy Solution:** Building the minimum spanning tree by adding the nearest vertex.
-
-## 7. Dijkstra's Shortest Path Algorithm
-
-- **Problem Statement:** Finding the shortest paths from a source vertex to all other vertices in a weighted graph.
-- **Greedy Solution:** Selecting the vertex with the minimum distance at each step.
-
-## 8. Coin Change Problem
-
-- **Problem Statement:** Making change for a given amount using the fewest number of coins.
-- **Greedy Solution:** Choosing the largest denomination coins until the amount is reached.
-
-## 9. Fractional Knapsack Problem
-
-- **Problem Statement:** Maximizing the total value of items in a knapsack without exceeding its weight capacity.
-- **Greedy Solution:** Selecting items based on their value-to-weight ratios.
-
-## 10. Job Sequencing with Deadlines
-
-- **Problem Statement:** Scheduling jobs with deadlines and maximizing the total profit.
-- **Greedy Solution:** Sorting jobs by profit and scheduling them based on deadlines.
-
-## Resources
-
-- [GeeksforGeeks - Greedy Algorithms](https://www.geeksforgeeks.org/greedy-algorithms/)
-- [Brilliant.org - Greedy Algorithms](https://brilliant.org/wiki/greedy-algorithm/)
-- [Greedy Algorithms - YouTube Tutorial](https://www.youtube.com/watch?v=wT1dti0vY4E)
-
-...
-
-# Divide and Conquer
-
-Divide and Conquer is a powerful algorithmic technique where a problem is divided into subproblems, solved independently, and then combined to solve the original problem. It is often used to efficiently solve complex problems. Here are key topics related to divide and conquer:
-
-## 1. Introduction to Divide and Conquer
-
-- **Definition:** Understanding the basic concept of divide and conquer as an algorithmic paradigm.
-- **Characteristics:** Identifying problems suitable for divide and conquer strategies.
-
-## 2. Basic Divide and Conquer Algorithm Structure
-
-- **Divide:** Breaking the problem into smaller subproblems.
-- **Conquer:** Solving the subproblems recursively.
-- **Combine:** Merging the solutions of subproblems to obtain the final solution.
-
-## 3. Merge Sort
-
-- **Sorting Algorithm:** Sorting an array or list using the divide and conquer approach.
-- **Divide:** Splitting the array into two halves.
-- **Conquer:** Recursively sorting the two halves.
-- **Combine:** Merging the sorted halves.
-
-## 4. Quick Sort
-
-- **Sorting Algorithm:** Sorting an array or list using the divide and conquer approach.
-- **Divide:** Choosing a pivot element and partitioning the array.
-- **Conquer:** Recursively sorting the two partitions.
-- **Combine:** No additional combining step is needed.
-
-## 5. Binary Search
-
-- **Searching Algorithm:** Finding the position of a target element in a sorted array.
-- **Divide:** Identifying the middle element.
-- **Conquer:** Searching the appropriate half based on the comparison.
-- **Combine:** Returning the position of the target.
-
-## 6. Closest Pair of Points
-
-- **Problem Statement:** Finding the closest pair of points in a set.
-- **Divide:** Dividing the set into two halves based on the x-coordinate.
-- **Conquer:** Finding the closest pairs in the two halves.
-- **Combine:** Checking for closer pairs across the dividing line.
-
-## 7. Strassen's Matrix Multiplication
-
-- **Matrix Multiplication:** Efficiently multiplying two matrices using divide and conquer.
-- **Divide:** Breaking matrices into smaller submatrices.
-- **Conquer:** Recursively multiplying submatrices.
-- **Combine:** Combining the results to obtain the final product.
-
-## 8. Karatsuba Algorithm for Multiplication
-
-- **Multiplication Algorithm:** Efficiently multiplying two numbers using divide and conquer.
-- **Divide:** Splitting numbers into smaller parts.
-- **Conquer:** Recursively multiplying subparts.
-- **Combine:** Combining the results to obtain the final product.
-
-## Resources
-
-- [GeeksforGeeks - Divide and Conquer](https://www.geeksforgeeks.org/divide-and-conquer/)
-- [Brilliant.org - Divide and Conquer](https://brilliant.org/wiki/divide-and-conquer-algorithm/)
-- [Divide and Conquer - YouTube Tutorial](https://www.youtube.com/watch?v=4OQeCuLYj-4)
-
-...
-
-# Segment Trees
-
-Segment Trees are a powerful data structure used for efficient querying of intervals or ranges in an array. They enable various range-based operations in logarithmic time. Here are key topics related to segment trees:
-
-## 1. Introduction to Segment Trees
-
-- **Definition:** Understanding the basic concept of segment trees as a data structure.
-- **Use Cases:** Identifying scenarios where segment trees are beneficial.
-
-## 2. Structure of a Segment Tree
-
-- **Node Representation:** Defining the structure of a segment tree node.
-- **Building Blocks:** Understanding the components of a segment tree.
-
-## 3. Construction of a Segment Tree
-
-- **Recursive Build:** Constructing a segment tree using a recursive approach.
-- **Lazy Propagation:** Introducing lazy propagation for optimizing updates.
-
-## 4. Range Query Operations
-
-- **Querying a Range:** Performing range-based queries efficiently using segment trees.
-- **Sum of Elements:** Finding the sum of elements in a given range.
-- **Minimum and Maximum Queries:** Determining the minimum or maximum element in a range.
-
-## 5. Range Update Operations
-
-- **Updating a Range:** Modifying elements within a specified range using segment trees.
-- **Point Update vs. Range Update:** Comparing different update strategies.
-
-## 6. Lazy Propagation
-
-- **Lazy Update:** Delaying updates to optimize segment tree construction.
-- **Lazy Querying:** Efficiently handling range queries with lazy propagation.
-
-## 7. Applications of Segment Trees
-
-- **Interval Query Problems:** Solving problems that involve querying intervals or ranges.
-- **Sum or Min/Max Queries:** Examples of real-world applications.
-
-## 8. Fenwick Tree (Binary Indexed Tree)
-
-- **Alternative Data Structure:** Understanding the Fenwick tree as an alternative to segment trees.
-- **Point Queries and Updates:** Handling point-based queries and updates efficiently.
-
-## 9. Persistent Segment Trees
-
-- **Definition:** Introducing the concept of persistent segment trees.
-- **Time Travel Queries:** Solving queries for different versions of the underlying array.
-
-## Resources
-
-- [GeeksforGeeks - Segment Tree](https://www.geeksforgeeks.org/segment-tree-set-1-sum-of-given-range/)
-- [CP-Algorithms - Segment Tree](https://cp-algorithms.com/data_structures/segment_tree.html)
-- [Segment Trees - YouTube Tutorial](https://www.youtube.com/watch?v=ZBHKZF5w4YU)
-
-...
-
-# Trie
-
-Trie, also known as a prefix tree, is a tree-like data structure that is used to store a dynamic set or associative array where the keys are strings. Tries are particularly useful for efficient string-related operations. Here are key topics related to tries:
-
-## 1. Introduction to Trie
-
-- **Definition:** Understanding the basic concept of a trie as a tree structure for storing strings.
-- **Use Cases:** Identifying scenarios where tries are advantageous.
-
-## 2. Structure of a Trie
-
-- **Node Representation:** Defining the structure of a trie node.
-- **Children Array:** Understanding how a node represents possible next characters.
-- **Root Node:** Special characteristics of the root node.
-
-## 3. Trie Operations
-
-- **Insertion:** Adding a new string to the trie.
-- **Deletion:** Removing a string from the trie.
-- **Search:** Checking whether a given string is present in the trie.
-
-## 4. Trie Construction
-
-- **Building a Trie:** Creating a trie by inserting strings one character at a time.
-- **Time Complexity:** Analyzing the time complexity of trie operations.
-
-## 5. Trie vs. Hash Table
-
-- **Comparison:** Contrasting tries with hash tables for string-related operations.
-- **Advantages and Disadvantages:** Identifying scenarios where one data structure is preferable.
-
-## 6. Trie Applications
-
-- **Autocomplete and Spell Checking:** Using tries to implement autocomplete suggestions and spell-checking.
-- **IP Routing and Longest Prefix Matching:** Applying tries in networking for IP address routing.
-
-## 7. Trie Variations
-
-- **Compressed Trie:** Reducing storage space by compressing common prefixes.
-- **Ternary Search Trie:** A balanced variant of the trie with three children per node.
-
-## 8. Suffix Trie
-
-- **Suffix Tree vs. Suffix Trie:** Understanding the connection between suffix trees and suffix tries.
-- **Applications:** Solving problems related to substring searching.
-
-## 9. Trie in Competitive Programming
-
-- **Typical Problems:** Exploring common algorithmic problems where tries are employed.
-- **Efficient Solutions:** Leveraging trie structures for optimized solutions.
-
-## Resources
-
-- [GeeksforGeeks - Trie](https://www.geeksforgeeks.org/trie-insert-and-search/)
-- [Brilliant.org - Trie](https://brilliant.org/wiki/tries/)
-- [Trie Data Structure - YouTube Tutorial](https://www.youtube.com/watch?v=AXjmTQ8LEoI)
-
-...
-
-# Graph Algorithms
-
-Graph algorithms are essential for analyzing and solving problems related to graphs, which model relationships between entities. They are widely used in various computer science applications. Here are key topics related to graph algorithms:
-
-## 1. Graph Representation
-
-- **Adjacency Matrix:** Representing a graph using a 2D matrix.
-- **Adjacency List:** Representing a graph using a list of adjacent vertices.
-- **Graph Traversal:** Techniques for visiting all vertices in a graph.
-
-## 2. Depth-First Search (DFS)
-
-- **Traversal Algorithm:** Visiting vertices and exploring as far as possible along each branch before backtracking.
-- **Applications:** Solving problems like connected components, topological sorting, and cycle detection.
-
-## 3. Breadth-First Search (BFS)
-
-- **Traversal Algorithm:** Visiting vertices level by level, exploring neighbors before moving on to the next level.
-- **Applications:** Finding the shortest path, connected components, and network flow.
-
-## 4. Shortest Path Algorithms
-
-- **Dijkstra's Algorithm:** Finding the shortest paths from a source vertex to all other vertices in a weighted graph.
-- **Bellman-Ford Algorithm:** Handling negative weights in graphs.
-
-## 5. Minimum Spanning Tree
-
-- **Kruskal's Algorithm:** Constructing a minimum spanning tree in a connected, undirected graph.
-- **Prim's Algorithm:** Another approach to finding a minimum spanning tree.
-
-## 6. Topological Sorting
-
-- **Topological Order:** Defining a linear ordering of vertices in a directed acyclic graph (DAG).
-- **Applications:** Useful in scheduling and task ordering problems.
-
-## 7. Graph Cycle Detection
-
-- **Detecting Cycles:** Identifying cycles in a graph using algorithms like DFS.
-- **Directed Acyclic Graphs (DAGs):** Recognizing acyclic graphs.
-
-## 8. Graph Coloring
-
-- **Graph Coloring Problem:** Assigning colors to vertices of a graph such that no two adjacent vertices share the same color.
-- **Applications:** Solving scheduling and resource allocation problems.
-
-## 9. Network Flow
-
-- **Max Flow and Min Cut:** Defining the maximum flow through a network and the minimum cut required.
-- **Ford-Fulkerson Algorithm:** An algorithm for finding the maximum flow in a network.
-
-## 10. Bipartite Graphs
-
-- **Bipartite Graphs:** Identifying graphs whose vertices can be partitioned into two sets such that no edges connect vertices within the same set.
-- **Applications:** Solving problems related to matching and scheduling.
-
-## Resources
-
-- [GeeksforGeeks - Graph Algorithms](https://www.geeksforgeeks.org/graph-data-structure-and-algorithms/)
-- [Khan Academy - Graphs](https://www.khanacademy.org/computing/computer-science/algorithms/graph-representation/a/describing-graphs)
-- [Visualgo - Graph Visualization](https://visualgo.net/en/graphds)
-
-...
-
-# Geometry Algorithms
-
-Geometry algorithms deal with solving problems related to geometric objects such as points, lines, and polygons. These algorithms are essential in computer graphics, computer-aided design, and various other applications. Here are key topics related to geometry algorithms:
-
-## 1. Points and Vectors
-
-- **Coordinate Systems:** Understanding different coordinate systems (2D and 3D).
-- **Vectors:** Representing and manipulating vectors in geometric calculations.
-
-## 2. Distance and Angles
-
-- **Euclidean Distance:** Calculating distances between points.
-- **Angle Between Vectors:** Determining angles formed by vectors.
-
-## 3. Line Segments and Lines
-
-- **Slope of a Line:** Finding the slope of a line in 2D space.
-- **Intersection of Lines:** Detecting intersections between line segments.
-
-## 4. Convex Hull
-
-- **Convex Hull Problem:** Finding the smallest convex polygon that encloses a set of points.
-- **Graham's Scan Algorithm:** Constructing the convex hull efficiently.
-
-## 5. Polygon Triangulation
-
-- **Triangulating Polygons:** Decomposing a polygon into triangles.
-- **Ear Clipping Algorithm:** An approach to polygon triangulation.
-
-## 6. Closest Pair of Points
-
-- **Closest Pair Problem:** Finding the two closest points in a set.
-- **Divide and Conquer:** Solving the problem efficiently using a divide-and-conquer approach.
-
-## 7. Intersection of Geometric Objects
-
-- **Intersection of Line Segments:** Determining if two line segments intersect.
-- **Intersection of Circles:** Detecting intersections between circles.
-
-## 8. Polygon Area
-
-- **Shoelace Formula:** Calculating the area of a simple polygon.
-- **Orientation Test:** Determining the orientation of three points.
-
-## 9. Voronoi Diagrams
-
-- **Voronoi Diagram:** Dividing a plane into regions based on proximity to a given set of points.
-- **Fortune's Algorithm:** Constructing Voronoi diagrams efficiently.
-
-## 10. Delaunay Triangulation
-
-- **Delaunay Triangulation:** Triangulating a set of points such that no point is inside the circumcircle of any triangle.
-- **Bowyer-Watson Algorithm:** An algorithm for Delaunay triangulation.
-
-## Resources
-
-- [GeeksforGeeks - Computational Geometry](https://www.geeksforgeeks.org/computer-graphics-algorithms/)
-- [Brilliant.org - Geometry](https://brilliant.org/wiki/geometry-algorithms/)
-- [CGAL - Computational Geometry Algorithms Library](https://www.cgal.org/)
-
-...
-
-...
-
-## Contributing
-
-If you would like to contribute to this repository by adding more topics, improving existing explanations, or fixing errors, please feel free to submit a pull request.
diff --git a/Recrusion/Recursion .md b/Recrusion/Recursion .md
deleted file mode 100644
index a636cb3..0000000
--- a/Recrusion/Recursion .md	
+++ /dev/null
@@ -1,49 +0,0 @@
-# Recursion
-
-Recursion is a programming technique where a function calls itself in order to solve a problem. It is particularly useful for solving problems that can be broken down into smaller, similar subproblems. In recursion, the function continues to call itself with modified input until it reaches a base case, which is a condition that stops the recursion.
-
-## What is Recursion?
-
-Recursion is a process where a function calls itself as a subroutine. This allows the function to repeat itself several times, outputting the result and the end of each iteration.
-
-## Types of Recursion
-
-### 1. Linear Recursion
-
-Linear recursion occurs when a function calls itself only once. Each recursive call generates only one subsequent recursive call until it reaches the base case.
-
-### 2. Tail Recursion
-
-Tail recursion occurs when the recursive call is the last thing the function does. This means there is no pending computation after the recursive call returns, making it easier for compilers to optimize.
-
-### 3. Binary Recursion
-
-Binary recursion occurs when a function calls itself twice in each recursion step. Each recursive call generates two subsequent recursive calls until it reaches the base case.
-
-### 4. Mutual Recursion
-
-Mutual recursion occurs when two or more functions call each other in a cycle. Each function delegates part of its task to the other function(s).
-
-### 5. Nested Recursion
-
-Nested recursion occurs when a recursive function passes the result of its recursive call as an argument to another call. The nested call can be deeper than the original call.
-
-### 6. Indirect Recursion
-
-Indirect recursion occurs when a function calls another function that eventually calls the first function in a cycle.
-
-### 6. Recursion Tree
-
-basicRecursion(3)
-│
-├── basicRecursion(2)
-│ │
-│ ├── basicRecursion(1)
-│ │ │
-│ │ └── basicRecursion(0)
-│ │ │
-│ │ └── basicRecursion(-1) (base case)
-│ │
-│ └── basicRecursion(-1) (base case)
-│
-└── basicRecursion(-1) (base case)
diff --git a/Recrusion/introrecrsion.js b/Recrusion/introrecrsion.js
deleted file mode 100644
index 2c9528e..0000000
--- a/Recrusion/introrecrsion.js
+++ /dev/null
@@ -1,52 +0,0 @@
-function basicRecursion(n) {
-    if (n < 0) {
-        return;
-    } else {
-        console.log(n);
-        basicRecursion(n - 1);
-    }
-}
-
-basicRecursion(10);
-
-/*basicRecursion(10)
-basicRecursion(9)
-│
-├── basicRecursion(8)
-│   │
-│   ├── basicRecursion(7)
-│   │   │
-│   │   ├── basicRecursion(6)
-│   │   │   │
-│   │   │   ├── basicRecursion(5)
-│   │   │   │   │
-│   │   │   │   ├── basicRecursion(4)
-│   │   │   │   │   │
-│   │   │   │   │   ├── basicRecursion(3)
-│   │   │   │   │   │   │
-│   │   │   │   │   │   ├── basicRecursion(2)
-│   │   │   │   │   │   │   │
-│   │   │   │   │   │   │   ├── basicRecursion(1)
-│   │   │   │   │   │   │   │   │
-│   │   │   │   │   │   │   │   └── basicRecursion(0)
-│   │   │   │   │   │   │   │       │
-│   │   │   │   │   │   │   │       └── basicRecursion(-1) (base case)
-│   │   │   │   │   │   │   │
-│   │   │   │   │   │   │   └── basicRecursion(0) (base case)
-│   │   │   │   │   │   │
-│   │   │   │   │   │   └── basicRecursion(0) (base case)
-│   │   │   │   │   │
-│   │   │   │   │   └── basicRecursion(0) (base case)
-│   │   │   │   │
-│   │   │   │   └── basicRecursion(0) (base case)
-│   │   │   │
-│   │   │   └── basicRecursion(0) (base case)
-│   │   │
-│   │   └── basicRecursion(0) (base case)
-│   │
-│   └── basicRecursion(0) (base case)
-│
-└── basicRecursion(0) (base case)
-
-│   │   │   │  
-*/
\ No newline at end of file
diff --git a/Recrusion/printNamesNTime.js b/Recrusion/printNamesNTime.js
deleted file mode 100644
index dfbd41d..0000000
--- a/Recrusion/printNamesNTime.js
+++ /dev/null
@@ -1,42 +0,0 @@
-
-// //print Name n time 
-// function printNameNTime(n, i) {
-//     if (i > n) {
-//         return;
-//     } else {
-//         console.log("This is Suman Singh", i);
-//         printNameNTime(n, i + 1);
-//     }
-// }
-
-// printNameNTime(10, 1);
-
-// //print  1 to n integer  time 
-
-
-// function printN1toN(n, i) {
-//     if (i > n) {
-//         return;
-//     } else {
-//         console.log(i);
-//         printN1toN(n, i + 1);
-//     }
-// }
-
-// printN1toN(10, 1);
-
-
-
-//print  n to  1integer  time 
-
-
-function printNto1(n) {
-    if (n <= 0) {
-        return;
-    } else {
-        console.log(n);
-        printNto1(n - 1);
-    }
-}
-
-printNto1(10);
\ No newline at end of file
diff --git a/Recrusion/printSumofN.js b/Recrusion/printSumofN.js
deleted file mode 100644
index 9274dc4..0000000
--- a/Recrusion/printSumofN.js
+++ /dev/null
@@ -1,28 +0,0 @@
-//print  sum of n numbers using recursion
-
-// Parameterized Recursion:
-function sumOfNParam(n, acc = 0) {
-    if (n === 0) { // Base case
-        return acc;
-    } else {
-        return sumOfNParam(n - 1, acc + n); // Recursive call with accumulator
-    }
-}
-
-// Example usage
-let result = sumOfNParam(5);
-console.log("Sum of first 5 natural numbers:", result); // Output: 15
-
-
-// Functional Recursion
-function sumOfN(n) {
-    if (n === 0) { // Base case
-        return 0;
-    } else {
-        return n + sumOfN(n - 1); // Recursive call
-    }
-}
-
-// Example usage
-let result1 = sumOfN(5);
-console.log("Sum of first 5 natural numbers:", result1); // Output: 15
diff --git a/Recrusion/reverseAnArray.js b/Recrusion/reverseAnArray.js
deleted file mode 100644
index 6e64de6..0000000
--- a/Recrusion/reverseAnArray.js
+++ /dev/null
@@ -1,18 +0,0 @@
-//
-function reverseArray(arr) {
-    let i = 0;
-    let j = arr.length - 1;
-    while (i < j) {
-        // Swap elements at positions i and j
-        let temp = arr[i];
-        arr[i] = arr[j];
-        arr[j] = temp;
-        i++;
-        j--;
-    }
-    return arr; // return the reversed array
-}
-
-const inputArray = [2, 3, 4, 5, 60, 55];
-const result = reverseArray(inputArray);
-console.log("result", result);
diff --git a/Reduce.js b/Reduce.js
new file mode 100644
index 0000000..8601c2f
--- /dev/null
+++ b/Reduce.js
@@ -0,0 +1,9 @@
+const arr = [1, 2, 3, 4, 5];
+
+const output = arr.reduce(function (acc, curr) {
+    return acc += curr
+}, 0)
+
+
+
+console.log(output);
\ No newline at end of file
diff --git a/SetInJs.js b/SetInJs.js
new file mode 100644
index 0000000..aa386da
--- /dev/null
+++ b/SetInJs.js
@@ -0,0 +1,29 @@
+// Creating a Set
+const mySet = new Set();
+
+// Adding elements to the Set
+mySet.add(1);
+mySet.add('Hello');
+mySet.add(true);
+mySet.add(1); // This duplicate value won't be added
+
+// Checking the size of the Set
+console.log("Size of the Set:", mySet.size); // Output: 3
+
+// Checking if an element exists in the Set
+console.log("Checking if 'Hello' exists in the Set:", mySet.has('Hello')); // Output: true
+
+// Deleting an element from the Set
+mySet.delete(true);
+
+// Iterating over the Set
+console.log("Iterating over the Set:");
+mySet.forEach(item => console.log(item));
+
+// Converting Set to Array
+const myArray = Array.from(mySet);
+console.log("Set converted to Array:", myArray); // Output: [1, 'Hello']
+
+// Clearing the Set
+mySet.clear();
+console.log("Cleared Set:", mySet); // Output: Set {}
diff --git a/SetTimeOutclosure.js b/SetTimeOutclosure.js
new file mode 100644
index 0000000..e96464b
--- /dev/null
+++ b/SetTimeOutclosure.js
@@ -0,0 +1,24 @@
+// function x() {
+//     for (let i = 1; i <= 5; i++) {
+//         setTimeout(function () {
+//             console.log(i);
+//         }, i * 1000);
+//     }
+
+//     console.log("Namaste  JS");
+// }
+// x();
+
+function x() {
+    for (var i = 1; i <= 5; i++) {
+        function close(x) {
+            setTimeout(function () {
+                console.log(x);
+            }, x * 1000);
+        }
+        close(i);
+    }
+
+    console.log("Namaste  JS");
+}
+x();
diff --git a/SlidingWindow/1.MaximumSumSubArray.js b/SlidingWindow/1.MaximumSumSubArray.js
deleted file mode 100644
index b31c6aa..0000000
--- a/SlidingWindow/1.MaximumSumSubArray.js
+++ /dev/null
@@ -1,25 +0,0 @@
-// Maximum Sum Subarray of Size K
-
-function maxSumSubarrayOfSizeK(arr, k) {
-    let maxSum = 0;
-    let windowSum = 0;
-    let windowStart = 0;
-
-    for (let windowEnd = 0; windowEnd < arr.length; windowEnd++) {
-        windowSum += arr[windowEnd];
-
-        // Slide the window if we have reached the size K
-        if (windowEnd >= k - 1) {
-            maxSum = Math.max(maxSum, windowSum);
-            windowSum -= arr[windowStart]; // Remove the element going out of the window
-            windowStart++; // Slide the window ahead
-        }
-    }
-
-    return maxSum;
-}
-
-// Example usage:
-const arr = [4, 2, 1, 7, 8, 1, 2, 8, 1, 0];
-const k = 3;
-console.log("Maximum sum of subarray of size K:", maxSumSubarrayOfSizeK(arr, k)); // Output: 16
diff --git a/SlidingWindow/2.LongestSumsArr.js b/SlidingWindow/2.LongestSumsArr.js
deleted file mode 100644
index 287d522..0000000
--- a/SlidingWindow/2.LongestSumsArr.js
+++ /dev/null
@@ -1,31 +0,0 @@
-// Longest Subarray with Sum K
-
-const longestSubarrayWithSumK = (nums, k) => {
-    let maxLength = 0;
-    let maxStart = 0;
-    let maxEnd = -1;
-    let sum = 0;
-    let start = 0;
-
-    for (let end = 0; end < nums.length; end++) {
-        sum += nums[end];
-
-        while (sum > k) {
-            sum -= nums[start];
-            start++;
-        }
-
-        if (sum === k && end - start + 1 > maxLength) {
-            maxLength = end - start + 1;
-            maxStart = start;
-            maxEnd = end;
-        }
-    }
-
-    return nums.slice(maxStart, maxEnd + 1);
-
-}
-
-const nums = [10, 5, 2, 7, 1, 5, 9];
-const k = 15;
-console.log(longestSubarrayWithSumK(nums, k)); 
diff --git a/SlidingWindow/Problems.md b/SlidingWindow/Problems.md
deleted file mode 100644
index f5e52c7..0000000
--- a/SlidingWindow/Problems.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# Sliding Window Problems
-
-## Problems for Arrays
-
-1. Maximum Sum Subarray of Size K
-2. Longest Subarray with Sum K
-3. Smallest Subarray with a given sum
-4. Maximum of all subarrays of size k
-5. Count distinct elements in every window of size k
-6. Check if a subarray with sum 0 exists or not
-7. Find the subarray with given sum
-8. Find the maximum average subarray of k length
-9. Find all Anagrams in a String
-10. Number of Subarrays with Bounded Maximum
-11. Shortest Subarray with Sum at Least K
-12. Sliding Window Maximum (Maximum of all subarrays of size k)
-13. Find K-Length Substrings With No Repeated Characters
-14. Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit
-15. Longest Repeating Character Replacement
-16. Minimum Size Subarray Sum
-17. Degree of an Array
-18. Subarrays with K Different Integers
-19. Find All Anagrams in a String
-20. Maximum Points You Can Obtain from Cards
-
-## Problems for Strings
-
-1. Minimum Window Substring
-2. Longest Substring Without Repeating Characters
-3. Substring with Concatenation of All Words
-4. Find All Anagrams in a String
-5. Longest Substring with At Most Two Distinct Characters
-6. Longest Repeating Character Replacement
-7. Longest Substring with At Most K Distinct Characters
-8. Longest Substring with Same Letters after Replacement
-9. Longest Substring with At Least K Repeating Characters
-10. Find All Anagrams in a String
-11. Count Number of Substrings with Exactly K Distinct Characters
-12. Substring with At Least K Distinct Characters
-13. Minimum Number of Steps to Make Two Strings Anagram
-14. Minimum Window Subsequence
-15. Minimum Operations to Make a Uni-Value String
-16. Find the Longest Substring Containing
diff --git a/SlidingWindow/SlidingWindow.md b/SlidingWindow/SlidingWindow.md
deleted file mode 100644
index fe30734..0000000
--- a/SlidingWindow/SlidingWindow.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# Sliding Window Pattern
-
-## Overview
-
-The Sliding Window pattern is a technique used in solving problems involving arrays and strings. It efficiently finds subarrays or substrings that fulfill certain conditions by maintaining a window of elements and moving it across the array or string.
-
-# types
-
-# 1 fixed size
-
-# 2 variable size
-
-## Basic Steps
-
-1. **Initialize**: Set up variables to define the starting point of the window and initialize any necessary data structures.
-2. **Expand and Contract the Window**: Grow the window by expanding it to the right or shrink it by contracting it from the left based on problem constraints.
-3. **Update the Result**: Update the result or track the current state based on the problem's requirements while expanding or contracting the window.
-4. **Move the Window**: Repeat steps 2 and 3 until the window's end reaches the end of the array or string.
-5. **Return the Result**: Return the final result.
-
-## Examples of Problems
-
-- Finding the maximum sum of a subarray of a fixed size.
-- Finding the smallest subarray with a sum greater than or equal to a given value.
-- Finding the longest substring with at most K distinct characters.
-- Finding the longest subarray with contiguous elements.
-- Finding the longest substring without repeating characters.
diff --git a/SlidingWindow/tempCodeRunnerFile.js b/SlidingWindow/tempCodeRunnerFile.js
new file mode 100644
index 0000000..463d871
--- /dev/null
+++ b/SlidingWindow/tempCodeRunnerFile.js
@@ -0,0 +1 @@
+windowStart
\ No newline at end of file
diff --git a/Strings/1.reverseString.js b/Strings/1.reverseString.js
deleted file mode 100644
index 51288f4..0000000
--- a/Strings/1.reverseString.js
+++ /dev/null
@@ -1,27 +0,0 @@
-// Write a function to reverse a string.
-
-function reverseString(inputString) {
-    const reversedArray = [];
-    for (let i = inputString.length - 1; i >= 0; i--) {
-        reversedArray.push(inputString[i]);
-    }
-    return reversedArray.join("");
-}
-
-// Example usage:
-let originalString = "Hello, World!";
-let reversedString = reverseString(originalString);
-console.log("Original String:", originalString);
-console.log("Reversed String:", reversedString);
-/*
-Time Complexity:
-The time complexity of the reverseString function is O(n), where n is the length of the input string.
- This is because the function iterates through each character in the input string exactly once, 
- and the number of iterations is directly proportional to the length of the string.
-
-Space Complexity:
-The space complexity is also O(n). In the optimized approach, we use an array (reversedArray) to store the reversed
- characters. The size of this array is equal to the length of the input string. Therefore, the space complexity is linear with respect to the size of the input.
-
-Time Complexity: O(n)
-Space Complexity: O(n)*/
\ No newline at end of file
diff --git a/Strings/10.checkIFStringhasUniqueChars.js b/Strings/10.checkIFStringhasUniqueChars.js
deleted file mode 100644
index a6f5824..0000000
--- a/Strings/10.checkIFStringhasUniqueChars.js
+++ /dev/null
@@ -1,34 +0,0 @@
-// 10. [*] Write a function to check if a string has all unique characters.
-
-const checkIfStrinhHasAllUniqueChars = (str) => {
-    const inputStr = str.toLowerCase();
-    // check if string is non-empty
-    if (inputStr.length <= 0) {
-        return "string must be contain some characters";
-    }
-    const countCharFrequency = {};
-
-    for (let i = 0; i < inputStr.length; i++) {
-
-        if (countCharFrequency[inputStr[i]]) countCharFrequency[inputStr[i]] += 1; else
-            countCharFrequency[inputStr[i]] = 1;
-    }
-    for (const value in countCharFrequency) {
-        if (countCharFrequency[value] > 1
-        ) {
-            return `String "${str}"  contain  duplicat value`
-        }
-        else
-            return `String "${str}" has all   unique  characters`
-
-    }
-};
-
-const inputString = "Suman singh";
-
-const result = checkIfStrinhHasAllUniqueChars(inputString);
-console.log(result);
-
-
-// Time Complexity: O(n)
-// Space Complexity: O(k)
\ No newline at end of file
diff --git a/Strings/11.ReverseWordsInstring.js b/Strings/11.ReverseWordsInstring.js
deleted file mode 100644
index c3ab9bf..0000000
--- a/Strings/11.ReverseWordsInstring.js
+++ /dev/null
@@ -1,22 +0,0 @@
-// 11. [*] Implement a function to reverse words in a given string.
-
-
-const revreseWordsInString = str => {
-    let inputString = str;
-    inputString = inputString.split(' ');
-    let reverseString = "";
-
-    // string , it must have somewords , it should not be empty 
-    if (inputString.length <= 0) {
-        return "String mshould be contain some words to return"
-    }
-    for (let index = inputString.length - 1; index >= 0; index--) {
-        reverseString += `${inputString[index]} `
-    }
-    return reverseString;
-}
-
-const inputString = "This is a String";
-const result = revreseWordsInString(inputString);
-console.log('original string', inputString);
-console.log('output reversed string', result);
\ No newline at end of file
diff --git a/Strings/15.OccurenceOfChars.js b/Strings/15.OccurenceOfChars.js
deleted file mode 100644
index 746e16b..0000000
--- a/Strings/15.OccurenceOfChars.js
+++ /dev/null
@@ -1,20 +0,0 @@
-// 15. [ ] Create a program to count the number of occurrences of a character in a string.
-
-
-const occurenceOfChar = str => {
-    const inputStr = str.toLowerCase();
-    let charOccurence = {};
-    for (const value of inputStr) {
-        if (charOccurence[value]) {
-            charOccurence[value] += 1;
-        }
-        else {
-            charOccurence[value] = 1;
-        }
-    }
-    return JSON.stringify(charOccurence);
-}
-
-const inputString = "Sumansinghchauhan"
-const result = occurenceOfChar(inputString);
-console.log("char occurence of String :", result);
\ No newline at end of file
diff --git a/Strings/2.Anagrams.js b/Strings/2.Anagrams.js
deleted file mode 100644
index 4ed36b2..0000000
--- a/Strings/2.Anagrams.js
+++ /dev/null
@@ -1,52 +0,0 @@
-// Implement a function to check if two strings are anagrams.
-
-/*An anagram is a word or phrase formed by rearranging the letters of another word or phrase,
-using all the original letters exactly once. Essentially,
- it's a permutation of the letters of a word or phrase to create a new word or phrase.
-
-For example, the word "listen" and "silent" are anagrams of each other because they contain
-the exact same letters.*/
-
-
-
-const checkIsGivenStringAnaGram = (inputString1, inputString12) => {
-    if (inputString1.length !== inputString12.length) {
-        return false; // If the lengths are different, they can't be anagrams
-    }
-    const frequencyCounter = {};
-    // Create frequency counter for str1
-    for (let char of str1) {
-        frequencyCounter[char] = (frequencyCounter[char] || 0) + 1;
-    }
-    // Compare the frequency of each character in both frequency counters
-    for (let char of inputString12) {
-        if (!frequencyCounter[char]) {
-            return false; // If a character is missing or its frequency is 0, they are not anagrams
-        } else {
-            frequencyCounter[char] -= 1; // Decrement the frequency count
-        }
-    }
-    return true; // If all checks pass, the strings are anagrams
-}
-
-console.log(checkIsGivenStringAnaGram("abcd", "dcba")); // Output: true
-console.log(checkIsGivenStringAnaGram("abcd", "abcde")); // Output: false
-console.log(checkIsGivenStringAnaGram("apple", "papel")); // Output: true
-
-/*Time Complexity:
-The time complexity of the areAnagrams function is O(n), where n is the total number of characters
- in both input strings. This is because the function iterates through each character in both strings 
- once to create the frequency counters, and then performs a comparison of the frequency counters,
-  which also takes
-  O(n) time.
-
-Space Complexity:
-The space complexity is O(c), where c is the total number of unique characters across both strings. 
-This is because the frequency counters are stored in objects, and the space required is proportional 
-to the number of unique characters. In the worst case, when the strings contain many unique characters, 
-the space complexity can approach O(n), but it is typically less than that.
-
-In summary:
-
-Time Complexity: O(n)
-Space Complexity: O(c), where c is the number of unique characters across both strings*/
diff --git a/Strings/3.FirstNonReptChar.js b/Strings/3.FirstNonReptChar.js
deleted file mode 100644
index 7265d67..0000000
--- a/Strings/3.FirstNonReptChar.js
+++ /dev/null
@@ -1,28 +0,0 @@
-// 3.[] Create a program to find the first non - repeated character in a string.
-
-
-const findFirstNonReptCharInString = str => {
-
-    let frequnecyOfChars = {};
-
-    for (const value of str) {
-        if (frequnecyOfChars[value]) {
-            frequnecyOfChars[value] += 1;
-        }
-        else {
-            frequnecyOfChars[value] = 1;
-
-        }
-    }
-    for (const value of str) {
-        if (frequnecyOfChars[value] === 1) {
-            return value
-        }
-
-    }
-    console.log("frequnecyOfChars", frequnecyOfChars);
-}
-
-let input = "programming";
-const result = findFirstNonReptCharInString(input);
-console.log(result);
diff --git a/Strings/4.RemoveDuplicatesChars.js b/Strings/4.RemoveDuplicatesChars.js
deleted file mode 100644
index 71f39f7..0000000
--- a/Strings/4.RemoveDuplicatesChars.js
+++ /dev/null
@@ -1,32 +0,0 @@
-// 4. [ *] Write a function to remove duplicate characters from a string.
-
-const removeDuplicateChars = str => {
-    let charFrequency = {};
-    let removeDuplicate = "";
-
-    // Count the frequency of each character
-    for (const char of str) {
-        if (charFrequency[char]) {
-            charFrequency[char] += 1;
-        } else {
-            charFrequency[char] = 1;
-        }
-    }
-
-    // Build the string with unique characters
-    for (const char of str) {
-        if (charFrequency[char] === 1) {
-            removeDuplicate += char;
-            charFrequency[char] = 0; // Set the frequency to 0 to avoid duplicates
-        }
-    }
-
-    return removeDuplicate;
-}
-
-const str = "abcdabcd";
-const result = removeDuplicateChars(str);
-console.log(result);
-
-
-
diff --git a/Strings/5.countVowels.js b/Strings/5.countVowels.js
deleted file mode 100644
index c9fbfbf..0000000
--- a/Strings/5.countVowels.js
+++ /dev/null
@@ -1,19 +0,0 @@
-// 5. [*] Implement a function to count the number of vowels in a string.
-// vowels :  a , e , i ,o ,u
-
-const countNumberOfVowles = (str) => {
-    const vowlesInAlphabets = ["a", "e", "i", "o", "u"];
-    let vowlesInString = [];
-
-    for (const char of str) {
-        if (vowlesInAlphabets.includes(char) && !vowlesInString.includes(char)) {
-            vowlesInString.push(char);
-        }
-    }
-    return vowlesInString;
-};
-
-const inputStr = "My Name is Suman Singh. ";
-const result = countNumberOfVowles(inputStr);
-console.log("vowles presnt in string :", result);
-console.log("number vowles presnt in string :", result.length);
diff --git a/Strings/6.isStringPalindrome.js b/Strings/6.isStringPalindrome.js
deleted file mode 100644
index 7684197..0000000
--- a/Strings/6.isStringPalindrome.js
+++ /dev/null
@@ -1,18 +0,0 @@
-// 6. [*] Create a program to check if a string is a palindrome.
-
-
-const idStringPalindrome = str => {
-    let reverseStr = "";
-    for (let index = str.length - 1; index >= 0; index--) {
-        reverseStr += str[index];
-    }
-    return reverseStr;
-}
-
-const inputStr = "racecar"
-const result = idStringPalindrome(inputStr);
-if (inputStr === result) {
-    console.log(`${inputStr} is a palindrome.`);
-} else {
-    console.log(`${inputStr} is not a palindrome.`);
-}
\ No newline at end of file
diff --git a/Strings/7.replaceSpcaeWith20.js b/Strings/7.replaceSpcaeWith20.js
deleted file mode 100644
index 6de4b1d..0000000
--- a/Strings/7.replaceSpcaeWith20.js
+++ /dev/null
@@ -1,19 +0,0 @@
-
-// 7. [ ] Write a function to replace all spaces in a string with '%20'.
-
-const replaceSpacesWithoutBuiltIn = (inputString) => {
-    let result = '';
-    for (const char of inputString) {
-        if (char === ' ') {
-            result += '%20';
-        } else {
-            result += char;
-        }
-    }
-    return result;
-}
-
-// Example usage:
-const inputString = "Hello World in JavaScript";
-const result = replaceSpacesWithoutBuiltIn(inputString);
-console.log(result);
diff --git a/Strings/8.stringCompression.js b/Strings/8.stringCompression.js
deleted file mode 100644
index ad5577e..0000000
--- a/Strings/8.stringCompression.js
+++ /dev/null
@@ -1,21 +0,0 @@
-// 8. [ ] Implement a function to perform basic string compression using the counts of repeated characters.
-
-
-const basicStringCompression = str => {
-    let countCharFrequency = {};
-    let compressedStr = "";
-
-    for (const value of str) {
-        countCharFrequency[value] ? countCharFrequency[value] += 1 : countCharFrequency[value] = 1;
-    }
-    for (const key in countCharFrequency) {
-        compressedStr += `${key}${countCharFrequency[key]}`
-    }
-    return compressedStr
-
-}
-
-
-const inputString = "aabcccccaaa";
-const result = basicStringCompression(inputString)
-console.log(result);
\ No newline at end of file
diff --git a/Strings/9.longestCommonPrefix.js b/Strings/9.longestCommonPrefix.js
deleted file mode 100644
index bb75887..0000000
--- a/Strings/9.longestCommonPrefix.js
+++ /dev/null
@@ -1,32 +0,0 @@
-// 9. [*] Create a program to find the longest common prefix among an array of strings.
-
-
-const longestCommonPrefix = (strings) => {
-    if (strings.length === 0) {
-        return "";
-    }
-
-    // Sort the array to bring strings with common prefixes together
-    strings.sort();
-
-    // Take the first and last strings after sorting
-    const firstStr = strings[0];
-    const lastStr = strings[strings.length - 1];
-
-    // Compare characters of the first and last strings
-    let commonPrefix = "";
-    for (let i = 0; i < firstStr.length; i++) {
-        if (firstStr[i] === lastStr[i]) {
-            commonPrefix += firstStr[i];
-        } else {
-            break;
-        }
-    }
-
-    return commonPrefix;
-}
-
-// Example usage
-const stringsArray = ["flower", "flow", "foight"];
-const result = longestCommonPrefix(stringsArray);
-console.log("Longest Common Prefix:", result);
diff --git a/Strings/StringsProblems.md b/Strings/StringsProblems.md
deleted file mode 100644
index 11a0d7f..0000000
--- a/Strings/StringsProblems.md
+++ /dev/null
@@ -1,113 +0,0 @@
-# String Data Structures Interview Questions
-
-## Basic Level
-
-1. [*] Write a function to reverse a string.
-2. [*] Implement a function to check if two strings are anagrams.
-3. [*] Create a program to find the first non-repeated character in a string.
-4. [*] Write a function to remove duplicate characters from a string.
-5. [*] Implement a function to count the number of vowels in a string.
-6. [*] Create a program to check if a string is a palindrome.
-7. [*] Write a function to replace all spaces in a string with '%20'.
-8. [*] Implement a function to perform basic string compression using the counts of repeated characters.
-9. [*] Create a program to find the longest common prefix among an array of strings.
-10. [*] Write a function to check if a string has all unique characters.
-
-## Mid-Level
-
-11. [*] Implement a function to reverse words in a given string.
-12. [ ] Create a program to find the longest palindrome substring in a string.
-13. [ ] Write a function to check if one string is a rotation of another.
-14. [ ] Implement a function to perform string matching using the Knuth-Morris-Pratt algorithm.
-15. [*] Create a program to count the number of occurrences of a character in a string.
-16. [ ] Write a function to convert a string to an integer (atoi).
-17. [ ] Implement a function to perform string matching using the Boyer-Moore algorithm.
-18. [ ] Create a program to find the shortest common supersequence of two strings.
-19. [ ] Write a function to perform string matching using the Rabin-Karp algorithm.
-20. [ ] Implement a function to check if a string is an interleaving of two other strings.
-
-## Advanced Level
-
-21. [ ] Create a program to find the longest substring without repeating characters.
-22. [ ] Write a function to check if a string is a valid palindrome, considering only alphanumeric characters and ignoring cases.
-23. [ ] Implement a function to check if a string can be formed by interleaving two given strings.
-24. [ ] Create a program to perform regular expression matching.
-25. [ ] Write a function to find the minimum window substring that contains all characters of a pattern.
-26. [ ] Implement a function to count the number of palindromic substrings in a string.
-27. [ ] Create a program to find the longest repeating substring in a string.
-28. [ ] Write a function to reverse only the vowels of a string.
-29. [ ] Implement a function to check if a string is valid by following a given set of rules.
-30. [ ] Create a program to find the longest word made of other words in a list of words.
-31. [ ] Write a function to perform basic regular expression matching.
-32. [ ] Implement a function to count and say the nth sequence.
-33. [ ] Create a program to generate all possible valid IP addresses from a given string.
-34. [ ] Write a function to find the first non-repeating character in a stream of characters.
-35. [ ] Implement a function to check if a string is a valid number (integer or floating-point).
-36. [ ] Create a program to find the length of the last word in a string.
-37. [ ] Write a function to group anagrams from a list of strings.
-38. [ ] Implement a function to add binary strings.
-39. [ ] Create a program to find the longest subarray with at most two distinct elements.
-40. [ ] Write a function to simplify a Unix-style path.
-41. [ ] Implement a function to add strings representing numbers without using built-in conversion functions.
-42. [ ] Create a program to count the number of substrings with exactly k distinct characters.
-43. [ ] Write a function to find the longest subarray with equal number of 0s and 1s.
-44. [ ] Implement a function to multiply two strings representing numbers.
-45. [ ] Create a program to find the longest substring with at most K distinct characters.
-46. [ ] Write a function to decode a run-length encoded string.
-47. [ ] Implement a function to find the minimum length of the contiguous subarray with the sum at least K.
-48. [ ] Create a program to find the longest substring with the same letters after replacement.
-49. [ ] Write a function to perform wildcard pattern matching.
-50. [ ] Implement a function to find the longest substring with at least K repeating characters.
-
-## Expert Level (continued)
-
-51. [ ] Create a program to count the number of distinct subsequences in a string.
-52. [ ] Write a function to perform string multiplication.
-53. [ ] Implement a function to find the length of the longest substring without repeating characters.
-54. [ ] Create a program to find the shortest palindrome that can be constructed by adding characters to a string.
-55. [ ] Write a function to perform string division.
-56. [ ] Implement a function to find the minimum window substring containing all characters of a pattern.
-57. [ ] Create a program to find the length of the longest alternating subsequence.
-58. [ ] Write a function to check if a string is a valid shuffle of two other strings.
-59. [ ] Implement a function to find the longest contiguous substring without repeating characters.
-60. [ ] Create a program to check if a string is a valid shuffle of two strings with equal lengths.
-61. [ ] Write a function to find the length of the longest substring with at most two distinct characters.
-62. [ ] Implement a function to find the longest substring with at most K distinct characters.
-63. [ ] Create a program to find the length of the longest subarray with equal number of 0s and 1s.
-64. [ ] Write a function to count the number of substrings with the given set of characters.
-65. [ ] Implement a function to find the length of the longest subarray with the sum at least K.
-66. [ ] Create a program to find the longest common prefix of three strings.
-67. [ ] Write a function to find the longest palindrome substring with at most K changes.
-68. [ ] Implement a function to find the longest substring with at least K repeating characters.
-69. [ ] Create a program to find the length of the shortest substring containing all characters of a pattern.
-70. [ ] Write a function to find the length of the longest contiguous substring with at most two distinct characters.
-71. [ ] Implement a function to find the longest substring without repeating characters after K swaps.
-72. [ ] Create a program to find the length of the longest common prefix among a set of strings.
-73. [ ] Write a function to find the length of the longest contiguous substring without repeating characters.
-74. [ ] Implement a function to find the length of the longest substring with at least K distinct characters.
-75. [ ] Create a program to find the length of the longest substring with at most two distinct characters.
-76. [ ] Write a function to find the length of the longest palindrome substring with at most K changes.
-77. [ ] Implement a function to find the length of the longest substring with at least K repeating characters.
-78. [ ] Create a program to find the length of the shortest substring containing all characters of a pattern.
-79. [ ] Write a function to find the length of the longest common prefix of three strings.
-80. [ ] Implement a function to find the length of the longest substring without repeating characters after K swaps.
-81. [ ] Create a program to find the length of the longest common prefix among a set of strings.
-82. [ ] Write a function to find the length of the longest contiguous substring without repeating characters.
-83. [ ] Implement a function to find the length of the longest substring with at least K distinct characters.
-84. [ ] Create a program to find the length of the longest substring with at most two distinct characters.
-85. [ ] Write a function to find the length of the longest palindrome substring with at most K changes.
-86. [ ] Implement a function to find the length of the longest substring with at least K repeating characters.
-87. [ ] Create a program to find the length of the shortest substring containing all characters of a pattern.
-88. [ ] Write a function to find the length of the longest common prefix of three strings.
-89. [ ] Implement a function to find the length of the longest substring without repeating characters after K swaps.
-90. [ ] Create a program to find the length of the longest common prefix among a set of strings.
-91. [ ] Write a function to find the length of the longest contiguous substring without repeating characters.
-92. [ ] Implement a function to find the length of the longest substring with at least K distinct characters.
-93. [ ] Create a program to find the length of the longest substring with at most two distinct characters.
-94. [ ] Write a function to find the length of the longest palindrome substring with at most K changes.
-95. [ ] Implement a function to find the length of the longest substring with at least K repeating characters.
-96. [ ] Create a program to find the length of the shortest substring containing all characters of a pattern.
-97. [ ] Write a function to find the length of the longest common prefix of three strings.
-98. [ ] Implement a function to find the length of the longest substring without repeating characters after K swaps.
-99. [ ] Create a program to find the length of the longest common prefix among a set of strings.
-100.  [ ] Write a function to find the length of the longest contiguous substring without repeating characters.
diff --git a/Throttling .js b/Throttling .js
new file mode 100644
index 0000000..59c156a
--- /dev/null
+++ b/Throttling .js	
@@ -0,0 +1,24 @@
+function throttle(func, delay) {
+    let lastCalled = 0;
+
+    return function (...args) {
+        const now = new Date().getTime();
+        if (now - lastCalled < delay) {
+            return;
+        }
+        lastCalled = now;
+        func.apply(this, args);
+    };
+}
+
+function makeApiRequest() {
+    // Simulate an API request by logging a message after 1 second
+    setTimeout(() => {
+        console.log("API request triggered");
+    }, 1000);
+}
+
+const throttledApiRequest = throttle(makeApiRequest, 1000);
+
+// Add event listener to the button
+document.getElementById("triggerButton").addEventListener("click", throttledApiRequest);
diff --git a/TwoPointer/Arrays/1.2sumpointer.js b/TwoPointer/Arrays/1.2sumpointer.js
deleted file mode 100644
index 865b060..0000000
--- a/TwoPointer/Arrays/1.2sumpointer.js
+++ /dev/null
@@ -1,32 +0,0 @@
-// 1. [ ] Two Sum: Given an array of integers, return indices of the two numbers such 
-// that they add up to a specific target.
-
-const twoSum = (nums, target) => {
-    // Sort the array to use two-pointer technique
-    let left = 0;
-    let right = nums.length - 1;
-
-    while (left < right) {
-        const sum = nums[left] + nums[right];
-        if (sum === target) {
-            // Find the original indices of the numbers
-            const index1 = nums.indexOf(nums[left]);
-            let index2 = nums.lastIndexOf(nums[right]);
-            // If both indices are the same, search for another occurrence of the number
-            if (index1 === index2) {
-                index2 = nums.indexOf(nums[right], index1 + 1);
-            }
-            return [index1, index2];
-        } else if (sum < target) {
-            left++;
-        } else {
-            right--;
-        }
-    }
-    return [];
-}
-
-const nums = [2, 7, 11, 15, 2, 7, 3];
-const target = 22;
-const result = twoSum(nums, 10)
-console.log(result);
diff --git a/TwoPointer/Arrays/2.squareofSortedArray.js b/TwoPointer/Arrays/2.squareofSortedArray.js
deleted file mode 100644
index f2b6254..0000000
--- a/TwoPointer/Arrays/2.squareofSortedArray.js
+++ /dev/null
@@ -1,25 +0,0 @@
-// 2. [ ] Squares of a Sorted Array: Given an integer array nums sorted in non-decreasing order,
-//  return an array of the squares of each number sorted in non-decreasing order.
-
-const sortedSquares = (nums) => {
-    const n = nums.length;
-    let result = new Array(n);
-    let left = 0;
-    let right = n - 1;
-
-    for (let i = n - 1; i >= 0; i--) {
-        if (Math.abs(nums[left]) > Math.abs(nums[right])) {
-            result[i] = nums[left] * nums[left];
-            left++;
-        } else {
-            result[i] = nums[right] * nums[right];
-            right--;
-        }
-    }
-
-    return result;
-}
-
-const nums = [-4, -1, 0, 3, 10];
-console.log("arr", nums);
-console.log("square", sortedSquares(nums)); 
diff --git a/TwoPointer/Arrays/2Sum.js b/TwoPointer/Arrays/2Sum.js
deleted file mode 100644
index 922306d..0000000
--- a/TwoPointer/Arrays/2Sum.js
+++ /dev/null
@@ -1,29 +0,0 @@
-
-/*Two Sum Problem:
-Problem Statement:
-Given an array of integers, return indices of the two numbers 
-such that they add up to a specific target. */
-function twoSum(nums, target) {
-    let left = 0;
-    let right = nums.length - 1;
-
-    while (left < right) {
-        const sum = nums[left] + nums[right];
-        if (sum === target) {
-            return [left, right];
-        } else if (sum < target) {
-            left++;
-        } else {
-            right--;
-        }
-    }
-
-    return null; // If no solution is found
-}
-
-// Example usage:
-const nums = [2, 7, 11, 15];
-const target = 9;
-const result = twoSum(nums, target);
-console.log(result); // Output: [0, 1]
-
diff --git a/TwoPointer/Arrays/3.removeDuplicate.js b/TwoPointer/Arrays/3.removeDuplicate.js
deleted file mode 100644
index 6573059..0000000
--- a/TwoPointer/Arrays/3.removeDuplicate.js
+++ /dev/null
@@ -1,22 +0,0 @@
-
-// 3. [ ] Remove Duplicates from Sorted Array: Given a sorted array nums, remove the duplicates in-place such
-// that each element appears only once and returns the new length.
-
-
-function removeDuplicates(nums) {
-    if (nums.length === 0) return 0;
-    let uniqueIndex = 0;
-    for (let i = 1; i < nums.length; i++) {
-        if (nums[i] !== nums[uniqueIndex]) {
-            uniqueIndex++;
-            nums[uniqueIndex] = nums[i];
-        }
-    }
-
-    return uniqueIndex + 1;
-}
-
-let nums = [0, 0, 1, 1, 2, 2, 3, 3, 4];
-let length = removeDuplicates(nums);
-console.log("New length:", length);
-console.log("Array after removing duplicates:", nums.slice(0, length)); 
diff --git a/TwoPointer/Arrays/3Sum.js b/TwoPointer/Arrays/3Sum.js
deleted file mode 100644
index e18b770..0000000
--- a/TwoPointer/Arrays/3Sum.js
+++ /dev/null
@@ -1,71 +0,0 @@
-/*given an array nums of n integers, are these elements  a , b ,c in nums such that a+b+c=0?
-find all unique  triples in the array which the sum of zero notice that the solution set must not contain 
-duplicate triples*/
-
-const threeSumBruteForce = (nums, target) => {
-    // Initialize an empty array to store the result.
-    const result = [];
-    const n = nums.length
-    // Loop through each element in the array up to the third-to-last element.
-    for (let i = 0; i < n; i++) {
-        // Loop through each element in the array starting from the next element after 'i'.
-        for (let j = i + 1; j < n; j++) {
-            // Loop through each element in the array starting from the next element after 'j'.
-            for (let k = j + 1; k < n; k++) {
-                // Check if the sum of the current triplet (nums[i], nums[j], nums[k]) is equal to the target.
-                if (nums[i] + nums[j] + nums[k] === target) {
-                    // If the sum is equal to the target, push the triplet into the 'result' array.
-                    result.push([nums[i], nums[j], nums[k]]);
-                }
-            }
-        }
-    }
-
-    // Return the final result array containing all triplets that sum up to the target.
-    return result;
-};
-
-// Example usage:
-// Define an array 'nums' and a target value 'target'.
-let nums = [-1, 0, 1, 2, -1, -4];
-let target = 0;
-
-// Call the 'threeSumBruteForce' function with the provided 'nums' and 'target'.
-// Print the result to the console.
-console.log(threeSumBruteForce(nums, target));
-
-
-
-function threeSumClosest(nums, target) {
-    const result = [];
-    nums.sort((a, b) => a - b);
-
-    for (let i = 0; i < nums.length - 2; i++) {
-        let j = i + 1;
-        let k = nums.length - 1;
-
-        while (j < k) {
-            const sum = nums[i] + nums[j] + nums[k];
-
-            if (sum === target) {
-                // If the sum is equal to the target, push the triplet into the 'result' array.
-                result.push([nums[i], nums[j], nums[k]]);
-            }
-
-            if (sum < target) {
-                j++;
-            } else {
-                k--;
-            }
-        }
-    }
-
-    return result;
-}
-
-// Example usage:
-
-const result = threeSumClosest(nums, target);
-console.log(result);
-
-
diff --git a/TwoPointer/Arrays/PairTwoSome.js b/TwoPointer/Arrays/PairTwoSome.js
deleted file mode 100644
index fc152b0..0000000
--- a/TwoPointer/Arrays/PairTwoSome.js
+++ /dev/null
@@ -1,31 +0,0 @@
-
-/*Pair Sum in Array: Given an array and a target sum,
- find if there are two elements in the array that add up to the target sum.
- also return pair*/
-
-function hasPairWithSum(arr, target) {
-    let left = 0, right = arr.length - 1;
-
-    while (left < right) {
-        const currentSum = arr[left] + arr[right];
-
-        if (currentSum === target) {
-            // Return an object indicating the pair exists and provide the pair array
-            return { doesPairExist: true, pair: [arr[left], arr[right]] };
-        }
-
-        if (currentSum < target) left++;
-        else right--;
-    }
-
-    // If no pair is found, return an object indicating that
-    return { doesPairExist: false, pair: [] };
-}
-
-
-
-const arr = [1, 2, 3, 5, 6, 9];
-const targetSum = 12;
-const result = hasPairWithSum(arr, targetSum)
-console.log("pairExist", result.doesPairExist);
-console.log("pair", result.pair);
diff --git a/TwoPointer/Arrays/SumUptoSpecificTarget.js b/TwoPointer/Arrays/SumUptoSpecificTarget.js
deleted file mode 100644
index 2a0f668..0000000
--- a/TwoPointer/Arrays/SumUptoSpecificTarget.js
+++ /dev/null
@@ -1,23 +0,0 @@
-// Given a sorted array, find two elements that sum up to a specific target.
-
-function twoSumToSpecificGivenTarget(arr, target) {
-    let left = 0,
-        right = arr.length - 1;
-    while (left < right) {
-        let sum = arr[left] + arr[right];
-        if (sum === target) {
-            return [arr[left], arr[right]];
-        } if (sum < target) {
-            left++;
-        } else {
-            right--;
-        }
-    }
-
-    return [];
-}
-
-
-const array = [2, 7, 11, 15, 18];
-const targetSum = 26;
-console.log(twoSumToSpecificGivenTarget(array, targetSum));
diff --git a/TwoPointer/Arrays/TwoPointerArray.md b/TwoPointer/Arrays/TwoPointerArray.md
deleted file mode 100644
index 87d5044..0000000
--- a/TwoPointer/Arrays/TwoPointerArray.md
+++ /dev/null
@@ -1,30 +0,0 @@
-1. [ *] Two Sum: Given an array of integers, return indices of the two numbers such that they add up to a specific target.
-2. [ ] Squares of a Sorted Array: Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order.
-3. [ ] Remove Duplicates from Sorted Array: Given a sorted array nums, remove the duplicates in-place such that each element appears only once and returns the new length.
-4. [ ] Remove Element: Given an array nums and a value val, remove all instances of that value.
-5. [ ] Merge Sorted Array: Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.
-6. [ ] Sort Colors: Given an array nums with n objects colored red, white, or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white, and blue.
-7. [ ] Dutch National Flag Problem: Given an array with n objects colored red, white, or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white, and blue.
-8. [ ] Container With Most Water: Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate (i, ai), n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which, together with the x-axis forms a container, such that the container contains the most water.
-9. [ ] Trapping Rain Water: Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.
-10. [ ] Three Sum: Find all unique triplets in the array which gives the sum of zero.
-11. [ ] Remove Nth Node From End of List: Given the head of a linked list, remove the nth node from the end of the list and return its head.
-12. [ ] Reverse Linked List: Given the head of a singly linked list, reverse the list, and return its head.
-13. [ ] Merge Two Sorted Lists: Merge two sorted linked lists and return it as a sorted list. The list should be made by splicing together the nodes of the first two lists.
-14. [ ] Intersection of Two Linked Lists: Write a program to find the node at which the intersection of two singly linked lists begins.
-15. [ ] Linked List Cycle: Given head, the head of a linked list, determine if the linked list has a cycle in it.
-16. [ ] Valid Parentheses: Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
-17. [ ] Remove Duplicates from Sorted List: Given the head of a sorted linked list, delete all duplicates such that each element appears only once.
-18. [ ] Partition List: Given the head of a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.
-19. [ ] Next Permutation: Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.
-20. [ ] Implement strStr(): Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.
-21. [ ] Search in Rotated Sorted Array: There is an integer array nums sorted in ascending order (with distinct values). Prior to being passed to your function, nums is rotated at an unknown pivot index k (0 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed). For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and become [4,5,6,7,0,1,2]. Given the array nums after the rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums.
-22. [ ] Container With Most Water: Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate (i, ai), n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which, together with the x-axis forms a container, such that the container contains the most water.
-23. [ ] Partition Array Into Three Parts With Equal Sum: Given an array of integers arr, return true if we can partition the array into three non-empty parts with equal sums.
-24. [ ] Number of Subarrays with Bounded Maximum: We are given an array nums of positive integers, and two positive integers left and right (left <= right). Return the number of (contiguous, non-empty) subarrays such that the value of the maximum array element in that subarray is at least left and at most right.
-25. [ ] Subarray Product Less Than K: Given an array of integers nums and an integer k, return the number of contiguous subarrays where the product of all the elements in the subarray is strictly less than k.
-26. [ ] Sum of Subarray Minimums: Given an array of integers arr, find the sum of min(b) where b ranges over every (contiguous) subarray of arr. Since the answer may be large, return the answer modulo 10^9 + 7.
-27. [ ] Valid Mountain Array: Given an array of integers arr, return true if and only if it is a valid mountain array.
-28. [ ] Maximum Width Ramp: Given an array nums of integers, a ramp is a tuple (i, j) for which i < j and nums[i] <= nums[j]. The width of such a ramp is j - i. The maximum width of a ramp in nums is the largest such ramp width.
-29. [ ] Longest Mountain in Array: Let's call any (contiguous) subarray B (of A) a mountain if the following properties hold: B.length >= 3, There exists some 0 < i < B.length - 1 such that B[0] < B[1] < ... B[i - 1] < B[i] > B[i + 1] > ... > B[B.length - 1] (Note that B could be any subarray of A, including the entire array A.). Given an array A of integers, return the length of the longest mountain. Return 0 if there is no mountain.
-30. [ ] Interval List Intersections: Given two lists of closed intervals, return the intersection of these two interval lists.
diff --git a/TwoPointer/String/LongestSubStirngWTrepeat.js b/TwoPointer/String/LongestSubStirngWTrepeat.js
deleted file mode 100644
index cc07c06..0000000
--- a/TwoPointer/String/LongestSubStirngWTrepeat.js
+++ /dev/null
@@ -1,20 +0,0 @@
-// Problem 2: Longest Substring Without Repeating Characters
-// Problem Statement:
-// Given a string, find the length of the longest substring without repeating characters.
-
-function lengthOfLongestSubstring(s) {
-    const charIndex = {};
-    let maxLength = 0, start = 0;
-
-    for (let i = 0; i < s.length; i++) {
-        if (charIndex[s[i]] !== undefined && charIndex[s[i]] >= start) {
-            start = charIndex[s[i]] + 1;
-        }
-        charIndex[s[i]] = i;
-        maxLength = Math.max(maxLength, i - start + 1);
-    }
-
-    return maxLength;
-}
-
-console.log(lengthOfLongestSubstring("abcabcbb"));
diff --git a/TwoPointer/String/ReverseWoerdsInString.js b/TwoPointer/String/ReverseWoerdsInString.js
deleted file mode 100644
index 18dd4cf..0000000
--- a/TwoPointer/String/ReverseWoerdsInString.js
+++ /dev/null
@@ -1,10 +0,0 @@
-// Problem 3: Reverse Words in a String
-// Problem Statement:
-// Given an input string, reverse the order of the words.
-
-function reverseWords(s) {
-    const words = s.split(/\s+/).filter(word => word.length > 0);
-    return words.reverse().join(' ');
-}
-
-console.log(reverseWords("the sky is blue"));
\ No newline at end of file
diff --git a/TwoPointer/String/TwoPointerString.md b/TwoPointer/String/TwoPointerString.md
deleted file mode 100644
index 4c4f3d1..0000000
--- a/TwoPointer/String/TwoPointerString.md
+++ /dev/null
@@ -1,35 +0,0 @@
-1. [*] Valid Palindrome: Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
-2. [*] Longest Substring Without Repeating Characters: Given a string s, find the length of the longest substring without repeating characters.
-3. [*] Longest Palindromic Substring: Given a string s, return the longest palindromic substring in s.
-4. [*] Minimum Window Substring: Given two strings s and t, return the minimum window in s which will contain all the characters in t in complexity O(n).
-5. [*] Implement strStr(): Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.
-6. [*] Longest Common Prefix: Write a function to find the longest common prefix string amongst an array of strings.
-7. [*] Valid Parentheses: Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
-8. [*] Implement Regular Expression Matching: Given an input string (s) and a pattern (p), implement regular expression matching with support for '.' and '\*'.
-9. [*] Wildcard Matching: Given an input string (s) and a pattern (p), implement wildcard pattern matching with support for '?' and '\*'.
-10. [*] Generate Parentheses: Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
-11. [*] Count and Say: The count-and-say sequence is a sequence of digit strings defined by the recursive formula:
-    - countAndSay(1) = "1"
-    - countAndSay(n) is the way you would "say" the digit string from countAndSay(n-1), which is then converted into a different digit string.
-12. [*] Integer to Roman: Given an integer, convert it to a roman numeral.
-13. [*] Roman to Integer: Given a roman numeral, convert it to an integer.
-14. [*] Longest Common Subsequence: Given two strings text1 and text2, return the length of their longest common subsequence.
-15. [*] Edit Distance: Given two strings word1 and word2, return the minimum number of operations required to convert word1 to word2.
-16. [*] Longest Palindromic Subsequence: Given a string s, find the longest palindromic subsequence's length in s.
-17. [*] Minimum ASCII Delete Sum for Two Strings: Given two strings s1, s2, find the lowest ASCII sum of deleted characters to make two strings equal.
-18. [*] Palindrome Partitioning II: Given a string s, partition s such that every substring of the partition is a palindrome. Return the minimum cuts needed for a palindrome partitioning of s.
-19. [*] Longest Repeating Substring: Given a string s, find out the length of the longest repeating substring(s). Return 0 if no repeating substring exists.
-20. [*] Longest Substring with At Least K Repeating Characters: Find the length of the longest substring T of a given string (consists of lowercase letters only) such that every character in T appears no less than k times.
-21. [*] Find All Anagrams in a String: Given two strings s and p, return an array of all the start indices of p's anagrams in s. You may return the answer in any order.
-22. [*] Valid Palindrome II: Given a string s, return true if the s can be palindrome after deleting at most one character from it.
-23. [*] Shortest Palindrome: Given a string s, you are allowed to convert it to a palindrome by adding characters in front of it. Find and return the shortest palindrome you can find by performing this transformation.
-24. [*] Count Substrings with Only One Distinct Letter: Given a string S, return the number of substrings that have only one distinct letter.
-25. [*] Find All Duplicates in a String: Given a string, find all the duplicates in it.
-26. [*] Shortest Word Distance: Given a list of words and two words word1 and word2, return the shortest distance between these two words in the list.
-27. [*] Shortest Word Distance II: Design a data structure that will be initialized with a list of words. You will be given a string word1 and a string word2, and you will return the shortest distance between these two words in the list.
-28. [*] Minimum Window Subsequence: Given strings S and T, find the minimum (contiguous) substring W of S, so that T is a subsequence of W.
-29. [*] Longest Chunked Palindrome Decomposition: Return the largest possible k such that there exists a_1, a_2, ..., a_k such that:
-    - Each a_i is a non-empty string;
-    - Their concatenation a_1 + a_2 + ... + a_k is equal to text;
-    - For all 1 <= i <= k, a*i = a*{k+1 - i}.
-30. [*] Find All Anagrams in a String: Given a string s and a non-empty string p, find all the start indices of p's anagrams in s.
diff --git a/TwoPointer/String/validPalindrome.js b/TwoPointer/String/validPalindrome.js
deleted file mode 100644
index 6d61e83..0000000
--- a/TwoPointer/String/validPalindrome.js
+++ /dev/null
@@ -1,26 +0,0 @@
-
-
-// Problem 1: Valid Palindrome
-// Problem Statement:
-// Given a
-//  string, determine if it is a palindrome, considering 
-//  only alphanumeric characters and ignoring cases.
-
-function isPalindrome(s) {
-    s = s.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
-    let left = 0, right = s.length - 1;
-
-    while (left < right) {
-        if (s[left] !== s[right]) {
-            return false;
-        }
-        left++;
-        right--;
-    }
-
-    return true;
-}
-
-
-
-console.log(isPalindrome(abcd));
\ No newline at end of file
diff --git a/TwoPointer/TwoPointer.md b/TwoPointer/TwoPointer.md
deleted file mode 100644
index 11b1316..0000000
--- a/TwoPointer/TwoPointer.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# Two Pointer Technique
-
-The two-pointer technique is a strategy used in algorithms to efficiently solve problems involving arrays or linked lists by employing two pointers that traverse the data structure in a specific manner.
-
-## Advantages
-
-- **Efficiency**: It optimizes time complexity to solve problems efficiently in linear or logarithmic time.
-- **Reduced Space Complexity**: Often, the technique avoids using additional space other than the pointers.
-- **Avoids Nested Loops**: It eliminates the need for nested iterations, leading to better performance.
-
-## Principles
-
-### 1. Two Pointers Approach
-
-- **Initialization**: Start with two pointers at different positions within the array or linked list.
-
-- **Traversal Criteria**: Move pointers based on certain conditions or criteria.
-
-- **Termination Condition**: Continue traversal until pointers meet or fulfill a specific condition.
-
-### 2. Techniques
-
-#### a. Slow and Fast Pointers
-
-- **Application**: Used when one pointer moves slower than the other.
-- **Example**: Detecting cycles in a linked list.
-
-#### b. Start from Different Ends
-
-- **Application**: Both pointers start from opposite ends, converging towards each other.
-- **Example**: Finding a pair in a sorted array that meets specific criteria.
-
-## Use Cases
-
-1. **Searching and Sorting**: Finding elements or ranges efficiently.
-2. **Finding Pairs**: Determining pairs that satisfy given conditions.
-3. **Checking Palindromes**: Verifying sequences, especially in linked lists.
-4. **Optimizing Algorithms**: Reducing time complexity in certain scenarios.
-
-## Considerations
-
-- **Problem Analysis**: Understand when the technique is applicable.
-- **Pointer Manipulation**: Adjust pointers based on specific conditions.
-- **Edge Cases**: Handle scenarios where pointers reach ends or null values.
-- # **Time Complexity**: Evaluate how this technique optimizes the solution.
-
-- # some use cases
-  use when array is sorted
-  descre time complexity
-  2 sum , or three suma problem
-
-# OR
-
-# Two Pointer is Normally used for searching and it use two pointer,
-
-in one loop over the given data structure. This is a quite common approach
-which is used to solve coding problems, mostly related to strings, arrays, linked list.
-
-In order to use two pointer, most of the times the data structure needs to be ordered in some way, which helps us to reduce the time complexity from O(n^2) or O(n^3) of just one loop with two pointer and search each item at one.
-
-So depending on whether the input string/array is sorted or not, the two-pointer method can take O(nlogn) time complexity or even better which is O(n).
-
-## Variants of 2 pointer
-
-1. **Opposite Direction (Two Pointers):**
-   One Pointer starts from the beginning while the other pointer starts from the end.
-   They move towards each other until they both meet or some condition is satisfied.
-   In the "Opposite Direction" scenario, you typically have two pointers starting from opposite ends of an array (or data structure) and moving towards each other until they meet or a certain condition is satisfied. This approach is commonly used in problems involving sorted arrays.
-
-2. **Equi-Direction:**
-   Both start from the beginning, One Slow-runner and the other fast-runner.
-   In the "Equi-Direction" scenario, you have two pointers both starting from the same end of the array and moving at different speeds. The "fast" pointer moves faster than the "slow" pointer. This approach is often used in problems involving linked lists or arrays where you need to identify a certain condition.
diff --git a/bindPolyFill.js b/bindPolyFill.js
new file mode 100644
index 0000000..6960804
--- /dev/null
+++ b/bindPolyFill.js
@@ -0,0 +1,26 @@
+let name = {
+    firstName: "suman",
+    lastName: "chauhan",
+}
+
+let name2 = {
+    firstName: "Summi",
+    lastName: "chauhan",
+}
+
+let printName = function (homeTown, state, country) {
+    console.log(this.firstName + " " + this.lastName + " " + "from" + " " + homeTown + " " + state + " " + country);
+}
+
+let printMyName = printName.bind(name, "Tehri", "Uttrakhand")
+printMyName("india")
+
+Function.prototype.myBind = function (...args) {
+    let obj = this;
+    return function (...args2) {
+        return obj.apply(args[0], [...args.slice(1), args2]); // Added return statement
+    }
+}
+
+let printMyName2 = printName.myBind(name2, "Dehradoon", "Uttrakhand")
+printMyName2("india")
diff --git a/callApllyBind.js b/callApllyBind.js
new file mode 100644
index 0000000..968ba89
--- /dev/null
+++ b/callApllyBind.js
@@ -0,0 +1,21 @@
+
+let name = {
+    firstName: "suman",
+    lastName: "chauhan",
+
+}
+let printFullName = function (homeTown, state) {
+    console.log(this.firstName + " " + this.lastName + " " + "from" + " " + homeTown + " " + state);
+}
+printFullName.call(name, "Tehri", "Uttrakhand")
+
+let name2 = {
+    firstName: "suman",
+    lastName: "chauhan2",
+}
+
+printFullName.apply(name, ["Tehri11", "Uttrakhand111"])
+
+
+let printMyName = printFullName.bind(name2, ["Tehri11", "Uttrakhand111"])
+console.log("printMyName", printMyName);
\ No newline at end of file
diff --git a/callBackfunction.js b/callBackfunction.js
new file mode 100644
index 0000000..b7258e9
--- /dev/null
+++ b/callBackfunction.js
@@ -0,0 +1,31 @@
+// setTimeout(function () {
+//     console.log("timer");
+// }, 5000);
+
+// function x(y) {
+//     console.log("x");
+//     y();
+// }
+// x(function () {
+//     console.log("y");
+// });
+
+
+function clickHandler(event) {
+    console.log("button clicked", clickHandler.count++);
+}
+
+function attachEventListener() {
+    clickHandler.count = 1; // Initialize count as a property of the function
+    document.addEventListener("click", clickHandler);
+}
+
+function removeEventListener() {
+    document.removeEventListener("click", clickHandler);
+}
+
+attachEventListener();
+// To remove the event listener, call removeEventListener()
+// removeEventListener();
+
+
diff --git a/callbackHell.js b/callbackHell.js
new file mode 100644
index 0000000..0df06fb
--- /dev/null
+++ b/callbackHell.js
@@ -0,0 +1,53 @@
+const cart = ["shoes", "pants", "Kurta"];
+
+// Function to simulate API calls with the same function names
+function apiOperation(data, callback) {
+    setTimeout(function () {
+        // Simulating API response
+        callback();
+    }, 1000 * 5); // Delayed by 1 second for demonstration
+}
+
+apiOperation(cart, function createOrder() {
+    console.log("Order created");
+    apiOperation(null, function proceedToPayment() {
+        console.log("Proceeded to payment");
+        apiOperation(null, function showOrderSummary() {
+            console.log("Order summary displayed");
+            apiOperation(null, function updateWallet() {
+                console.log("Wallet updated");
+                apiOperation(null, function applyDiscount() {
+                    console.log("Discount applied");
+                    apiOperation(null, function verifyPayment() {
+                        console.log("Payment verified");
+                        apiOperation(null, function sendConfirmationEmail() {
+                            console.log("Confirmation email sent");
+                            apiOperation(null, function notifyShipping() {
+                                console.log("Shipping notified");
+                                apiOperation(null, function trackOrder() {
+                                    console.log("Order tracked");
+                                    apiOperation(null, function showThankYouPage() {
+                                        console.log("Thank you page shown");
+                                        apiOperation(null, function requestFeedback() {
+                                            console.log("Feedback requested");
+                                            apiOperation(null, function showSurvey() {
+                                                console.log("Survey shown");
+                                                apiOperation(null, function updateCustomerProfile() {
+                                                    console.log("Customer profile updated");
+                                                    apiOperation(null, function logAnalytics() {
+                                                        console.log("Analytics logged");
+                                                        console.log("All operations completed!");
+                                                    });
+                                                });
+                                            });
+                                        });
+                                    });
+                                });
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    });
+});
diff --git a/debaunce.js b/debaunce.js
new file mode 100644
index 0000000..b51599d
--- /dev/null
+++ b/debaunce.js
@@ -0,0 +1,43 @@
+let counter = 0;
+const fruits = [
+    "Apple",
+    "Banana",
+    "Orange",
+    "Grape",
+    "Strawberry",
+    "Watermelon",
+    "Pineapple",
+    "Mango",
+    "Kiwi",
+    "Blueberry",
+    "Peach",
+    "Cherry",
+    "Pear",
+    "Lemon",
+    "Raspberry",
+    "Cantaloupe",
+    "Plum",
+    "Apricot",
+    "Pomegranate",
+    "Coconut",
+];
+
+const handleSearch = () => {
+    let searchValue = document.getElementById("searchInput").value;
+    const fruitList = fruits.filter((fruit) => fruit.includes(searchValue));
+    console.log("fruitList", fruitList);
+};
+const doSomeMagic = function (fn, delay) {
+    let timer;
+    return function () {
+        let context = this;
+        args = arguments;
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            handleSearch.apply(context, arguments);
+            clearTimeout(timer);
+        }, delay);
+    };
+};
+
+const betterFunction = doSomeMagic(handleSearch, 1000);
diff --git a/funtions.js b/funtions.js
new file mode 100644
index 0000000..798aa65
--- /dev/null
+++ b/funtions.js
@@ -0,0 +1,14 @@
+var acc = 1;
+a();
+b();
+console.log(acc);
+function a() {
+    const acc = 10;
+    console.log(acc);
+    console.log(bb);
+    const bb = 22;
+}
+function b() {
+    const acc = 100;
+    console.log(acc);
+}
diff --git a/higherOrderFunction.js b/higherOrderFunction.js
new file mode 100644
index 0000000..606e5ca
--- /dev/null
+++ b/higherOrderFunction.js
@@ -0,0 +1,57 @@
+const listRadiuses = [2, 6, 7, 8, 3, 9];
+
+// without higher order functions
+const calculateArea = function (radiuses) {
+    const output = [];
+    for (const radius of radiuses) {
+        output.push(Math.PI * radius * radius);
+    }
+    return output;
+};
+
+console.log("Area of circle ", calculateArea(listRadiuses));
+
+const calculateCircumference = function (radiuses) {
+    const output = [];
+    for (const radius of radiuses) {
+        output.push(2 * Math.PI * radius);
+    }
+    return output;
+};
+
+console.log("Area of circumference ", calculateCircumference(listRadiuses));
+
+const calculateDiameter = function (radiuses) {
+    const output = [];
+    for (const radius of radiuses) {
+        output.push(2 * radius);
+    }
+    return output;
+};
+
+console.log("Area of Diameter ", calculateDiameter(listRadiuses));
+
+// with higher order function
+const area = function (radius) {
+    return Math.PI * radius * radius;
+};
+
+const circumference = function (radius) {
+    return 2 * Math.PI * radius;
+};
+const diameter = function (radius) {
+    return 2 * radius;
+};
+
+const calculate = function (radiuses, logic) {
+    const output = [];
+    for (const radius of radiuses) {
+        output.push(logic(radius));
+    }
+    return output;
+};
+
+
+console.log("calculate area", calculate(listRadiuses, area));
+console.log("calculate circumference", calculate(listRadiuses, circumference));
+console.log("calculate diameter", calculate(listRadiuses, diameter));
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..4035797
--- /dev/null
+++ b/index.html
@@ -0,0 +1,117 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>JavaScript Topics</title>
+    <link
+rel="stylesheet"
+href="https://static-exp1.licdn.com/sc/h/8fx9nkd7mx8avdpqm5hqcbi97"
+/>
+    <link rel="stylesheet" href="./style.css" />
+    <!-- <script src="./script.js" defer></script> -->
+    <!-- <script src="./funtions.js" defer></script> -->
+    <!-- <script src="./scopeChain.js"></script> -->
+    <!-- <script src="./Let&ConstTempoZone.js"></script> -->
+        <!-- <script src="./BlockScope.js"></script> -->
+        <!-- <script src="./Closures .js"></script> -->
+  <!-- <script src="./SetTimeOutclosure.js"></script> -->
+ <!-- <script src="./ClosureQuestion.js"></script> -->
+ <!-- <script src="./callBackfunction.js"></script> -->
+ <!-- <script src="./higherOrderFunction.js"></script> -->
+ <!-- <script src="./callbackHell.js"></script> -->
+
+ <!-- <script src="./Promise.js"></script> -->
+ <!-- <script src="./thisKeyword.js"></script> -->
+ <!-- <script src="./SetInJs.js"></script> -->
+ <!-- <script src="./maps.js"></script> -->
+ <!-- <script src="./callApllyBind.js"></script> -->
+ <!-- <script src="./bindPolyFill.js"></script> -->
+ <!-- <script src="./debaunce.js"></script> -->
+
+ <script
+ src="https://platform.linkedin.com/badges/js/profile.js"
+ async
+ defer
+ type="text/javascript"
+></script>
+
+
+  </head>
+  <header>
+    <div class="container">
+      <h1>JavaScript Topics</h1>
+      <button id="triggerButton">Trigger API Request for throttle</button>
+      <button id="clickMe" onclick="alert(this)">Click Me</button>
+      <button id="clickMe1" onclick="alert(this.tagName)">Click Me1</button>
+      <div
+      class="badge-base LI-profile-badge"
+      data-locale="en_US"
+      data-size="medium"
+      data-theme="dark"
+      data-type="VERTICAL"
+      data-vanity="suman-singh-6085741aa"
+      data-version="v1"
+    ></div>    
+      <nav>
+        <ul>
+          <li><a href="#core-concepts">Core Concepts</a></li>
+          <li><a href="#advanced-concepts">Advanced Concepts</a></li>
+          <li><a href="#additional-topics">Additional Topics</a></li>
+        </ul>
+       
+      </nav>
+    </div>
+    <input type="text" id="searchInput" placeholder="Search..." onkeyup="betterFunction()">  </header>
+  
+  <section id="core-concepts" class="topic-list">
+    <div class="container">
+      <h2>Core Concepts</h2>
+      <ul>
+        <li>Variables and Data Types</li>
+        <li>Functions</li>
+        <li>Objects</li>
+        <li>Arrays</li>
+        <li>Conditional Statements</li>
+        <li>Loops</li>
+      </ul>
+    </div>
+  </section>
+  
+  <section id="advanced-concepts" class="topic-list">
+    <div class="container">
+      <h2>Advanced Concepts</h2>
+      <ul>
+        <li>Scope and Closures</li>
+        <li>Hoisting</li>
+        <li>Callback Functions</li>
+        <li>Promises</li>
+        <li>Async/Await</li>
+        <li>Event Handling</li>
+      </ul>
+    </div>
+  </section>
+
+  <section id="additional-topics" class="topic-list">
+    <div class="container">
+      <h2>Additional Topics</h2>
+      <ul>
+        <li>DOM Manipulation</li>
+        <li>HTTP Requests (AJAX)</li>
+        <li>Local Storage</li>
+        <li>ES6+ Features</li>
+      </ul>
+    </div>
+  </section>
+
+  <footer>
+    <div class="container">
+      <p>&copy; 2024 JavaScript Topics</p>
+    </div>
+  </footer>
+</body>
+<script src="./Throttling .js"></script>
+<!-- <script src="./ProtoType.js"></script> -->
+<!-- <script src="./ProtoType.js"></script> -->
+
+</html>
\ No newline at end of file
diff --git a/interviewAsks/ImplementStack.js b/interviewAsks/ImplementStack.js
deleted file mode 100644
index c5ab395..0000000
--- a/interviewAsks/ImplementStack.js
+++ /dev/null
@@ -1,40 +0,0 @@
-class Stack {
-    constructor() {
-        this.stack = [];
-    }
-
-    push(item) {
-        this.stack.push(item);
-    }
-
-    pop() {
-        if (this.isEmpty()) {
-            throw new Error('Stack is empty');
-        }
-        return this.stack.pop();
-    }
-
-    peek() {
-        if (this.isEmpty()) {
-            throw new Error('Stack is empty');
-        }
-        return this.stack[this.stack.length - 1];
-    }
-
-    isEmpty() {
-        return this.stack.length === 0;
-    }
-}
-
-// Example usage
-const stack = new Stack();
-stack.push(1);
-stack.push(2);
-stack.push(3);
-
-console.log(stack.peek()); // 3
-console.log(stack.pop());  // 3
-console.log(stack.pop());  // 2
-console.log(stack.isEmpty());  // false
-console.log(stack.pop());  // 1
-console.log(stack.isEmpty());  // true
diff --git a/interviewAsks/RadndomNum.js b/interviewAsks/RadndomNum.js
deleted file mode 100644
index b255339..0000000
--- a/interviewAsks/RadndomNum.js
+++ /dev/null
@@ -1,8 +0,0 @@
-function getRandomNumber(min, max) {
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-const min = 1;
-const max = 100;
-const randomNumber = getRandomNumber(min, max);
-console.log(randomNumber);
diff --git a/interviewAsks/RemoveKthNodeLinkedList.js b/interviewAsks/RemoveKthNodeLinkedList.js
deleted file mode 100644
index 73da4ac..0000000
--- a/interviewAsks/RemoveKthNodeLinkedList.js
+++ /dev/null
@@ -1,50 +0,0 @@
-// remove kth nocde form linked list 
-
-class ListNode {
-    constructor(val = 0, next = null) {
-        this.val = val;
-        this.next = next;
-    }
-}
-
-function removeNthFromEnd(head, n) {
-    let dummy = new ListNode(0);
-    dummy.next = head;
-    let first = dummy;
-    let second = dummy;
-
-    // Move the second pointer n+1 steps ahead
-    for (let i = 1; i <= n + 1; i++) {
-        second = second.next;
-    }
-
-    // Move both pointers until the second pointer reaches the end
-    while (second !== null) {
-        first = first.next;
-        second = second.next;
-    }
-
-    // Remove the k-th node and return it
-    let removedNode = first.next;
-    first.next = first.next.next;
-
-    return removedNode;
-}
-
-// Example usage:
-let head = new ListNode(1);
-head.next = new ListNode(2);
-head.next.next = new ListNode(3);
-head.next.next.next = new ListNode(4);
-head.next.next.next.next = new ListNode(5);
-
-let k = 2;
-let removedNode = removeNthFromEnd(head, k);
-
-console.log("Removed node:", removedNode.val);
-
-let current = head;
-while (current !== null) {
-    console.log(current.val);
-    current = current.next;
-}
diff --git a/interviewAsks/combination.js b/interviewAsks/combination.js
deleted file mode 100644
index a67db19..0000000
--- a/interviewAsks/combination.js
+++ /dev/null
@@ -1,37 +0,0 @@
-function permute(arr) {
-    let result = [];
-
-    function swap(a, b) {
-        let temp = arr[a];
-        arr[a] = arr[b];
-        arr[b] = temp;
-    }
-
-    function generate(n) {
-        if (n === 1) {
-            result.push(Number(arr.join("")));
-            return;
-        }
-
-        for (let i = 0; i < n; i++) {
-            generate(n - 1);
-            if (n % 2 === 0) {
-                swap(i, n - 1);
-            } else {
-                swap(0, n - 1);
-            }
-        }
-    }
-
-    generate(arr.length);
-    return result;
-}
-
-let n = 3;
-let arr = [];
-for (let i = 1; i <= n; i++) {
-    arr.push(i);
-}
-
-let permutations = permute(arr);
-console.log("Permutations:", permutations);
diff --git a/interviewAsks/reverseString.js b/interviewAsks/reverseString.js
deleted file mode 100644
index 7f3efe5..0000000
--- a/interviewAsks/reverseString.js
+++ /dev/null
@@ -1,16 +0,0 @@
-// reverse a string 
-
-
-function reverseString(inputStr) {
-    let reverseStr = "";
-    for (let i = inputStr.length - 1; i >= 0; i--) {
-
-        reverseStr += inputStr[i]
-    }
-    return reverseStr;
-}
-
-const str = "suman singh";
-
-const result = reverseString(str);
-console.log(result);
\ No newline at end of file
diff --git a/interviewAsks/sortArray.js b/interviewAsks/sortArray.js
deleted file mode 100644
index 91644bc..0000000
--- a/interviewAsks/sortArray.js
+++ /dev/null
@@ -1,26 +0,0 @@
-// sort an  array of integers
-
-
-function sortArrayOfInteger(arr) {
-    const n = arr.length;
-    let swapped;
-
-    for (let i = 0; i < n - 1; i++) {
-        swapped = false;
-        for (let j = 0; j < n - 1 - i; j++) {
-            if (arr[j] > arr[j + 1]) {
-                const temp = arr[j];
-                arr[j] = arr[j + 1];
-                arr[j + 1] = temp;
-                swapped = true;
-            }
-        }
-        if (!swapped) break; // If no swaps were made, the array is already sorted
-    }
-
-    return arr;
-}
-
-const arr = [2, 5, 1, 3, 6, 0, 9, 4];
-const result = sortArrayOfInteger(arr);
-console.log(result);
diff --git a/maps.js b/maps.js
new file mode 100644
index 0000000..cb4c696
--- /dev/null
+++ b/maps.js
@@ -0,0 +1,33 @@
+// Creating a Map
+const myMap = new Map();
+
+// Adding key-value pairs to the Map
+myMap.set(1, 'John');
+myMap.set(true, 30);
+myMap.set("fun", function name(params) {
+
+});
+
+// Retrieving values from the Map
+console.log("Name:", myMap.get('name')); // Output: John
+console.log("Age:", myMap.get('age')); // Output: 30
+console.log("City:", myMap.get('city')); // Output: New York
+
+// Checking if a key exists in the Map
+console.log("Does the Map contain key 'name'?", myMap.has('name')); // Output: true
+console.log("Does the Map contain key 'gender'?", myMap.has('gender')); // Output: false
+
+// Getting the size of the Map
+console.log("Size of the Map:", myMap.size); // Output: 3
+
+// Deleting a key from the Map
+myMap.delete('city');
+
+// Iterating over the Map
+console.log("Iterating over the Map:");
+myMap.forEach((value, key) => {
+    console.log(key, ":", value);
+});
+
+// Clearing the Map
+myMap.clear();
diff --git a/scopeChain.js b/scopeChain.js
new file mode 100644
index 0000000..dd5dd23
--- /dev/null
+++ b/scopeChain.js
@@ -0,0 +1,10 @@
+
+
+function a() {
+    var b = 10;
+    c();
+    function c() {
+        console.log(b);
+    }
+}
+a();
\ No newline at end of file
diff --git a/script.js b/script.js
new file mode 100644
index 0000000..6fce8eb
--- /dev/null
+++ b/script.js
@@ -0,0 +1,11 @@
+
+
+var x = 7;
+
+function getName() {
+    console.log("Hello js");
+}
+
+getName();
+console.log(x);
+console.log(getName);
\ No newline at end of file
diff --git a/search/BinarySerach/binary.js b/search/BinarySerach/binary.js
deleted file mode 100644
index 20081ea..0000000
--- a/search/BinarySerach/binary.js
+++ /dev/null
@@ -1,39 +0,0 @@
-function binarySearchRecursive(arr, target, left = 0, right = arr.length - 1) {
-    if (left > right) {
-        return -1; // Not found
-    }
-
-    let mid = Math.floor((left + right) / 2);
-
-    if (arr[mid] === target) {
-        return mid;
-    } else if (arr[mid] < target) {
-        return binarySearchRecursive(arr, target, mid + 1, right);
-    } else {
-        return binarySearchRecursive(arr, target, left, mid - 1);
-    }
-}
-
-let arr = [1, 3, 5, 7, 9, 11, 13, 15];
-let target = 7;
-let index = binarySearchRecursive(arr, target);
-console.log(index);
-
-function binarySearch(arr, target) {
-    let left = 0;
-    let right = arr.length - 1;
-
-    while (left <= right) {
-        let mid = Math.floor((left + right) / 2);
-
-        if (arr[mid] === target) {
-            return mid;
-        } else if (arr[mid] < target) {
-            left = mid + 1;
-        } else {
-            right = mid - 1;
-        }
-    }
-
-    return -1; // Not found
-}
diff --git a/search/BinarySerach/binarySearch.js b/search/BinarySerach/binarySearch.js
deleted file mode 100644
index 3613084..0000000
--- a/search/BinarySerach/binarySearch.js
+++ /dev/null
@@ -1,23 +0,0 @@
-function binarySearch(arr, target) {
-    let left = 0;
-    let right = arr.length - 1;
-
-    while (left <= right) {
-        let mid = Math.floor((left + right) / 2);
-
-        if (arr[mid] === target) {
-            return mid;
-        } else if (arr[mid] < target) {
-            left = mid + 1;
-        } else {
-            right = mid - 1;
-        }
-    }
-
-    return -1; // Not found in array
-}
-
-let arr = [1, 3, 5, 7, 9, 11, 13, 15, 20];
-let target = 7;
-let index = binarySearch(arr, target);
-console.log(index); 
diff --git a/searching/BinarySearch.js b/searching/BinarySearch.js
deleted file mode 100644
index b1e09f2..0000000
--- a/searching/BinarySearch.js
+++ /dev/null
@@ -1,26 +0,0 @@
-// Binary search is a technique used to quickly find a value in a sorted array.
-
-function binarySearch(arr, target) {
-    let left = 0;
-    let right = arr.length - 1;
-
-    while (left <= right) {
-        let mid = Math.floor((left + right) / 2);
-        // Math.floor is a function in JavaScript that returns the largest integer less than or equal to a given number.
-
-        if (arr[mid] === target) {
-            return mid;
-        } else if (arr[mid] < target) {
-            left = mid++;
-        } else {
-            right = mid--;
-        }
-    }
-
-    return -1;
-}
-
-const arr = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21];
-const target = 17;
-const index = binarySearch(arr, target);
-console.log(index);
diff --git a/searching/linerSearch.js b/searching/linerSearch.js
deleted file mode 100644
index 870e21b..0000000
--- a/searching/linerSearch.js
+++ /dev/null
@@ -1,17 +0,0 @@
-// Write a function called linearSearch which accepts an array and a value, 
-// and returns the index at which the value exists. 
-// If the value does not exist in the array, return -1.
-
-
-function linearSearch(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i] === val) {
-            return i;
-        }
-    }
-    return -1;
-}
-
-const arr = [10, 20, 30, 40, 50];
-console.log(linearSearch(arr, 30));
-console.log(linearSearch(arr, 70)); 
diff --git a/searching/searchoccurence.js b/searching/searchoccurence.js
deleted file mode 100644
index f1539e3..0000000
--- a/searching/searchoccurence.js
+++ /dev/null
@@ -1,24 +0,0 @@
-function findFirstOccurrence(nums, target) {
-    let left = 0;
-    let right = nums.length - 1;
-    let result = -1;
-
-    while (left <= right) {
-        let mid = Math.floor((left + right) / 2);
-        if (nums[mid] === target) {
-            result = mid; // Update result but continue searching for the first occurrence
-            right = mid - 1; // Continue searching in the left subarray
-        } else if (nums[mid] < target) {
-            left = mid + 1;
-        } else {
-            right = mid - 1;
-        }
-    }
-
-    return result;
-}
-
-// Example usage
-const nums = [1, 2, 2, 2, 4, 5, 6];
-const target = 2;
-console.log(findFirstOccurrence(nums, target)); // Output: 1 (index of the first occurrence of 2)
diff --git a/sorting/Insertion Sort/insertingsort.js b/sorting/Insertion Sort/insertingsort.js
deleted file mode 100644
index afd7686..0000000
--- a/sorting/Insertion Sort/insertingsort.js	
+++ /dev/null
@@ -1,16 +0,0 @@
-const insertionSort = (arr) => {
-    for (let i = 1; i < arr.length; i++) {
-        let currentVal = arr[i];
-        let j = i - 1;
-        while (j >= 0 && arr[j] > currentVal) {
-            arr[j + 1] = arr[j];
-            j--;
-        }
-        arr[j + 1] = currentVal;
-    }
-    return arr;
-}
-
-// Example usage
-let arr = [5, 3, , 7, 0, 8, 4, , 5, 7, 92];
-console.log(insertionSort(arr)); 
diff --git a/sorting/bubblesort/Bubblesort.js b/sorting/bubblesort/Bubblesort.js
deleted file mode 100644
index 7240879..0000000
--- a/sorting/bubblesort/Bubblesort.js
+++ /dev/null
@@ -1,24 +0,0 @@
-// Bubble sort is a simple sorting algorithm that repeatedly steps through the list,
-//  compares adjacent elements, and swaps them if they are
-// in the wrong order. The pass through the list is repeated until the list is sorted.
-//  It's not efficient for large datasets, but it's easy to understand and implement,
-//   making it suitable for educational purposes or small datasets
-
-function bubbleSort(arr) {
-    const len = arr.length;
-    for (let i = 0; i < len; i++) {
-        for (let j = 0; j < len - 1; j++) {
-            if (arr[j] > arr[j + 1]) {
-                // Swap elements
-                const temp = arr[j];
-                arr[j] = arr[j + 1];
-                arr[j + 1] = temp;
-            }
-        }
-    }
-    return arr;
-}
-
-const array = [64, 34, 25, 12, 22, 11, 90];
-console.log("Original Array:", array);
-console.log("Sorted Array:", bubbleSort(array));
diff --git a/sorting/bubblesort/bubblesortStep.js b/sorting/bubblesort/bubblesortStep.js
deleted file mode 100644
index a64c8b0..0000000
--- a/sorting/bubblesort/bubblesortStep.js
+++ /dev/null
@@ -1,33 +0,0 @@
-
-// Problem: Write a function bubbleSortSteps that takes an array of numbers and returns 
-// an array of arrays representing each step of the bubble sort algorithm. Each inner array 
-// should represent the state of the array after one pass of the algorithm 
-// (with the largest unsorted element bubbled to 
-//     its correct position). The final inner array should be the sorted array.
-
-const bubbleSortSteps = (arr) => {
-    const steps = [];
-    const len = arr.length;
-    for (let i = 0; i < len; i++) {
-        let swapped = false;
-        for (let j = 0; j < len - i - 1; j++) {
-            if (arr[j] > arr[j + 1]) {
-                // Swap elements
-                const temp = arr[j];
-                arr[j] = arr[j + 1];
-                arr[j + 1] = temp;
-                swapped = true;
-            }
-        }
-        // If no swap occurred, the array is already sorted
-        if (!swapped) {
-            break;
-        }
-        steps.push([...arr]); // Save a copy of the current state
-    }
-    steps.push([...arr]); // Save the final sorted array
-    return steps;
-}
-
-const arr = [64, 34, 25, 12, 22, 11, 90];
-console.log(bubbleSortSteps(arr));
diff --git a/sorting/bubblesort/comprBubble.js b/sorting/bubblesort/comprBubble.js
deleted file mode 100644
index 9b59d0d..0000000
--- a/sorting/bubblesort/comprBubble.js
+++ /dev/null
@@ -1,22 +0,0 @@
-// Problem: Modify the bubbleSort function to also accept a comparator function as a second argument.
-//  The comparator function should take two arguments (a and b) and return a negative number if
-//   a should come before b, a positive number if b should come before a, or 0 if they are equal.
-
-
-const bubbleSortComp = (arr, comparator) => {
-    const len = arr.length;
-    for (let i = 0; i < len; i++) {
-        for (let j = 0; j < len - i - 1; j++) {
-            if (comparator(arr[j], arr[j + 1]) > 0) {
-                const temp = arr[j];
-                arr[j] = arr[j + 1];
-                arr[j + 1] = temp;
-            }
-        }
-    }
-    return arr;
-}
-
-const arr = [64, 34, 25, 12, 22, 11, 90];
-const comparator = (a, b) => a - b;
-console.log(bubbleSortComp(arr, comparator)); 
diff --git a/sorting/mergesort/mergesort.js b/sorting/mergesort/mergesort.js
deleted file mode 100644
index 21ac86b..0000000
--- a/sorting/mergesort/mergesort.js
+++ /dev/null
@@ -1,32 +0,0 @@
-function mergeSort(arr) {
-    if (arr.length <= 1) {
-        return arr;
-    }
-
-    const middle = Math.floor(arr.length / 2);
-    const left = arr.slice(0, middle);
-    const right = arr.slice(middle);
-
-    return merge(mergeSort(left), mergeSort(right));
-}
-
-function merge(left, right) {
-    let result = [];
-    let leftIndex = 0;
-    let rightIndex = 0;
-
-    while (leftIndex < left.length && rightIndex < right.length) {
-        if (left[leftIndex] < right[rightIndex]) {
-            result.push(left[leftIndex]);
-            leftIndex++;
-        } else {
-            result.push(right[rightIndex]);
-            rightIndex++;
-        }
-    }
-
-    return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
-}
-
-let numbers = [4, 2, 5, 1, 3, 9];
-console.log(mergeSort(numbers)); 
diff --git a/sorting/selectionsort/descSort.js b/sorting/selectionsort/descSort.js
deleted file mode 100644
index 7bf5d93..0000000
--- a/sorting/selectionsort/descSort.js
+++ /dev/null
@@ -1,18 +0,0 @@
-const selectionSortDescending = (arr) => {
-    const len = arr.length;
-    for (let i = 0; i < len - 1; i++) {
-        let maxIdx = i;
-        for (let j = i + 1; j < len; j++) {
-            if (arr[j] > arr[maxIdx]) {
-                maxIdx = j;
-            }
-        }
-        if (maxIdx !== i) {
-            [arr[i], arr[maxIdx]] = [arr[maxIdx], arr[i]];
-        }
-    }
-    return arr;
-}
-
-const arr = [64, 34, 2520, 0, 5, 7, 3, 90];
-console.log(selectionSortDescending(arr)); 
diff --git a/sorting/selectionsort/selectionsort.js b/sorting/selectionsort/selectionsort.js
deleted file mode 100644
index 43048f4..0000000
--- a/sorting/selectionsort/selectionsort.js
+++ /dev/null
@@ -1,55 +0,0 @@
-
-/*Selection Sort
-
-Definition: Selection Sort is a simple sorting algorithm that divides the input array 
-into two parts: the sorted subarray and the unsorted subarray. Initially, the sorted subarray 
-is empty, and the unsorted subarray is the entire input array. The algorithm selects the smallest
- (or largest, depending on the sorting order) element from the unsorted subarray and swaps it with the 
- leftmost unsorted element, thus expanding the sorted subarray's boundary by one element.
-
-Algorithm:
-
-Repeat until the unsorted subarray becomes empty:
-Find the minimum element in the unsorted subarray.
-Swap the minimum element with the leftmost unsorted element.
-Complexity:
-
-Time Complexity: O(n^2) for all cases (best, average, and worst).
-Space Complexity: O(1) as it requires only a constant amount of additional space.
-Advantages:
-
-Simple implementation.
-In-place sorting algorithm (doesn't require extra space).
-Good for small arrays or when auxiliary memory is limited.
-Disadvantages:
-
-Inefficient for large arrays due to its O(n^2) time complexity.
-Not stable (relative order of equal elements may change).
-Example:
-
-Input Array: [64, 25, 12, 22, 11]
-Step 1: [11, 25, 12, 22, 64] (11 is the smallest, swap with the first element)
-Step 2: [11, 12, 25, 22, 64] (12 is the smallest in the remaining, swap with the second element)
-Step 3: [11, 12, 22, 25, 64] (22 is the smallest in the remaining, swap with the third element)
-Step 4: [11, 12, 22, 25, 64] (25 is the smallest in the remaining, swap with the fourth element)
-Step 5: [11, 12, 22, 25, 64] (64 is already in the correct position)*/
-
-const selectionSort = (arr) => {
-    const len = arr.length;
-    for (let i = 0; i < len - 1; i++) {
-        let minIndex = i;
-        for (let j = i + 1; j < len; j++) {
-            if (arr[j] < arr[minIndex]) {
-                minIndex = j;
-            }
-        }
-        if (minIndex !== i) {
-            [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
-        }
-    }
-    return arr;
-}
-
-const arr = [64, 25, 12, 22, 11];
-console.log("Original Array:", arr);
-console.log("Sorted Array:", selectionSort(arr));
diff --git a/style.css b/style.css
new file mode 100644
index 0000000..9924598
--- /dev/null
+++ b/style.css
@@ -0,0 +1,75 @@
+body {
+  font-family: "Arial", sans-serif;
+  margin: 0;
+  padding: 0;
+  background-color: #f9f9f9;
+  color: #333;
+}
+
+.container {
+  width: 80%;
+  margin: 0 auto;
+}
+
+header {
+  background-color: #3498db;
+  color: #fff;
+  text-align: center;
+  padding: 1em 0;
+}
+
+h1,
+h2 {
+  color: #3498db;
+}
+
+.topic-list {
+  margin: 20px 0;
+  padding: 20px 0;
+  background-color: #fff;
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+  border-radius: 8px;
+}
+
+ul {
+  list-style-type: none;
+  padding: 0;
+}
+
+li {
+  padding: 10px 0;
+  border-bottom: 1px solid #eee;
+}
+
+li:last-child {
+  border-bottom: none;
+}
+
+footer {
+  background-color: #3498db;
+  color: #fff;
+  text-align: center;
+  padding: 1em 0;
+  position: fixed;
+  bottom: 0;
+  width: 100%;
+}
+#searchInput {
+  width: 300px;
+  padding: 10px;
+  font-size: 16px;
+}
+
+#searchResults {
+  list-style-type: none;
+  padding: 0;
+}
+
+#searchResults li {
+  padding: 5px 10px;
+  cursor: pointer;
+}
+
+#searchResults li:hover {
+  background-color: #f0f0f0;
+}
diff --git a/tempCodeRunnerFile.js b/tempCodeRunnerFile.js
new file mode 100644
index 0000000..4d19f5d
--- /dev/null
+++ b/tempCodeRunnerFile.js
@@ -0,0 +1 @@
+Tehri
\ No newline at end of file
diff --git a/thisKeyword.js b/thisKeyword.js
new file mode 100644
index 0000000..68e6595
--- /dev/null
+++ b/thisKeyword.js
@@ -0,0 +1,100 @@
+
+/* 00:00 🔑 JavaScript's "this" keyword can be confusing for many and behaves differently in various scenarios.
+00:55 🔑 The behavior of the "this" keyword depends on the context, such as whether it's in a function, global space, or an arrow function.
+04:17 🔑 In the global space, the value of "this" is the global object, which can vary depending on the JavaScript runtime environment (e.g., window in browsers, Global in Node.js).
+07:30 🔑 Inside a function, the value of "this" can be undefined in strict mode or the global object in non-strict mode.
+10:06 🔑 JavaScript uses a mechanism called "this substitution," where "this" is replaced with the global object when it's undefined or null in non-strict mode.
+16:11 🔑 Inside an object's method, "this" refers to the object itself where the method is called.
+21:11 🔑 "call," "apply," and "bind" are important functions used to manipulate the value of "this" when calling methods and sharing them between objects.
+26:23 🔑 It's essential to understand "call," "apply," and "bind" to effectively control the value of "this" in JavaScript methods.
+27:30 🔑 In global space, the 'this' keyword refers to the global object (e.g., 'window' in the browser).
+28:08 🔑 In strict mode, 'this' inside a function is undefined; in non-strict mode, it refers to the global object.
+35:23 🔑 Understanding "this" substitution: When 'this' is undefined or null inside a function, it becomes the global object.
+39:59 🔑 Inside an object's method, 'this' refers to the object itself.
+44:12 🔑 The 'call' method can be used to invoke a function with a specific 'this' context.
+46:01 🔑 Arrow functions do not have their own 'this' binding and take the value of the enclosing lexical context.
+48:46 🔑 In the context of DOM elements, 'this' refers to the specific HTML element being interacted with. */
+
+"use strict"
+
+/*Global Context:
+ *******this keyword in global space
+When used outside of any function, this refers to the global object.
+In browsers, the global object is window, while in Node.js, it's global. 
+In web development, the "window" object is a global object that represents
+ the browser window or frame that contains the document being viewed.
+
+*/
+
+console.log("global space", this);
+
+// this inside a function
+function x() {
+    // depend on strict  mode 
+    console.log("this inside a function ", this);
+}
+
+//this in a non-strict mode  - (this substitutions)
+// if the value of this keyword is undefined or
+// null this will be replaced with global object(only in non-strict mode)
+
+// this keyword value depend upton how it is calling 
+x()
+window.x()
+
+
+
+// this inside object's method 
+
+const student = {
+    name: "Suman Singh",
+    printName: function () {
+        console.log("this inside object's method ", this);
+        console.log(" this.a", this.name);
+    }
+}
+student.printName()
+
+const student2 = {
+    name: "Suman Chauhan",
+}
+
+student.printName.call(student2)
+
+// call apply bind methods (sharing )
+
+
+
+//inside arrow function
+
+// arrow function dose not have their own this keyword it use it's lexical this
+
+const obj = {
+    name: "Suman Chauhan",
+    x: () => {
+        console.log("this inside arrow", this);
+    }
+}
+
+obj.x()
+const obj2 = {
+    name: "Suman Chauhan",
+    x: function () {
+        console.log("this outer inside nested arrow", this);
+        return () => {
+            console.log("this inside nested arrow", this);
+        };
+    }
+};
+
+obj2.x()
+
+
+// this keyword in dom
+// value is reference  to html element 
+
+
+let arr1 = [1, 2, 5]
+let arr2 = [1, 2, 5]
+arr1 = [...arr1, ...arr2]
+console.log("arr1", arr1);
\ No newline at end of file
