Python: last minute notes for your coding interviews
Tags: python, career, computerscience
Published: 2022-04-16 08:50:46

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

```python
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:

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

## 3. Sort based on key and reverse

```python
# 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

```python
if isinstance(x, list)

# OR

if type(x) is list
```

## 5. ASCII values

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

ord('Z') = 90

ord('a') = 97

ord('z') = 122

chr(65) = 'A'
```

## 6. Limit float to 2 decimal places

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

## 7. Using a double ended queue

```python
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

```python
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

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

## 10. Combinations vs Permutations

```python
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

```python
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

```python
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!