Python

Question 1

Create an array of 0s

Answer 1

temp = [0]*(r-l+1)

Question 2

sort an array

Answer 2

arr.sort()

Question 3

iterate over keys in dict

Answer 3

for key in dict: print(key,dict[key])

Question 4

defaultdict

Answer 4

from collections import defaultdict
d = defaultdict(int)

seen = defaultdict(set)
for x in range(1000):
for y in range(1000):
seen[x].add(y) # insert a new pair
assert y in seen[x] # check if pair in dictionary

Question 5

Declare a set

Answer 5

By default h = {} is a map so for set, we do h= set()

Question 6

reverse list

Answer 6

list.reverse() -> in place

new_list = list[::-1] -> extra space

Question 7

comparator

Answer 7

from functools import cmp_to_key

key=cmp_to_key(lambda x,y: 1 if str(y)+str(x) > str(x)+str(y) else -1))

Question 8

iterate digits of a number if need to iterate msb to lsb

Answer 8

dictmap = {
'0' : 0,
'1' : 1,
'2' : 2,
'3' : 3,
'8' : 8,
'9' : 9
}

def each_dig_in_num(n):
dm = dictmap #faster if local
s = repr(n) #repr is faster than str
for char in s:
foo(dm[char])

Question 9

iterate digits of a number if order doesn’t matter

Answer 9

n2 = n
while n2 > 0:
d = n2 % 10
n2 /= 10
foo(d)

Question 10

other ways to iterate digits of a number using typecasting

Answer 10

2.

n = 12345

#1.
s = str(n)
for i in s:
d = int(i)
foo(d)

nl = map(int, str(n))
for d in nl:
foo(d)

nl = [int(x) for x in str(n)]
for d in nl:
foo(d)

Of those, I have, a bit surprised, found that #1 is the fastest, and
that #2 using map() is faster than #3 using list comprehension. I also
registered that that repr(n) is about 8% faster than str(n)

Question 11

stack using deque

Answer 11

from collections import deque
stack = deque()

Deque is preferred over list in the cases where we need quicker append and pop operations from both the ends of the container, as deque provides an O(1) time complexity for append and pop operations as compared to list which provides O(n) time complexity.

Question 12

min heap (default)

Answer 12

heapify(), heappush() and heappop()

# importing "heapq" to implement heap queue 
import heapq 

li = [5, 7, 9, 1, 3] # initializing list

# using heapify to convert list into heap 
heapq.heapify(li) 

# printing created heap 
print (list(li)) 

# using heappush() to push elements into heap 
heapq.heappush(li,4) 

# using heappop() to pop smallest element 
print (heapq.heappop(li))

Question 13

Heap operations

Answer 13

import heapq

1. heapify(iterable)
2. heappush(heap, ele)
3. heappop(heap)
4. heappushpop(heap, ele)
5. heapreplace(heap, ele): In this, element is first popped, then the element is pushed.i.e, the value larger than the pushed value can be returned. heapreplace() returns the smallest value originally in heap regardless of the pushed element as opposed to heappushpop().
6. nlargest(k, iterable, key = fun)
7. nsmallest(k, iterable, key = fun)

Question 14

Integer division of negative numbers

Answer 14

Because // is floor division, so rounding down, not towards zero.-22 / 10 is -2.2, rounding down makes that -3

Question 15

deque operations

Answer 15

append() :- This function is used to insert the value in its argument to the right end of deque.
appendleft() :- This function is used to insert the value in its argument to the left end of deque.
pop() :- This function is used to delete an argument from the right end of deque.
popleft() :- This function is used to delete an argument from the left end of deque.

Question 16

Want to Stand Out in Python Job Interviews?

Answer 16

𝟭. 𝗨𝘀𝗲 “𝘁𝘆𝗽𝗲 𝗵𝗶𝗻𝘁𝘀” 𝘁𝗼 𝗺𝗮𝗸𝗲 𝗰𝗼𝗱𝗲 𝗺𝗼𝗿𝗲 𝗿𝗲𝗮𝗱𝗮𝗯𝗹𝗲: Type hints make it easier to understand the expected types of function arguments and return values. For example, def demo(x: int, y: str, z: float = 100) -> bool:.

