feat: Solved 11 Leetcode problems

Author: ralvarezdev

daily/2024-july/easy/intersection-of-two-arrays-ii.js renamed to monthly/2024-july/easy/intersection-of-two-arrays-ii.js

@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function(s) {
+    let max=0, map, counter
+
+    for(let i=0;i<s.length&&max<s.length-i;i++)
+    {
+        map = new Map()
+        counter=0
+
+        for(let j=i;j<s.length;j++)
+            if(map.get(s[j])!==undefined)
+                break
+            else{
+                map.set(s[j], true)
+                counter++
+            }
+
+        if(counter>max)
+            max=counter
+    }
+
+    return max
+};

monthly/2024-july/easy/longest-substring-without-repeating-characters.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @param {number} time
+ * @return {number}
+ */
+var passThePillow = function(n, time) {
+    let person, t=0
+
+    while(t<time){
+        let i=1
+
+        for(;i<n&& t<time;i++, t++)
+            person=i
+
+        if(t===time){
+            person=i
+            break}
+
+        for(i=n-1;i>0&&t<time;i--, t++)
+            person=i
+    }
+    return person
+};

monthly/2024-july/easy/pass-the-pillow.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var removeDuplicates = function(nums) {
+    let k=0, prevNum=null
+
+    for(const num of nums)
+        if(num!==prevNum||prevNum===null){
+            prevNum=num
+            nums[k++]=num
+        }
+
+    return k
+};

monthly/2024-july/easy/remove-duplicates-from-sorted-array.js

@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @param {number} val
+ * @return {number}
+ */
+var removeElement = function(nums, val) {
+    let k=0
+
+    for(const num of nums)
+        if(num!==val)
+            nums[k++]=num
+
+    return k
+};

monthly/2024-july/easy/remove-element.js

@@ -0,0 +1,51 @@
+/*
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ *
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function(l1, l2) {
+    if(l1===null)
+        return l2
+    if(l2===null)
+        return l1
+
+    const head=l1
+    let prev, accum=0, val=0;
+
+    while(l1!==null){
+        if(l2!==null){
+            val=l1.val+l2.val+accum
+            l2=l2.next
+        }
+        else
+            val=l1.val+accum
+
+        l1.val=val%10
+        accum=(val-val%10)/10
+        prev=l1
+        l1=l1.next
+    }
+
+    if(l2!==null)
+        prev.next=l2
+
+    while(l2!==null&&accum>0){
+        val = l2.val+accum
+        l2.val=val%10
+        accum=(val-val%10)/10
+        prev=l2
+        l2=l2.next
+    }
+    if(accum>0){
+        prev.next=new ListNode()
+        prev.next.val=accum
+    }
+
+    return head
+};

daily/2024-july/easy/three-consecutive-odds.js renamed to monthly/2024-july/easy/three-consecutive-odds.js

@@ -0,0 +1,47 @@
+/**
+ * @param {number} dividend
+ * @param {number} divisor
+ * @return {number}
+ */
+var divide = function(dividend, divisor) {
+    const isNegative=(dividend>0&&divisor<0)||(dividend<0&&divisor>0)
+    dividend=dividend>0?dividend:-dividend
+    divisor=divisor>0?divisor:-divisor
+
+    if(divisor>dividend)
+        return 0
+
+    const min= -Math.pow(2, 31)
+    const max=-1-min
+
+    const getResult=(val)=>{
+        if(isNegative)
+            return val<min?min:-val
+        return val>max?max:val
+    }
+
+    if(divisor===1)
+        return getResult(dividend)
+
+    const multiples=[]
+    let r=0, pow,exponent=1, multiple=divisor,remainder=dividend, tempRemainder
+
+    while(multiple<=dividend){
+        multiples.push(multiple)
+        multiple=Math.pow(divisor, ++exponent)
+    }
+
+    while(multiples.length>0&&remainder>0)
+    {
+        multiple=multiples.pop()
+        tempRemainder=remainder
+        pow=Math.pow(divisor, multiples.length)
+
+        while((tempRemainder-=multiple)>=0){
+            r+=pow
+            remainder=tempRemainder
+        }
+    }
+
+    return getResult(r)
+};

monthly/2024-july/medium/add-two-numbers.js

