feat: Solved 15 Leetcode problems

Author: ralvarezdev

monthly/2024-july/easy/crawler-log-folder.js

@@ -0,0 +1,46 @@
+/**
+ * @param {string[]} logs
+ * @return {number}
+ */
+var minOperations = function(logs) {
+    const moveToFolder = i=>{
+        const path =    logs[i].substring(0,logs[i].length-1)
+
+        return path[0]==='.'?"":path
+    }
+    const moveToParentFolder= ()=>{
+        const lastIdx = currDirectory.lastIndexOf('/')
+
+        if(lastIdx>=0)
+            currDirectory=currDirectory.substring(0, lastIdx)
+        else
+            currDirectory=""
+    }
+
+    let currDirectory=moveToFolder(0)
+
+    for(let idx=1;idx<logs.length;idx++)
+    {
+        if(logs[idx].charAt(0)!=='.'){
+            if(currDirectory.length!==0)
+                currDirectory=[currDirectory,moveToFolder(idx)].join('/')
+            else
+                currDirectory=moveToFolder(idx)
+            continue
+        }
+
+        if(logs[idx].charAt(1)!=='.')
+            continue
+
+        moveToParentFolder()
+    }
+
+    console.log(currDirectory)
+    let counter=currDirectory.length>0?1:0
+
+    for(let c of currDirectory)
+        if(c==='/')
+            counter++
+
+    return counter
+};

monthly/2024-july/medium/average-waiting-time.py

@@ -0,0 +1,26 @@
+class Solution:
+    def averageWaitingTime(self, customers: List[List[int]]) -> float:
+        arrival=None
+        time=None
+        currTime=None
+        totalTime=0
+        idx=0
+
+        arrival,time = customers[idx]
+        totalTime+=time
+        currTime=arrival+time
+        idx+=1
+
+        while idx<len(customers):
+            arrival, time=customers[idx]
+
+            if currTime-arrival>=0:
+                totalTime+=currTime+time-arrival
+                currTime+=time
+            else:
+                totalTime+=time
+                currTime=time+arrival
+
+            idx+=1
+
+        return totalTime/len(customers)

monthly/2024-july/medium/find-the-winner-of-the-circular-game-solution1.py

@@ -0,0 +1,25 @@
+class Solution:
+    def findTheWinner(self, n: int, k: int) -> int:
+        if k==1:
+            return n
+
+        players = [i+1 for i in range(0,n)]
+        idx=0
+        maxIdx = n-1
+
+        while len(players)>1:
+            moveCounter=1
+
+            while moveCounter<k:
+                idx=idx+1 if idx<maxIdx else 0
+                moveCounter+=1
+
+            print(players[idx])
+            del players[idx]
+
+            if idx==maxIdx:
+                idx=0
+
+            maxIdx-=1
+
+        return players[0]

monthly/2024-july/medium/find-the-winner-of-the-circular-game-solution2.py

@@ -0,0 +1,35 @@
+class Solution:
+    def findTheWinner(self, n: int, k: int) -> int:
+        if k==1:
+            return n
+
+        players = [True for i in range(0,n)]
+        roundCounter=0
+        idx=-1
+
+        move = lambda i:i+1 if idx<n-1 else 0
+
+        while roundCounter<n-1:
+            moveCounter=1
+            idx= move(idx)
+
+            while not players[idx]:
+                idx= move(idx)
+            #print(f'1. {idx+1}')
+
+            while moveCounter<k:
+                idx=move(idx)
+
+                if not players[idx]:
+                    while not players[idx]:
+                        idx=move(idx)
+                #print(f'2. {idx+1}')
+                moveCounter+=1
+
+            #print(f'3. {idx+1}')
+            players[idx]=False
+            roundCounter+=1
+
+        for i,player in enumerate(players):
+            if player:
+                return i+1

monthly/2024-july/medium/reverse-substrings-between-each-pair-of-parentheses.js

@@ -0,0 +1,38 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var reverseParentheses = function(s) {
+    const stack = new Array()
+
+    let result="",c
+    const startEndIdx=s.indexOf('(')
+    const start= (startEndIdx>=0)?s.substring(0,startEndIdx ):""
+    const endStartIdx=s.lastIndexOf(')')+1
+    const end=(endStartIdx>=0)?s.substring(endStartIdx):""
+
+    for(let i=startEndIdx;i<endStartIdx;i++){
+        c=s[i]
+
+        if(c!==')'){
+            stack.push(c)
+            continue
+        }
+
+        c=stack.pop()
+        result=""
+
+        while(c!=='(')
+        {
+            result+=c
+            c=stack.pop()
+        }
+
+        for(let i=0;i<result.length;i++)
+            stack.push(result[i])
+    }
+
+    result=stack.join('')
+
+    return start+result+end
+};

