def num_identical_pairs(nums):
count = 0
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
if nums[i] == nums[j]:
count += 1
return count
# Example usage:
nums = [1, 2, 3, 1, 1, 3]
print("Number of good pairs:", num_identical_pairs(nums))
ef finalValueAfterOperations(operations):
count = 0
length= len(operations)
for i in range(length):
if(operations[i]=="++x" or operations[i]=="x++"):
count+=1
print(operations[i])
elif(operations[i]=='--x' or operations[i]=='x--'):
count-=1
print(operations[i])
return count
a=['--x','x++','x++']
b=['++x','++x','x++']
res1 = finalValueAfterOperations(a)
res2 = finalValueAfterOperations(b)
print('operation1',res1)
print('operation2',res2)
def shuffleArray(nums,n):
result=[]
for i in range(n):
result.append(nums[i])
result.append(nums[i+n])
return result
num= [2,5,1,3,4,7]
no=3
answer = shuffleArray(num,no)
print(answer)
def findWordsContaining(self,words, x):
res = []
for i in range(len(words)):
if x in words[i]:
res.append(i)
return res
# Example usage:
text = ["abc","bcd","aaaa","cbc"]
char = 'a'
words_with_char = findWordsContaining(text, char)
print("Words containing the character:", words_with_char)
def maxWealth(accounts):
highest_sum=0
for account in accounts:
current_sum = sum(account)
if current_sum>highest_sum:
highest_sum = current_sum
return highest_sum
l1=[[1,5],[7,3],[3,5]]
l2=[[1,2,3],[3,2,1]]
result = maxWealth(l1)
print('max wealth',result)
def targetcount(nums,n):
count = 0
for i in nums:
if i>=n:
count+=1
return count
inp = [1,1,2,4,5]
target = 2
output = targetcount(inp,target)
print(output)
def runningSum(nums):
for i in range(1,len(nums)):
nums[i] = nums[i-1] + nums[i]
return nums
nums = [1,2,3,4]
res=runningSum(nums)
print(res)
def truncateSentence(s,k):
words= s.split(" ")
print(words)
truncated_words=words[:k]
truncated_s=" ".join(truncated_words)
return truncated_s
s="hello how are you gugu"
k=2
result=truncateSentence(s,k)
print(result)
class Solution:
def countPairs(self, nums: list[int], target: int) -> int:
nums.sort() # sort the vector nums
count = 0 # variable to store the count
left = 0 # variable to store the left
right = len(nums)-1 # variable to store the right
while(left < right): # loop until left is less than right
if(nums[left] + nums[right] < target): # if nums[left] + nums[right] is less than target
count += right-left # update the count
left += 1 # increment the left
else: # else
right -= 1 # decrement the right
return count # return the count
nums=[-1,1,2,3,1]
target=2
s=Solution()
res=s.countPairs(nums,target)
print(res)
class Solution:
def maximizeSquareArea(self, m: int, n: int, hFences: List[int], vFences: List[int]) -> int:
mod = (10**9)+7
ans = -1
height = set([m-1])
hFences+=[1,m]
vFences+=[1,n]
for h1 in hFences:
for h2 in hFences:
if h1!=h2:
height.add(abs(h1-h2))
if n-1 in height:
ans = n-1
for v1 in vFences:
for v2 in vFences:
if abs(v1-v2) in height:
ans = max(ans,abs(v1-v2))
return (ans**2)%mod if ans!=-1 else -1
def minimumFinishTime(tires, changeTime, numLaps):
minimum = [] # minimum[i] represents for the min time to complete i + 1 laps without changing a
tire
total = [0] * len(tires)
# the worst case is: fi = 1, ri = 2, changeTime = 10 ** 5
# this while loop will be computed for at most math.ceil(math.log2(10 ** 5 + 1)) = 17 times
while True:
for t in range(len(tires)):
total[t] += tires[t][0]
tires[t][0] *= tires[t][1]
minimum.append(min(total))
# if the minimum cost is greater than changing a new tire, we stop looping
if minimum[-1] > changeTime + minimum[0]: break
# dp
dp = [float('inf')] * numLaps
for l in range(numLaps):
for pre in range(len(minimum)):
if l - pre - 1 < 0:
dp[l] = min(dp[l], minimum[pre])
break
dp[l] = min(dp[l], minimum[pre] + dp[l - pre - 1] + changeTime)
return dp[-1]
tires = [[2,3],[3,4]]
changeTime = 5
numLaps = 4
res=minimumFinishTime(tires, changeTime, numLaps)
print(res)
class Solution:
def firstPalindrome(self,words):
for word in words:
if word==word[::-1]:
return word
return ""
words = ["abc","car","racecar","cool"]
s=Solution()
res=s.firstPalindrome(words)
print(res)
class Solution:
def stringIndices(self, wordsContainer, wordsQuery):
trie = {}
for i,word in enumerate(wordsContainer):
spot = trie
if None not in spot or spot[None][1] > len(word):
spot[None] = (i,len(word))
for c in reversed(word):
if c not in spot:
spot[c] = {}
spot = spot[c]
if None not in spot or spot[None][1] > len(word):
spot[None] = (i,len(word))
ans = []
for word in wordsQuery:
spot = trie
for c in reversed(word):
if c not in spot:
break
spot = spot[c]
ans.append(spot[None][0])
return ans
wordsContainer = ["abcd","bcd","xbcd"]
wordsQuery = ["cd","bcd","xyz"]
s=Solution()
result=s.stringIndices(wordsContainer, wordsQuery)
print(result)
class MajorityChecker(object):
def __init__(self, arr):
self.arr = arr
def query(self, left, right, threshold):
candidate = 0
count = 0
for i in range(left, right+1):
if count == 0:
candidate = self.arr[i]
count = 1
elif candidate == self.arr[i]:
count += 1
else:
count -= 1
count = 0
for i in range(left, right+1):
if candidate == self.arr[i]:
count += 1
if count >= threshold:
return candidate
return -1
s=MajorityChecker.query(2, 3, 2)
print(s)
class Solution:
def minMovesToCaptureTheQueen(self, a, b, c, d, e, f):
# rock and queen in the same row or col
if a == e: # same row
if a == c and (d - b) * (d - f) < 0: # bishop on the same row and between rock and queen
return 2
else:
return 1
elif b == f: # same col
if b == d and (c - a) * (c - e) < 0:
return 2
else:
return 1
# bishop and queen in the same diagonal
elif c - e == d - f: # \ diagonal
if a - e == b - f and (a - c) * (a - e) < 0:
return 2
else:
return 1
elif c - e == f - d: # / diagonal
if a - e == f - b and (a - c) * (a - e) < 0:
return 2
else:
return 1
return 2
a,b,c,d,e,f = 1,1,8,8,2,3
s=Solution()
res=s.minMovesToCaptureTheQueen(a,b,c,d,e,f)
print(res)
class Solution:
def totalSteps(self, nums):
st = []
ans = 0
for i in nums:
t=0
while st and st[-1][0] <= i:
t = max(t, st.pop()[1])
x=0
if st:
x = t+1
st.append([i, x])
ans = max(ans, x)
return ans
nums = [4,7,3,6,11,8,5,11]
s=Solution()
res=s.totalSteps(nums)
print(res)
class Solution:
def arrayStringsAreEqual(self, word1: List[str], word2: List[str]) -> bool:
a=''.join(word1)
b=''.join(word2)
return a==b
class Solution:
def maxWidthOfVerticalArea(self, points: list[list[int]]) -> int:
x_coordinates = sorted(set(point[0] for point in points))
max_diff = 0
prev_x = None
for x in x_coordinates:
if prev_x is not None:
max_diff = max(max_diff, x - prev_x)
prev_x = x
return max_diff
def countPairs( nums, target) :
nums.sort()
count = 0
left = 0
right = len(nums)-1
while(left < right):
if(nums[left] + nums[right] < target):
count += 1 # update the count
print(count)
left += 1 # increment the left
else: # else
right -= 1 # decrement the right
return count
nums = [-1,1,2,3,1]
target = 2
result=countPairs(nums,target)
print(result)
