1
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
idx = {}
for j , x in enumerate(nums):
if target - x in idx:
return [idx[target - x] , j]
idx[x] = j
1512
class Solution:
def numIdenticalPairs(self, nums: List[int]) -> int:
res = 0
idx = defaultdict(int)
for x in nums:
res += idx[x]
idx[x] += 1
return res
2001
class Solution:
def interchangeableRectangles(self, rectangles: List[List[int]]) -> int:
idx = defaultdict(int)
res = 0
for l,d in rectangles:
res += idx[l/d]
idx[l/d] += 1
return res121
class Solution:
def maxProfit(self, prices: List[int]) -> int:
res = 0
minprice = prices[0]
for p in prices:
res = max(res,p-minprice)
minprice = min(minprice,p)
return res
2342
class Solution:
def maximumSum(self, nums: List[int]) -> int:
def getN(num):
s = 0
t = num
while t:
s += t % 10
t //= 10
return s
c = [-1] * 100
res = -1
for i in nums:
k = getN(i)
if c[k] > 0:
res = max(res, i + c[k])
c[k] = max(c[k], i)
return res2815
class Solution:
def maxSum(self, nums: List[int]) -> int:
c = [-100] * 10
res = -1
for i in nums:
t = i
m = 0
k = 0
while t:
k = t % 10
t //= 10
if m < k:
m = k
if c[m] >= 1:
res = max(res, i + c[m])
c[m] = max(c[m], i)
return res
1679
class Solution:
def maxOperations(self, nums: List[int], k: int) -> int:
nums.sort()
left = 0
right = len(nums) - 1
res = 0
while left < right:
n = nums[left] + nums[right]
if n == k:
res += 1
left += 1
right -= 1
elif n > k:
right -= 1
else:
left += 1
return res219
class Solution:
def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
res = 0
idx = {}
for j,x in enumerate(nums):
if x in idx:
if j - idx[x] <= k:
return True
idx[x] = j
return False
2260
class Solution:
def minimumCardPickup(self, cards: List[int]) -> int:
s = {}
k = 0
res = 100001
for i in range(len(cards)):
if cards[i] in s:
res = min(res, i - s[cards[i]] + 1)
s[cards[i]] = i
if res == 100001:
return -1
return res
624
class Solution:
def maxDistance(self, arrays: List[List[int]]) -> int:
m = max(arrays[0])
n = min(arrays[0])
res = 0
for i in range(1, len(arrays)):
l = max(arrays[i])
k = min(arrays[i])
res = max(abs(l - n), res)
res = max(abs(k - m), res)
m = max(l, m)
n = min(n, k)
return res1010
class Solution:
def numPairsDivisibleBy60(self, time: List[int]) -> int:
cnt = [0] * 60
res = 0
for i in time:
n = i % 60
res += cnt[(60 - n) % 60]
cnt[n] += 1
return res3185
class Solution:
def countCompleteDayPairs(self, hours: List[int]) -> int:
cnt = [0] * 24
res = 0
for i in hours:
n = i % 24
res += cnt[(24 - n) % 24]
cnt[n] += 1
return res2506
class Solution:
def similarPairs(self, words: List[str]) -> int:
s = {}
res = 0
for i in words:
c = ""
for j in range(len(i)):
if i[j] not in c:
c += i[j]
cnt = "".join(sorted(c))
if cnt in s:
res += s[cnt]
s[cnt] += 1
else:
s[cnt] = 1
return res2748
class Solution:
def countBeautifulPairs(self, nums: List[int]) -> int:
f = {}
res = 0
for i in nums:
t = i
l = 0
while t:
l = t % 10
t //= 10
for j in f:
if gcd(j, i % 10) == 1:
res += f[j]
if l in f:
f[l] += 1
else:
f[l] = 1
return res2874
class Solution:
def maximumTripletValue(self, nums: List[int]) -> int:
ans = max_diff = pre_max = 0
for x in nums:
ans = max(ans, max_diff * x)
max_diff = max(max_diff, pre_max - x)
pre_max = max(pre_max, x)
return ans3371
class Solution:
def getLargestOutlier(self, nums: List[int]) -> int:
cnt = Counter(nums)
total = sum(nums)
ans = -inf
for x in nums:
cnt[x] -= 1
if (total - x) % 2 == 0 and cnt[(total - x) // 2] > 0:
ans = max(ans, x)
cnt[x] += 1
return ans1014
class Solution:
def maxScoreSightseeingPair(self, values: List[int]) -> int:
res = 0
pre = 0
for i, x in enumerate(values):
res = max(res, pre + x - i)
pre = max(pre, x + i)
return res1814
class Solution:
def countNicePairs(self, nums: List[int]) -> int:
mod = 10**9 + 7
dic = {}
res = 0
def rev(num):
t = str(num)
n = len(t)
r = ""
for i in range(n - 1, -1, -1):
r += t[i]
return int(r)
for i in nums:
t = rev(i)
t = i - t
if t in dic:
res += dic[t]
dic[t] += 1
else:
dic[t] = 1
return res % mod2905
class Solution:
def findIndices(self, nums: List[int], indexDifference: int, valueDifference: int) -> List[int]:
max_idx = min_idx = 0
for j in range(indexDifference, len(nums)):
i = j - indexDifference
if nums[i] > nums[max_idx]:
max_idx = i
elif nums[i] < nums[min_idx]:
min_idx = i
if nums[max_idx] - nums[j] >= valueDifference:
return [max_idx, j]
if nums[j] - nums[min_idx] >= valueDifference:
return [min_idx, j]
return [-1, -1]