DEV Community is a community of 879,630 amazing developers

We're a place where coders share, stay up-to-date and grow their careers.

Omkar Bhagat

Posted on

Python: last minute notes for your coding interviews

If you are someone who opts for the Python language for your coding (data structures and algorithms) interviews, then you may want to bookmark this post for your last minute revision.

1. Convert dictionary key-values to a list of tuples

``````seen = {'i': 2, 'love': 2, 'leetcode': 1, 'coding': 1}

seen.items()
# [('i', 2), ('love', 2), ('coding', 1), ('leetcode', 1)]
``````

2. Populating a dictioonary with +1/-1

Quickly increment or decrement a value of a key in a dictionary:

``````seen[c] = 1 + seen.get(c,0)
seen[c] = seen.get(c,0) - 1
``````

3. Sort based on key and reverse

``````# sorting interval at index i
# by 1st value as key in that interval
# [ [1,2], [3,4] ]
# and then reversing the result
# [ [3,4], [1,2] ]

items.sort(key=lambda x: x[1], reverse=True)
``````

4. Check if list type

``````if isinstance(x, list)

# OR

if type(x) is list
``````

5. ASCII values

``````ord('A') = 65

ord('Z') = 90

ord('a') = 97

ord('z') = 122

chr(65) = 'A'
``````

6. Limit float to 2 decimal places

``````round(x, 2)
``````

7. Using a double ended queue

``````from collections import deque

>>> word = 'hit'

>>> q = deque([word])
>>> q
deque(['hit'])

>>> q = deque(word)
>>> q
deque(['h', 'i', 't'])

# functions like these exist:
# q.appendleft
# q.popleft
# q.append
# q.pop
``````

8. Creating adjacency list with defaultdict

``````from collections import defaultdict

neighbours = defaultdict(list)

# creates a structure like this:
# neighbours = {
#     key1: [item1, item2],
#     key2: [item1, item2, item3],
# }

# can be populated as follows:
for key, val in somelist:
neighbours[key].append(val)

``````

9. Intersection of two sets

``````>>> a = { 1, 2, 3 }
>>> b = { 3, 4, 5 }
>>> a.intersection(b)
{3}
>>> list(a.intersection(b))
[3]
``````

10. Combinations vs Permutations

``````a = "ABC"

>>> list(itertools.permutations(a))
[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]

>>> list(itertools.combinations(a, 3))
[('A', 'B', 'C')]

>>> list(itertools.combinations(a, 2))
[('A', 'B'), ('A', 'C'), ('B', 'C')]

>>> list(itertools.permutations(a, 2))
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
``````

11. Reading input line by line

``````if __name__ == '__main__':
n = int(input().strip())

words = []

for _ in range(n):
words_item = input()
words.append(words_item)

# call some function after reading..
noPrefix(words)
``````

12. Writing test cases

``````class Solution:

def twoSum(self, nums, target):

seen = {}

for i, num in enumerate(nums):
num2 = target-num

if num2 in seen:
return [seen[num2], i]
else:
seen[num] = i

import unittest
class BasicTests(unittest.TestCase):

testcases = [
([2,7,11,15], 9, [0,1]),
([3,2,4], 6, [1,2]),
([3,3], 6, [0,1])
]

def test1(self):
s = Solution()
for nums, target, expected in self.testcases:
actual = s.twoSum(nums, target)
# print(actual, expected)
assert actual == expected or list(reversed(actual)) == expected

if __name__ == "__main__":
unittest.main()
``````

I have personally found this quite helpful and I hope you too will get some value from it. Good luck!