Given two arrays nums1 and nums2 of equal length, where each element in nums1 has been increased (or decreased in the case of negative) by an integer x, we aim to find the value of x such that nums1 becomes equal to nums2. Since both arrays should contain the same integers with the same frequencies after applying x, we can determine x by comparing the sum of elements in nums1 and nums2.
Time complexity: O(n), where n is the length of nums1 (or nums2 since they have the same length). We iterate through both arrays once to calculate their sums.
Space complexity: O(1), as we use only a constant amount of extra space.
class Solution:
def addedInteger(self, nums1: List[int], nums2: List[int]) -> int:
return (sum(nums2) - sum(nums1))//len(nums1)
Solving by sorting the arrays and iterating through all possibilities for minimum difference.
Time complexity: O(n^2), where n is the length of nums1. We iterate through all pairs of indices (i, j) in nums1.
Space complexity: O(n), where n is the length of nums1. We create a new array new_nums1 for each pair of indices.
import sys
class Solution:
def minimumAddedInteger(self, nums1: List[int], nums2: List[int]) -> int:
nums1.sort()
nums2.sort()
min_diff = sys.maxsize
for i in range(len(nums1)):
for j in range(i+1, len(nums1)):
new_nums1 = nums1[:i] + nums1[i+1:j] + nums1[j+1:]
diff = nums2[0] - new_nums1[0]
if all(new_nums1[k] + diff == nums2[k] for k in range(len(nums2))):
min_diff = min(min_diff, diff)
return min_diff
Implementing a singly linked list. Each node contains a value (val) and a reference to the next node (next). We’ll also consider methods for adding, getting, and deleting nodes from the list.
class ListNode:
def __init__(self,val):
self.val = val
self.next = None
class MyLinkedList:
def __init__(self):
self.head = self.tail = None
self.size = 0
def get(self, index: int) -> int:
if index < 0 or index >= self.size:
return -1
curr = self.head
for _ in range(index):
curr = curr.next
return curr.val
def addAtHead(self, val: int) -> None:
node = ListNode(val)
if not self.head:
self.head = self.tail = node
else:
node.next = self.head
self.head = node
self.size += 1
def addAtTail(self, val: int) -> None:
node = ListNode(val)
if not self.head:
self.head = self.tail = node
else:
self.tail.next = node
self.tail = node
self.size += 1
def addAtIndex(self, index: int, val: int) -> None:
if index < 0 or index > self.size:
return
if index == 0:
self.addAtHead(val)
elif index == self.size:
self.addAtTail(val)
else:
node = ListNode(val)
curr = self.head
for _ in range(index-1):
curr = curr.next
node.next = curr.next
curr.next = node
self.size +=1
def deleteAtIndex(self, index: int) -> None:
if index < 0 or index >= self.size:
return
if index == 0:
if self.size == 1:
self.head = self.tail = None
else:
self.head = self.head.next
else:
curr = self.head
for _ in range(index-1):
curr = curr.next
if curr.next == self.tail:
self.tail = curr
curr.next = curr.next.next
self.size-=1
Implementing a doubly linked list. Each node contains a value (val), a reference to the next node (next), and a reference to the previous node (prev). We’ll consider methods for adding, getting, and deleting nodes from the list.
class ListNode:
def __init__(self, val):
self.prev = None
self.val = val
self.next = None
class MyLinkedList:
def __init__(self):
self.head = self.tail = None
self.size = 0
def get(self, index: int) -> int:
if index < 0 or index >= self.size:
return -1
curr = self.head
for _ in range(index):
curr = curr.next
return curr.val
def addAtHead(self, val: int) -> None:
node = ListNode(val)
if not self.head:
self.head = self.tail = node
else:
node.next = self.head
self.head.prev = node
self.head = node
self.size+=1
def addAtTail(self, val: int) -> None:
node = ListNode(val)
if not self.head:
self.head = self.tail = node
else:
node.prev = self.tail
self.tail.next = node
self.tail = node
self.size += 1
def addAtIndex(self, index: int, val: int) -> None:
if index < 0 or index > self.size:
return
if index == 0:
self.addAtHead(val)
elif index == self.size:
self.addAtTail(val)
else:
node = ListNode(val)
curr = self.head
for _ in range(index-1):
curr = curr.next
node.prev = curr
node.next = curr.next
curr.next = node
self.size += 1
def deleteAtIndex(self, index: int) -> None:
if index < 0 or index >= self.size:
return
if index == 0:
if not self.head:
self.head = self.tail = None
else:
self.head = self.head.next
else:
curr = self.head
for _ in range(index-1):
curr = curr.next
if curr.next == self.tail:
self.tail = curr
self.tail.next = None
else:
temp = curr.next.next
curr.next = curr.next.next
temp.prev = curr
self.size-=1
We can solve this problem by splitting the string on space and iterating through each word. For each word, we iterate through the characters of the broken letters. If any character from the broken letters is found in the current word, we skip that word. If none of the characters from the broken letters are found in the word, we count it as a word that can be typed. Finally, we return the count of such words.
Time complexity: O(n * m), where n is the number of words in the text and m is the length of the broken letters string. The function iterates through each word in the text and checks each character against the broken letters.
Space complexity: O(1), as the function uses only a constant amount of extra space.
class Solution:
def canBeTypedWords(self, text: str, brokenLetters: str) -> int:
count = 0
for w in text.split(" "):
for i in brokenLetters:
if i in w:
break
else:
count+=1
return count
To count the number of special characters in the given word, we first convert the word into a set to obtain unique characters. Then, we initialize an empty set to keep track of the lowercase versions of characters encountered. We iterate through each unique character in the set, converting it to lowercase. If the lowercase character is not present in the tracking set, we add it. If it’s already present, indicating that both lowercase and uppercase versions exist, we remove it from the tracking set and increment the count of special characters. Finally, we return the count of special characters. This approach ensures that each special character is counted only once, regardless of its case.
class Solution:
def numberOfSpecialChars(self, word: str) -> int:
w = set(word)
a = set()
count = 0
for i in w:
p = i.lower()
if p not in a:
a.add(p)
else:
a.remove(p)
count+=1
return count
To count the number of special characters in the given word, we initialize an empty dictionary to track the occurrences of each character and a counter variable to store the count of special characters. Iterating through each character in the word, we check if its lowercase version is not present in the dictionary or its corresponding value is not “NA”. If the character is a lowercase letter, we mark its presence in the dictionary. If it’s an uppercase letter and its lowercase version exists in the dictionary with the value “Yes”, we increment the counter and mark it as encountered. Otherwise, we mark it as encountered and decrement the counter. Finally, we return the counter, which represents the count of special characters in the word. This approach ensures that each special character is counted only once, regardless of its case.
class Solution:
def numberOfSpecialChars(self, word: str) -> int:
dic = {}
count = 0
for i in word:
if dic.get(i.lower(),True)!="NA":
if 'a'<=i<='z':
if not dic.get(i,False):
dic[i] = "Yes"
else:
if dic[i] == "No":
dic[i] = "NA"
count-=1
else:
p = i.lower()
if dic.get(p,False):
if dic[p]!="No":
count+=1
dic[p] = "No"
else:
dic[p] = "NA"
return count
First creating a character count for the cleaned and lowercased characters of the license plate. Then, each word in the given list is iterated through, and for each word, another character count is created. It’s checked if the word contains all the characters from the license plate. If so, and if it’s shorter than the current shortest completing word found so far, it becomes the new shortest completing word. Finally, the shortest completing word found is returned as the solution.
Time complexity: O(m * (k + n)), constructing the valid counter from the licensePlate incurs a linear runtime of O(n), where n represents the length of the licensePlate string. Subsequently, iterating through each word in the words list adds complexity proportional to the number of words, denoted as m. Within each iteration, generating a counter for the current word takes O(k) time, where k denotes the length of the word. Moreover, verifying whether the word contains sufficient occurrences of each character from the valid counter extends the time complexity to O(n) for each word.
Space complexity: O(n + k), valid counter requires O(n) space, where n denotes the count of unique characters in the licensePlate string. Additionally, the space consumption includes the ans string, necessitating O(k) space, corresponding to the length of the shortest completing word. Moreover, the creation of a new counter j for each word within the iteration further contributes O(k) space per word, where k signifies the length of the respective word.
from collections import Counter
class Solution:
def shortestCompletingWord(self, licensePlate: str, words: List[str]) -> str:
valid = Counter("".join(x.lower() for x in licensePlate if x.isalpha()))
ans = ""
for i in words:
j = Counter(i)
if all(j.get(c,0) >= valid[c] for c in valid):
if not ans or len(i)<len(ans):
ans = i
return ans
Splitting the input sentence into individual words and initializing an empty list with the same length as the number of words. Iterating through each word, the last character, representing its position in the sorted sentence, is extracted. By converting this character to an integer and adjusting for zero-based indexing, each word is placed in its corresponding position in the output list. Finally, the words in the output list are joined with spaces to form the sorted sentence, which is then returned.
Time complexity: O(n), where n is the number of words in the sentence s. The function iterates through each word once.
Space complexity: O(n), where n is the number of words in the sentence s. This is because we create a list ans to store the sorted words.
class Solution:
def sortSentence(self, s: str) -> str:
words = s.split(" ")
ans = [""]*len(words)
for w in words:
ans[int(w[-1])-1] = w[:-1]
return " ".join(ans)
Calculate the numerical values of three given words by converting each character to its ASCII value and summing them up. Then, check if the sum of the first two words equals the numerical value of the third word.
Time complexity: O(n), where n is the maximum length among the lengths of firstWord, secondWord, and targetWord. The function iterates through each character of the longest word once.
Space complexity: O(1), as the function uses only a constant amount of extra space.
class Solution:
def isSumEqual(self, firstWord: str, secondWord: str, targetWord: str) -> bool:
fw = 0
sw = 0
tw = 0
for i in range(max(len(firstWord),len(secondWord),len(targetWord))):
if i<=len(firstWord)-1:
fw = fw*10 + ord(firstWord[i]) - ord('a')
if i<=len(secondWord)-1:
sw = sw*10 + ord(secondWord[i]) - ord('a')
if i<=len(targetWord)-1:
tw = tw*10 + ord(targetWord[i]) - ord('a')
if fw + sw == tw:
return True
return False
Iterate through the attendance record string, tallying counts for absences and consecutive late days. Track the maximum consecutive late days encountered. At each step, check for conditions violating the attendance criteria, like multiple absences or more than two consecutive late days.
Time complexity: O(n), where n is the length of the string s. The function iterates through each character of the string once.
Space complexity: O(1), as the function uses only a constant amount of extra space.
class Solution:
def checkRecord(self, s: str) -> bool:
Absent, Late = 0, 0
for i in s:
if i != 'L':
Late=0
if i=='A':
Absent+=1
if Absent>=2:
return False
else:
Late+=1
if Late>=3:
return False
return True