CarGDev/leetcode
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updating exercises

Browse Source
This commit is contained in:
Carlos
2025-07-14 10:46:28 -04:00
parent 7f1381ae93
commit 9e97460936
16 changed files with 84 additions and 693 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
src/exercises/10.regular-expression-matching.py
View File

@@ -1,40 +0,0 @@
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet start
class Solution:
def isMatch(self, s: str, p: str) -> bool:
# @leet end

40
src/exercises/1298.maximum-candies-you-can-get-from-boxes.py
View File

@@ -1,40 +0,0 @@
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet start
class Solution:
def maxCandies(self, status: List[int], candies: List[int], keys: List[List[int]], containedBoxes: List[List[int]], initialBoxes: List[int]) -> int:
# @leet end

40
src/exercises/150.evaluate-reverse-polish-notation.py
View File

@@ -1,40 +0,0 @@
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet start
class Solution:
def evalRPN(self, tokens: List[str]) -> int:
# @leet end

42
src/exercises/1820.maximum-number-of-accepted-invitations.py
View File

@@ -1,42 +0,0 @@
# @leet imports start
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet imports end
# @leet start
class Solution:
def maximumInvitations(self, grid: List[List[int]]) -> int:
# @leet end

83
src/exercises/2040.kth-smallest-product-of-two-sorted-arrays.py
View File

@@ -1,83 +0,0 @@
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet start
class Solution:
def kthSmallestProduct(self, nums1: List[int], nums2: List[int], k: int) -> int:
low = -(10**10)
high = 10**10
def countLessEqual(p):
count = 0
for i in range(len(nums1)):
l, h = 0, len(nums2)
if nums1[i] == 0 and p >= 0:
count += len(nums2)
elif nums1[i] > 0:
while l < h:
mid = (l + h) // 2
x = nums1[i] * nums2[mid]
if x <= p:
l = mid + 1
else:
h = mid
count += l
else:
while l < h:
mid = (l + h) // 2
x = nums1[i] * nums2[mid]
if x <= p:
h = mid
else:
l = mid + 1
count += len(nums2) - l
return count
while low < high:
mid = (low + high) // 2
count = countLessEqual(mid)
if count < k:
low = mid + 1
else:
high = mid
return low
# @leet end

45
src/exercises/21.merge-two-sorted-lists.py
View File

@@ -1,45 +0,0 @@
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet start
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
# @leet end

66
src/exercises/2116.check-if-a-parentheses-string-can-be-valid.py
View File

@@ -1,66 +0,0 @@
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet start
class Solution:
def canBeValid(self, s: str, locked: str) -> bool:
var = ''
new_str = []
for i in s:
new_str.append(i)
for i in range(len(s)):
if i % 2 == 0:
var = '('
if var != s[i] and locked[i] == "0":
new_str[i] = var
elif i % 2 != 0:
var = ')'
if var != s[i] and locked[i] == "0":
new_str[i] = var
count_v = 0
count_x = 0
for i in new_str:
if i == ')':
count_x += 1
if i == '(':
count_v += 1
return count_v % 2 == 0 and count_x % 2 == 0
# @leet end

41
src/exercises/2616.minimize-the-maximum-difference-of-pairs.py
View File

@@ -1,41 +0,0 @@
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet start
class Solution:
def minimizeMax(self, nums: List[int], p: int) -> int:
nums.sort()
# @leet end

40
src/exercises/2966.divide-array-into-arrays-with-max-difference.py
View File

@@ -1,40 +0,0 @@
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet start
class Solution:
def divideArray(self, nums: List[int], k: int) -> List[List[int]]:
# @leet end

5
src/exercises/3.longest-substring-without-repeating-characters.ts
View File

@@ -1,5 +0,0 @@
// @leet start
function lengthOfLongestSubstring(s: string): number {
};
// @leet end

40
src/exercises/3445.maximum-difference-between-even-and-odd-frequency-ii.py
View File

@@ -1,40 +0,0 @@
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet start
class Solution:
def maxDifference(self, s: str, k: int) -> int:
# @leet end

42
src/exercises/45.jump-game-ii.py
View File

@@ -1,42 +0,0 @@
# @leet imports start
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet imports end
# @leet start
class Solution:
def jump(self, nums: List[int]) -> int:
# @leet end

5
src/exercises/595.big-countries.sql Normal file
View File

@@ -0,0 +1,5 @@
# Write your MySQL query statement below
select w.name, w.population, w.area
from world as w
where w.area >= 3000000
or w.population >= 25000000

45
src/exercises/92.reverse-linked-list-ii.py
View File

@@ -1,45 +0,0 @@
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet start
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
# @leet end

42
src/exercises/990.satisfiability-of-equality-equations.py
View File

@@ -1,42 +0,0 @@
# @leet imports start
from string import *
from re import *
from datetime import *
from collections import *
from heapq import *
from bisect import *
from copy import *
from math import *
from random import *
from statistics import *
from itertools import *
from functools import *
from operator import *
from io import *
from sys import *
from json import *
from builtins import *
import string
import re
import datetime
import collections
import heapq
import bisect
import copy
import math
import random
import statistics
import itertools
import functools
import operator
import io
import sys
import json
from typing import *
# @leet imports end
# @leet start
class Solution:
def equationsPossible(self, equations: List[str]) -> bool:
# @leet end