@@ -0,0 +1,60 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {number[]}
+ */
+var nodesBetweenCriticalPoints = function(head) {
+    let prevVal=head.val, currVal=null, nextVal=null
+
+    const criticalPos=[]
+    const criticalDiff= new Array(2)
+    counter=1
+
+    const checkVal=()=>{
+        if((currVal>nextVal&&currVal>prevVal)||(currVal<nextVal&&currVal<prevVal))
+            criticalPos.push(counter)
+    }
+
+    while((head=head.next)!==null)
+    {
+        counter++
+
+        if(currVal!==null && nextVal!==null){
+            prevVal=currVal
+            currVal=nextVal
+            nextVal=head.val
+
+            checkVal()
+        }
+
+        else if(currVal===null)
+            currVal=head.val
+
+        else{
+            nextVal = head.val
+    checkVal()
+        }
+    }
+
+    if(criticalPos.length<2)
+        return [-1,-1]
+
+    criticalDiff[1]=criticalPos[criticalPos.length-1]-criticalPos[0]
+
+    let min=null
+    for(let i=0, val;i< criticalPos.length-1;i++){
+        val=criticalPos[i+1]-criticalPos[i]
+
+        if(val<min||min===null)
+            min=val
+    }
+    criticalDiff[0]=min
+
+    return criticalDiff
+};

monthly/2024-july/medium/divide-two-integers.js

@@ -0,0 +1,21 @@
+/**
+ * @param {string[]} strs
+ * @return {string}
+ */
+var longestCommonPrefix = function(strs) {
+    let i, j,c, minLength
+
+    for(i=0;i<strs.length;i++)
+        if(strs[i].length<minLength||minLength===undefined)
+            minLength=strs[i].length
+
+    for(i=0;i<minLength;i++)
+    {
+        c=strs[0][i]
+
+        for(j=1;j<strs.length;j++)
+            if(c!==strs[j][i])
+                return strs[0].substr(0, i)
+    }
+    return strs[0].substr(0, i)
+};

monthly/2024-july/medium/find-the-minimum-and-maximum-number-of-nodes-between-critical-points.js

@@ -0,0 +1,44 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} list1
+ * @param {ListNode} list2
+ * @return {ListNode}
+ */
+var mergeTwoLists = function(list1, list2) {
+    if(list1===null)
+        return list2
+
+    if(list2===null)
+        return list1
+
+    let head=null, list3
+
+    if(list2.val>=list1.val)
+    {
+        head=list3=list1
+        list1=list1.next
+    }
+    else{
+       head= list3=list2
+      list2  =list2.next
+    }
+
+    while(list2!==null) {
+        while(list1!==null&&list2.val>=list1.val){
+            list3=list3.next = list1
+            list1=list1.next
+        }
+
+       list3= list3.next=list2
+        list2=list2.next
+    }
+    list3.next=list1
+
+    return head
+};

daily/2024-july/medium/merge-nodes-in-between-zeros.js renamed to monthly/2024-july/medium/merge-nodes-in-between-zeros.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number} x
+ * @return {boolean}
+ */
+var isPalindrome = function(x) {
+    if(x<0)
+        return false
+    if(x==0)
+        return true
+
+    const numberStr=String(x)
+    const numberStrLength=numberStr.length
+
+    for(let i=0;i<numberStrLength/2;i++)
+        if(numberStr[i]!==numberStr[numberStrLength-1-i])
+            return false
+    return true
+};

daily/2024-july/medium/minimum-difference-between-largest-and-smallest-value-in-three-moves.js renamed to monthly/2024-july/medium/minimum-difference-between-largest-and-smallest-value-in-three-moves.js

@@ -0,0 +1,29 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isValid = function(s) {
+    const characters=[]
+
+    for(let c of s)
+        if(c==='(')
+            characters.push(c)
+        else if(c==='[')
+            characters.push(c)
+        else if(c==='{')
+            characters.push(c)
+        else if(c===')'){
+            if(characters.pop()!=='(')
+                return false
+        }
+        else if(c===']'){
+            if(characters.pop()!=='[')
+                return false
+        }
+        else if(c==='}'){
+            if(characters.pop()!=='{')
+                return false
+        }
+
+    return characters.length===0
+};