random/2024-july/easy/climbing-stairs.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function(n) {
+    const map = new Map()
+    let climb1,climb2
+
+    const climb=n=>{
+        if(n<=2)
+            return n
+
+        climb1=map.get(n-1)
+        if(climb1===undefined){
+            climb1=climb(n-1)
+            map.set(n-1, climb1)
+        }
+
+        climb2=map.get(n-2)
+        if(climb2===undefined){
+            climb2=climb(n-2)
+            map.set(n-2, climb2)
+        }
+
+        return climb1+climb2
+    }
+
+    return climb(n)
+};

random/2024-july/easy/find-subarrays-with-equal-sum.js

@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var findSubarrays = function(nums) {
+    for(let i=0;i<nums.length-2;i++)
+        for(let j=i+1;j<nums.length-1;j++)
+            if(nums[i]+nums[i+1]===nums[j]+nums[j+1])
+                return true
+
+    return false
+};

random/2024-july/hard/median-of-two-sorted-arrays.js

@@ -0,0 +1,46 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var findMedianSortedArray = function(nums){
+    const mid= parseInt(nums.length/2)
+
+    if(nums.length%2===0)
+        return (nums[mid-1]+nums[mid])/2
+    return nums[mid]
+}
+
+var findMedianSortedArrays = function(nums1, nums2) {
+    const searchInsert=(val)=>{
+    let low=0,high= nums1.length-1,mid, isUpper
+
+    while(high>=low)
+    {
+        mid= Math.floor((high+low)/2)
+
+        if(nums1[mid]===val)
+            return mid
+
+        else if(nums1[mid]>val){
+            high=mid-1
+            isUpper=false
+        }
+
+        else{
+           low=mid+1
+           isUpper=true
+        }
+    }
+
+    return isUpper?mid+1:mid
+    }
+
+    if(nums1.length===0)
+        return findMedianSortedArray(nums2)
+
+    for(let num of nums2)
+        nums1.splice(searchInsert(num), 0, num)
+
+    return findMedianSortedArray(nums1)
+};

random/2024-july/hard/minimum-number-of-days-to-eat-n-oranges.js

@@ -0,0 +1,31 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var minDays = function(n) {
+    if(n<=0)
+        return 0
+
+    const minDays=new Map()
+
+    const getMinDays=(n)=>{
+        const nDays=[]
+
+        if(n<=2)
+            return n
+
+        let min=minDays.get(n)
+        if(min!==undefined)
+            return min
+
+        const minDays2=1+n%2+getMinDays(parseInt(n/2))
+        const minDays3=1+n%3+getMinDays(parseInt(n/3))
+
+        min= minDays2<minDays3?minDays2:minDays3
+        minDays.set(n, min)
+
+        return min
+    }
+
+    return getMinDays(n)
+};

random/2024-july/medium/count-nice-pairs-in-an-array.js

@@ -0,0 +1,54 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var countNicePairs = function(nums) {
+    let nList, mid
+
+    const getReverse=n=>{
+        if(n<=9)
+            return n
+
+        n=String(n)
+        nList=new Array(n.length)
+
+        for(let i=n.length-1, j=0;j<i;i--,j++){
+            nList[i]=n[j]
+            nList[j]=n[i]
+        }
+
+        if(n.length%2!==0){
+            mid=parseInt(n.length/2)
+            nList[mid]=n[mid]
+        }
+
+        return parseInt(nList.join(''))
+    }
+
+    const revNums=new Map(), revNumsFreq=new Map()
+    let value,freq, counter=0
+
+    nums.forEach((num, i)=>{
+        value=revNums.get(num)
+
+        if(value===undefined){
+            value=num-getReverse(num)
+            revNums.set(num, value)
+        }
+
+        freq=revNumsFreq.get(value)
+
+        if(freq!==undefined)
+            revNumsFreq.set(value,freq+1)
+        else
+            revNumsFreq.set(value,1)
+    })
+
+    const revNumsFreqValues=Array.from(revNumsFreq.values())
+    for(let i=0;i<revNumsFreqValues.length;i++){
+        value=revNumsFreqValues[i]-1
+        counter+=value*(value+1)/2
+    }
+
+    return counter%(Math.pow(10,9)+7)
+};