first commit

Author: bibhuti9

.idea/leet code.iml

@@ -0,0 +1,50 @@
+/*
+Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
+You may assume that each input would have exactly one solution, and you may not use the same element twice.
+You can return the answer in any order.
+
+*/
+
+/*
+    https://leetcode.com/problems/two-sum/discuss/2388388/100-fastest-solution-java-script-solution-0n
+
+*/
+
+/*  TIME COMPLEXITY IS O(logn) */
+
+/*
+
+Example 1:
+
+Input: nums = [2,7,11,15], target = 9
+Output: [0,1]
+Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+Example 2:
+
+Input: nums = [3,2,4], target = 6
+Output: [1,2]
+Example 3:
+
+Input: nums = [3,3], target = 6
+Output: [0,1]
+*/
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+    var s = 0;  //initilize a pointer to 0
+    for (let i = 1; i < nums.length; i++) { //itterate 1 to length
+        if ((nums[s] + nums[i]) == target) {    //check the pointer is equal to the target number or not
+            return [s, i];  //return if both sum are equal to the target
+        }
+        if (i == nums.length - 1) { //if i equal to the length-1 then reinitilize it's to s+1
+            i = s + 1;
+            s++;
+        }
+    }
+}
+var nums = [3, 2, 4], target = 6;
+console.log(twoSum(nums, target));

.idea/misc.xml

@@ -0,0 +1,76 @@
+/*
+    125. Valid Palindrome
+    https://leetcode.com/problems/valid-palindrome/
+*/
+
+/*  TIME COMPLEXITY O(N) */
+
+/*
+Example 1:
+
+Input: s = "A man, a plan, a canal: Panama"
+Output: true
+Explanation: "amanaplanacanalpanama" is a palindrome.
+Example 2:
+
+Input: s = "race a car"
+Output: false
+Explanation: "raceacar" is not a palindrome.
+*/
+
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+
+//Create a function to check that the whole string is palindrom or not
+//This function is the main function to check our string is valid palindrom or not
+function check_palindrom(s) {
+    let pointer = s.length - 1; // Make a pointer which is start form length
+    for (let i = 0; i < s.length / 2; i++, pointer--) {
+        if (s[i] != s[pointer]) {   // Check is the Ith possition value and pointer possition value is equal or not 
+            return false;   // return false if any of character is not equal we don't require to itterate whole string
+        }
+    }
+    return true;    // Return true if all condition is satisfy
+}
+
+// Method 1
+// This Below method is basically used for non-regex method.
+
+var isPalindrome = function (s) {
+    // Make a array which is used to store all non-alphanumeric characters.
+    s = s.toLowerCase();    // Convert whole string to lower case.
+    var ansArray = [];
+    for (let i = 0; i < s.length; i++) {
+        // The bellow condition is used to check that the number should be a-z or 0-9
+        if ((s.charCodeAt(i) >= 97 && s.charCodeAt(i) <= 122) || (s.charCodeAt(i) >= 48 && (s.charCodeAt(i) <= 57))) {
+            ansArray.push(s[i]) // If the condition is true then add this value to the array
+        }
+    }
+    // Here The join function is used to convert  array to string.
+    return check_palindrom(ansArray.join(""));
+};
+
+
+// Method 2
+// Below method is basically used for use regex
+
+var isPalindrome = function (s) {
+    // the below replace method is basically used to remove all non-alphanumeric character
+    // And the lower function is used for convert whole string to lower case
+    s = s.replace(/[^A-Za-z0-9]/g, '').toLowerCase();
+    // Convert whole string to lower case.
+    // Here The join function is used to convert  array to string.
+    return check_palindrom(s);
+};
+
+console.log(isPalindrome("0P"));
+console.log(isPalindrome("A man, a plan, a canal: Panama"));
+// char Code
+// a = 97
+// z = 122
+// A = 65
+// Z = 90
+// 0 = 48
+// 9 = 57

.idea/modules.xml

@@ -0,0 +1,46 @@
+/* 13. Roman to Integer
+https://leetcode.com/problems/roman-to-integer/
+*/
+
+/*  TIME COMPLEXITY IS O(N) */
+
+/*
+Example 1:
+
+Input: s = "III"
+Output: 3
+Explanation: III = 3.
+Example 2:
+
+Input: s = "LVIII"
+Output: 58
+Explanation: L = 50, V= 5, III = 3.
+Example 3:
+
+Input: s = "MCMXCIV"
+Output: 1994
+Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
+*/
+
+var romanToInt = function (s) {
+    // Create A Map
+    const map = {
+        'I': 1,
+        'V': 5,
+        'X': 10,
+        'L': 50,
+        'C': 100,
+        'D': 500,
+        'M': 1000
+    }
+    let ans = 0;
+    for (let i = 0; i < s.length; i++) {
+        const cur = map[s[i]], next = map[s[i + 1]];
+        //check that the current indext value is smaller than the next index value or not if the current value smaller than next value return current value as minus(-) value.
+        ans += cur < next ? -cur : cur;
+    }
+    return ans;
+};
+romanToInt("MCMXCIV");
+//Input :MCMXCIV
+//Output:1994

