Recruiters nowadays use online timed tests when screening developers. I recently looked at Python & Algorithms Hard questions at TestDome. While the timing and hints seem to push towards* implementing tricks from scratch*, for the quality in long term it is better to *structure the problem and use established solutions (divide & conquer)*. The battery of “hard” problems can be solved in few lines of code, using the standard Python libraries (Numpy, Pandas, Collections).

**League Table (Hard)**

The task is to essentially sort the football results by multiple criteria: first by the higher number of scores, next (breaking ties) by the lower number of games, finally (breaking ties) by the default order. While the hint suggests building a custom comparator, the *effective way is by Pandas tables* (5 lines).

```
import pandas as pd
def player_rank(self, rank):
ts = []
ts = map(lambda t:(t[1][0],t[1][1]['score'],t[1][1]['games_played'],t[0]),enumerate(self.standings.items()))
df = pd.DataFrame(ts)
df = df.sort_values(by=[1,2,3],ascending=[False,True,True]).reset_index()
return df.loc[rank-1][0]
```

**Sorted Search (Hard)**

The task is to determine how many values in a sorted list are less than the given value. This is equivalent to finding the right position to insert (to maintain the sorted order). While the solution suggests playing with a variant of binary search on your own, the *effective way is by the Python bisect algorithm* (1 line).

```
from bisect import bisect_left
def count_numbers(sorted_list, less_than):
return bisect_left(sorted_list,less_than)
```

**Train Composition (Hard)**

The task is to implement a data structure that mimics composing the train: one can quickly attach and detach to/from both ends. The effective way is to use *Python double-ended queue* (5 lines).

```
from collections import deque
class TrainComposition:
def __init__(self):
self.d = deque()
def attach_wagon_from_left(self, wagonId):
self.d.appendleft(wagonId)
def attach_wagon_from_right(self, wagonId):
self.d.append(wagonId)
def detach_wagon_from_left(self):
return self.d.popleft()
def detach_wagon_from_right(self):
return self.d.pop()
```