𝟮. 𝗨𝘀𝗲 𝗽𝗿𝗼𝗽𝗲𝗿 𝗲𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 𝗵𝗮𝗻𝗱𝗹𝗶𝗻𝗴: Catch specific exceptions to understand what went wrong in the code. Avoid using bare except clause that catches all the exceptions.
For example,
try:
some_code()
except ValueError:
handle_value_error()

𝟯. 𝗨𝘀𝗲 “𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝗺𝗮𝗻𝗮𝗴𝗲𝗿𝘀” 𝗳𝗼𝗿 𝗿𝗲𝘀𝗼𝘂𝗿𝗰𝗲 𝗺𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁: This ensures that resources such as file handles and database connections are properly managed and closed.
For example, with open(“demo.txt”, mode=”w”) as file:

𝟰. 𝗨𝘀𝗲 “𝗲𝗹𝘀𝗲” 𝘄𝗶𝘁𝗵 “𝗳𝗼𝗿” 𝗮𝗻𝗱 “𝘄𝗵𝗶𝗹𝗲” 𝗹𝗼𝗼𝗽𝘀: It’s the pythonic way of indicating that all items were processed in their natural course.

𝟱. 𝗨𝘀𝗲 𝗱𝗶𝗰𝘁.𝗴𝗲𝘁() 𝗺𝗲𝘁𝗵𝗼𝗱: It provides a way to avoid errors when a key is not present and allows you to return a default value when the key is not present. For example, my_dict.get(‘key’, default_val).

𝟲. 𝗨𝘀𝗲 “𝗶𝘀𝗶𝗻𝘀𝘁𝗮𝗻𝗰𝗲” 𝘁𝗼 𝗰𝗵𝗲𝗰𝗸 𝗳𝗼𝗿 “𝗼𝗯𝗷𝗲𝗰𝘁 𝘁𝘆𝗽𝗲” 𝗲𝗾𝘂𝗮𝗹𝗶𝘁𝘆: It’s the recommended way to compare object types in Python, especially with inherited objects.

𝟳. 𝗨𝘀𝗲 “𝗶𝘀” 𝗳𝗼𝗿 𝗲𝗾𝘂𝗮𝗹𝗶𝘁𝘆 𝘄𝗶𝘁𝗵 𝘀𝗶𝗻𝗴𝗹𝗲𝘁𝗼𝗻: Use is to check for None, True, and False instead of ==. It checks if the two items reference the same object in memory, while == checks for value equality.

𝟴. 𝗨𝘀𝗲 𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗽𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 𝘁𝗲𝗰𝗵𝗻𝗶𝗾𝘂𝗲𝘀 𝘀𝘂𝗰𝗵 𝗮𝘀 𝗺𝗮𝗽, 𝗿𝗲𝗱𝘂𝗰𝗲, 𝗮𝗻𝗱 𝗳𝗶𝗹𝘁𝗲𝗿 𝘁𝗼 𝗺𝗮𝗸𝗲 𝗰𝗼𝗱𝗲 𝗲𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝘁: They provide a concise way of transforming and filtering data in a list. For example, squared = map(lambda x: x*x, [1, 2, 3]).

𝟵. 𝗨𝘀𝗲 “𝗱𝗼𝗰𝘀𝘁𝗿𝗶𝗻𝗴𝘀” 𝗮𝗻𝗱 “𝗰𝗼𝗺𝗺𝗲𝗻𝘁𝘀”: Docstrings provide a way to document what a function or module does, as well as its input and output. Single-line comments can also help explain complex expressions.

𝟭𝟬. 𝗗𝗲𝗳𝗶𝗻𝗲 𝘁𝗵𝗲 “𝗿𝗲𝗽𝗿 “𝗺𝗲𝘁𝗵𝗼𝗱 𝗳𝗼𝗿 𝗼𝗯𝗷𝗲𝗰𝘁𝘀: Implementing repr allows you to define a string representation for objects. This can be helpful for debugging and logging.

𝟭𝟭. 𝗨𝘀𝗲 𝗹𝗼𝗴𝗴𝗶𝗻𝗴 𝗶𝗻𝘀𝘁𝗲𝗮𝗱 𝗼𝗳 𝗽𝗿𝗶𝗻𝘁: Logging provides a more consistent way of displaying messages, and allows you to filter messages by setting the correct log level.