.idea/vcs.xml

@@ -0,0 +1,46 @@
+/*
+14. Longest Common Prefix
+
+https://leetcode.com/problems/longest-common-prefix/
+
+https://leetcode.com/problems/longest-common-prefix/discuss/2396181/easiest-java-script-solution-on2
+*/
+
+/*  TIME COMPLEXITY IS O(N2) */
+
+/*
+Example 1:
+
+Input: strs = ["flower","flow","flight"]
+Output: "fl"
+Example 2:
+
+Input: strs = ["dog","racecar","car"]
+Output: ""
+Explanation: There is no common prefix among the input strings.
+*/
+
+/**
+ * @param {string[]} strs
+ * @return {string}
+ */
+var longestCommonPrefix = function (strs) {
+    var firstIndexStr = strs[0], ans = "";
+    if (strs[0] == "") return "";   //if string contain blank
+    if (strs.length == 1) return strs[0]    //return if string contain only one word
+    for (let i = 0; i < firstIndexStr.length; i++) {    //this loop is used for check the firstWord all character with it's respective to other word character.
+        var count = 1;  //use count veriable to check that all character satisfy with all word character or not.
+        for (let j = 1; j < strs.length; j++) {
+            if (strs[j][i] == firstIndexStr[i]) {   //here we check string First Word with other character words
+                count++;    //if the character match with other character than increment to +1
+            }
+        }
+        if (count == strs.length) { //check that all word character satisfy with all character or not.
+            ans += firstIndexStr[i];
+        } else {
+            return ans.length > 0 ? ans : ""; //chect that the ans length should be greater than 1 than return ans otherwise return "";
+        }
+    }
+    return ans;
+};
+console.log(longestCommonPrefix(["flower", "flower", "flower", "flower"]));

.idea/workspace.xml

@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+    nums.sort((a, b) => a - b);
+
+    let res = [];
+    for (let i = 0; i < nums.length - 2; i++) {
+
+        // skipping the duplicate elements
+        if (i > 0 && nums[i] == nums[i - 1]) continue;
+        let j = i + 1;
+        let k = nums.length - 1;
+
+        // Two sum approach
+        while (j < k) {
+            let sum = nums[j] + nums[k];
+
+            if (sum == -nums[i]) {
+                res.push([nums[i], nums[j], nums[k]]);
+                // skipping the duplicate elements
+                while (nums[j] == nums[j + 1]) j++;
+                while (nums[k] == nums[k - 1]) k--;
+                k--;
+                j++;
+            }
+            else if (sum > -nums[i]) {
+                k--;
+            }
+            else {
+                j++;
+            }
+        }
+    }
+    return res;
+};
+
+console.log(threeSum([-1, 0, 1, 2, -1, -4]));

Easy/1. Two Sum.js

@@ -0,0 +1,40 @@
+/*
+    1752. Check if Array Is Sorted and Rotated  
+    https://leetcode.com/problems/check-if-array-is-sorted-and-rotated/
+
+*/
+
+/*  TIME COMPLEXITY O(N) */
+
+/*
+Example 1:
+
+Input: nums = [3,4,5,1,2]
+Output: true
+Explanation: [1,2,3,4,5] is the original sorted array.
+You can rotate the array by x = 3 positions to begin on the the element of value 3: [3,4,5,1,2].
+Example 2:
+
+Input: nums = [2,1,3,4]
+Output: false
+Explanation: There is no sorted array once rotated that can make nums.ś
+
+*/
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var check = function (nums) {
+    let count = 0;      // Make a count veriable
+    for (let i = 1; i < nums.length; i++) {
+        if (nums[i - 1] > nums[i]) {    // Check that if the i-1 index value should be greater then i possition value
+            count++;
+        }
+    }
+    if (nums[nums.length - 1] > nums[0]) {      // this condition is basically used for to check last index value to first index value.
+        count++;
+    }
+    return count <= 1;  // return if the count is 0 or 1 then it will true or false.
+};
+console.log(check([2, 1, 3, 4]));