Python tips and tricks for competitive programming

Here are some Python hacks for competitive programming that can help you write efficient and concise code.

String Operation

Join

The join() method takes all items in an iterable and joins them into one string.
A string must be specified as the separator.
Iterable –> string

Synatx

string.join(iterable)

string.join(iterable)

Python

Example

myTuple = ("John", "Peter", "Vicky")
x = "->".join(myTuple)
print(x) #John->Peter->Vicky


myList = ["John", "Peter", "Vicky"]
x = "".join(myList)
print(x) #JohnPeterVicky

myTuple = ("John", "Peter", "Vicky")
x = "->".join(myTuple)
print(x) #John->Peter->Vicky


myList = ["John", "Peter", "Vicky"]
x = "".join(myList)
print(x) #JohnPeterVicky

Python

Perform join in integer

lst = ['1','2','3','4']
print("".join(lst)) #1234

lst = [1,2,3,4]
print("".join(lst)) #TypeError: sequence item 0: expected str instance, int found


lst = ['1','2','3','4']
print("".join(lst)) #1234

lst = [1,2,3,4]
print("".join(lst)) #TypeError: sequence item 0: expected str instance, int found

Python

Solution

lst = [1,2,3,4]
print("".join(map(str,lst))) #1234

lst = [1,2,3,4]
print("".join(map(str,lst))) #1234

Python

Dictionary

When using a dictionary as an iterable, the returned values are the keys, not the values.

myDict = {"name": "John", "country": "Norway"}
mySeparator = "="

x = mySeparator.join(myDict)

print(x) #name=country

myDict = {"name": "John", "country": "Norway"}
mySeparator = "="

x = mySeparator.join(myDict)

print(x) #name=country

Python

Split

The split() method splits a string into a list.

You can specify the separator, default separator is any whitespace.

Syntax

string.split(separator, maxsplit)

string.split(separator, maxsplit)

Python

separator Optional. Specifies the separator to use when splitting the string. By default any whitespace is a separator
maxsplit Optional. Specifies how many splits to do. Default value is -1, which is “all occurrences”

Example

txt = "welcome to the jungle"

x = txt.split()

print(x) # ['welcome', 'to', 'the', 'jungle']

txt = "hello, my name is Peter, I am 26 years old"

x = txt.split()
y = txt.split(", ")
z = txt.split(", ",1)

print(x) # ['hello,', 'my', 'name', 'is', 'Peter,', 'I', 'am', '26', 'years', 'old']
print(y) # ['hello', 'my name is Peter', 'I am 26 years old']
print(z) # ['hello', 'my name is Peter, I am 26 years old']

txt = "welcome to the jungle"

x = txt.split()

print(x) # ['welcome', 'to', 'the', 'jungle']

txt = "hello, my name is Peter, I am 26 years old"

x = txt.split()
y = txt.split(", ")
z = txt.split(", ",1)

print(x) # ['hello,', 'my', 'name', 'is', 'Peter,', 'I', 'am', '26', 'years', 'old']
print(y) # ['hello', 'my name is Peter', 'I am 26 years old']
print(z) # ['hello', 'my name is Peter, I am 26 years old']

Python

strip()

The strip() method removes any leading, and trailing whitespaces.
Leading means at the beginning of the string, trailing means at the end.
You can specify which character(s) to remove, if not, any whitespaces will be removed.

Syntax

string.strip(characters)

string.strip(characters)

Python

Example

txt = "     banana     "
x = txt.strip()
print(x)   # banana


txt = ",,,,,rrttgg.....banana....rrr"
x = txt.strip(",.grt") #  banana
print(x)

Python

“,.grt” –> stripping , . g r t

rstrip and lstrip

The lstrip() method removes any leading characters (space is the default leading character to remove)
The rstrip() method removes any trailing characters (characters at the end a string), space is the default trailing character to remove.

txt = "...banana,,,,,ssqqqww....."

print(txt.rstrip(",.qsw")) # ...banana
print(txt.lstrip(",.qsw")) # banana,,,,,ssqqqww.....

txt = "...banana,,,,,ssqqqww....."

print(txt.rstrip(",.qsw")) # ...banana
print(txt.lstrip(",.qsw")) # banana,,,,,ssqqqww.....

Python

index() and find()

find()

The find() method finds the first occurrence of the specified value.
The find() method returns -1 if the value is not found.

index()

The index() method finds the first occurrence of the specified value.
The index() method raises an exception if the value is not found.

Syntax

string.index(value, start, end)
string.find(value, start, end)

string.index(value, start, end)
string.find(value, start, end)

Python

Example

txt = "Mi casa, su casa."

print(txt.find("casa")) # 3
print(txt.index("casa")) # 3

print(txt.find("hi")) # -1
#print(txt.index("hi")) # error ValueError: substring not found

txt = "Mi casa, su casa."

print(txt.find("casa")) # 3
print(txt.index("casa")) # 3

print(txt.find("hi")) # -1
#print(txt.index("hi")) # error ValueError: substring not found

Python

rindex() and rfind()

rfind()

The rfind() method finds the last occurrence of the specified value.
The rfind() method returns -1 if the value is not found.

rindex()

The rindex() method finds the last occurrence of the specified value.
The rindex() method raises an exception if the value is not found.

Syntax

string.rfind(value, start, end)

string.rindex(value, start, end)

string.rfind(value, start, end)

string.rindex(value, start, end)

Python

Example

txt = "Mi casa, su casa."

print(txt.rfind("casa")) # 12
print(txt.rindex("casa")) # 12

print(txt.rfind("hi")) # -1
print(txt.rindex("hi")) # error ValueError: substring not found

txt = "Mi casa, su casa."

print(txt.rfind("casa")) # 12
print(txt.rindex("casa")) # 12

print(txt.rfind("hi")) # -1
print(txt.rindex("hi")) # error ValueError: substring not found

Python

Find out all occurrence

result = []

lst = "my name is backendmesh"

index = lst.find("m")
while(index>-1):
    result.append(index)
    lst = lst[index+1:]
    index = lst.find("m")

print(result) #[0, 4, 12]

result = []

lst = "my name is backendmesh"

index = lst.find("m")
while(index>-1):
    result.append(index)
    lst = lst[index+1:]
    index = lst.find("m")

print(result) #[0, 4, 12]

Python

partition()

The partition() method searches for a specified string, and splits the string into a tuple containing three elements.
The first element contains the part before the specified string.
The second element contains the specified string.
The third element contains the part after the string.

txt = "I could eat bananas all day"

x = txt.partition("bananas") 

print(x) # ('I could eat ', 'bananas', ' all day')

txt = "I could eat bananas all day"

x = txt.partition("bananas") 

print(x) # ('I could eat ', 'bananas', ' all day')

Python

replace()

The replace() method replaces a specified phrase with another specified phrase.

string.replace(oldvalue, newvalue, count)

string.replace(oldvalue, newvalue, count)

Python

oldvalue Required. The string to search for
newvalue Required. The string to replace the old value with
count Optional. A number specifying how many occurrences of the old value you want to replace. Default is all occurrences

txt = "one one one one"

print(txt.replace("one", "three")) # three three three three
print(txt.replace("one", "three", 2)) # three three one one

txt = "one one one one"

print(txt.replace("one", "three")) # three three three three
print(txt.replace("one", "three", 2)) # three three one one

Python

String to list

#String to list
word = "hello"
print(list(word)) #['h', 'e', 'l', 'l', 'o']


#list to string
lst = ['h', 'e', 'l', 'l', 'o']
print("".join(lst)) #hello


#String to list
word = "hello"
print(list(word)) #['h', 'e', 'l', 'l', 'o']


#list to string
lst = ['h', 'e', 'l', 'l', 'o']
print("".join(lst)) #hello

Python

String to ASCII

print(ord('a')) #97
print(ord('A')) #65

print(ord('a')) #97
print(ord('A')) #65

Python

Question: Assign A=1,……Z=26

print(ord('A')-64) #1
print(ord('Z')-64) #26

OR 

print(ord('A')-ord('A')+1) #1
print(ord('Z')-ord('A')+1) #26

print(ord('A')-64) #1
print(ord('Z')-64) #26

OR 

print(ord('A')-ord('A')+1) #1
print(ord('Z')-ord('A')+1) #26

Python

ASCII to String

print(chr(97)) #a
print(chr(65)) #A


print(chr(97)) #a
print(chr(65)) #A

Python

Loops

Range

range(start, stop, step)
Generates numbers from start to stop – 1, incrementing by step.

for i in range(2,n) # 2 to n-1
for i in range(0,n) # 0 to n-1
for i in range(0,n,2) # 0,2,4,6 ...
for i in range(n) # 0 to n-1
for i in range(n,0,-1) # n to 1
for i in range(n,-1,-1) # n to 0

for i in range(2,n) # 2 to n-1
for i in range(0,n) # 0 to n-1
for i in range(0,n,2) # 0,2,4,6 ...
for i in range(n) # 0 to n-1
for i in range(n,0,-1) # n to 1
for i in range(n,-1,-1) # n to 0

Python

Array/List

Python does not have built-in support for arrays like other languages (C, Java), but lists can be used as dynamic arrays.

Initialisation with Default value

arr = [0] * 10  # Creates an array of size 10 with all elements as 0
arr = [1] * 10  # Creates an array of size 10 with all elements as 1

arr = [0] * 10  # Creates an array of size 10 with all elements as 0
arr = [1] * 10  # Creates an array of size 10 with all elements as 1

Python

Delete

Delete an element from a list.

Way 1: Using remove() (by value):

my_list = [1, 2, 3, 4, 5,3]
my_list.remove(3)  # Removes the first occurrence of 3
print(my_list)  # [1, 2, 4, 5, 3]

my_list = [1, 2, 3, 4, 5,3]
my_list.remove(3)  # Removes the first occurrence of 3
print(my_list)  # [1, 2, 4, 5, 3]

Python

Way 2: Slice

my_list = [1, 2, 3, 4, 5,3]
my_list = my_list[:2]+my_list[3:] # 0 to 1 and 3 to end
print(my_list)

my_list = [1, 2, 3, 4, 5,3]
my_list = my_list[:2]+my_list[3:] # 0 to 1 and 3 to end
print(my_list)

Python

Way 3: Using pop() (by index):

my_list = [1, 2, 3, 4, 5, 3]
my_list.pop(2)  # Removes the element at index 2 (which is 3)
print(my_list)  # [1, 2, 4, 5, 3]

my_list = [1, 2, 3, 4, 5, 3]
my_list.pop(2)  # Removes the element at index 2 (which is 3)
print(my_list)  # [1, 2, 4, 5, 3]

Python

Way 4: Using del (by index):

my_list = [1, 2, 3, 4, 5, 3]
del my_list[2]  # Deletes the element at index 2
print(my_list)  # [1, 2, 4, 5, 3]

my_list = [1, 2, 3, 4, 5, 3]
del my_list[2]  # Deletes the element at index 2
print(my_list)  # [1, 2, 4, 5, 3]

Python

pop vs del

Feature	`pop()`	`del`
Purpose	Removes an element and returns it	Just deletes the element (no return)
Usage	`list.pop(index)`	`del list[index]`
Default	If no index, removes last item (`pop()`)	No default; you must give an index or slice
Error on wrong index	Yes (`IndexError`)	Yes (`IndexError`)
Return value	Yes, returns the removed item	No, just deletes

with power comes responsibility

length = len(nums)
for i in range(0, length):   
    nums.pop(i). #IndexError: pop index out of range

length = len(nums)
for i in range(0, length):   
    nums.pop(i). #IndexError: pop index out of range

Python

gives an error because you are modifying the list (pop) while looping through it forward — but when you pop(i), the list shrinks, and the indices shift!

👉 So i becomes out of range very quickly.

Example:

nums = [10, 20, 30, 40, 50]

for i in range(2, length):   
    nums.pop(i). #IndexError: pop index out of range
    #or 
    #del nums[i]

explanation
del nums[2] # [10, 20, 40, 50]
del nums[3] # [10,20,40]
del nums[4] # error

nums = [10, 20, 30, 40, 50]

for i in range(2, length):   
    nums.pop(i). #IndexError: pop index out of range
    #or 
    #del nums[i]

explanation
del nums[2] # [10, 20, 40, 50]
del nums[3] # [10,20,40]
del nums[4] # error

Python

i = 2, you pop(2), list becomes [10, 20, 40, 50]
Now i = 3, but after pop, the list is smaller, so nums[3] = 50 is still OK
Then i = 4, but now list length is only 4, so nums[4] ❌ IndexError.

Solution 1 :slice

del nums[j:]

del nums[j:]

Python

Solution 2 : Loop backward (so popping doesn’t affect upcoming elements):

length = len(nums)
for i in range(length-1, j-1, -1):   
    nums.pop(i)

length = len(nums)
for i in range(length-1, j-1, -1):   
    nums.pop(i)

Python

Negative index in List

lst = [1,2,3,4,5,6,7,8,9]
print(lst[-1]) #9
print(lst[-2]) #8
print(lst[-3]) #7

lst = [1,2,3,4,5,6,7,8,9]
print(lst[-1]) #9
print(lst[-2]) #8
print(lst[-3]) #7

Python

Dictionary

Default Value

Instead of manually checking if a key exists in a dictionary, use defaultdict.

from collections import defaultdict

my_dict = {}
my_dict['a'] = 4
print(my_dict['a']) # 4
print(my_dict['b']) # error KeyError: 'b'

d = defaultdict(int)  # Default value is 0
d['a'] = 1
print(d['a'])  # 1
print(d['b'])  # 0 (instead of KeyError)

my_dict = defaultdict(int)
print(my_dict['my_key']) # 0
my_dict = defaultdict(list)
print(my_dict['my_key']) # []

from collections import defaultdict

my_dict = {}
my_dict['a'] = 4
print(my_dict['a']) # 4
print(my_dict['b']) # error KeyError: 'b'

d = defaultdict(int)  # Default value is 0
d['a'] = 1
print(d['a'])  # 1
print(d['b'])  # 0 (instead of KeyError)

my_dict = defaultdict(int)
print(my_dict['my_key']) # 0
my_dict = defaultdict(list)
print(my_dict['my_key']) # []

Python

Default Values

int : 0
float : 0.0
str : ”
bool : False

Why?

Without defaultdict: Everytime before using value , we needs to check if exist

counts = {}
words = ['apple', 'banana', 'apple']

for word in words:
    if word in counts:
        counts[word] += 1
    else:
        counts[word] = 1

counts = {}
words = ['apple', 'banana', 'apple']

for word in words:
    if word in counts:
        counts[word] += 1
    else:
        counts[word] = 1

Python

With defaultdict:

from collections import defaultdict

counts = defaultdict(int)  # int() defaults to 0

for word in ['apple', 'banana', 'apple']:
    counts[word] += 1

print(counts)

from collections import defaultdict

counts = defaultdict(int)  # int() defaults to 0

for word in ['apple', 'banana', 'apple']:
    counts[word] += 1

print(counts)

Python

It’s shorthand
count[‘any_key’] will never throw an error. Will always get a default value

Example 2

List as default value

from collections import defaultdict

d = defaultdict(list)   # Automatically assigns an empty list as the default value
d['a'].append(10)       # Since 'a' doesn't exist, it's initialized to [] first, then 10 is appended
print(d['a'])           # Output: [10]

print(d['b'])    # []

from collections import defaultdict

d = defaultdict(list)   # Automatically assigns an empty list as the default value
d['a'].append(10)       # Since 'a' doesn't exist, it's initialized to [] first, then 10 is appended
print(d['a'])           # Output: [10]

print(d['b'])    # []

Python

Swap Two Variables

a, b = 5, 10
a, b = b, a
print(a, b)  # 10, 5

a, b = 5, 10
a, b = b, a
print(a, b)  # 10, 5

Python

Additional variable not required

It’s very usefully and handy to use.

Example: Reverse a list

arr = [1, 2, 3, 4, 5,6,7,8,9,10]
start = 0
lst   = len(arr)-1

while start<=lst:
    arr[lst],arr[start] = arr[start],arr[lst]
    start+=1
    lst-=1

print(arr)

arr = [1, 2, 3, 4, 5,6,7,8,9,10]
start = 0
lst   = len(arr)-1

while start<=lst:
    arr[lst],arr[start] = arr[start],arr[lst]
    start+=1
    lst-=1

print(arr)

Python

Use itertools for Combinations & Permutations

from itertools import permutations, combinations
print(list(permutations([1, 2, 3], 2)))  # [(1,2), (1,3), (2,1), ...]
print(list(combinations([1, 2, 3], 2)))  # [(1,2), (1,3), (2,3)]

from itertools import permutations, combinations
print(list(permutations([1, 2, 3], 2)))  # [(1,2), (1,3), (2,1), ...]
print(list(combinations([1, 2, 3], 2)))  # [(1,2), (1,3), (2,3)]

Python

Use enumerate to Avoid Extra Index Handling

arr = [10, 20, 30]
for i, val in enumerate(arr, start=1):
    print(i, val)

arr = [10, 20, 30]
for i, val in enumerate(arr, start=1):
    print(i, val)

Python

Use divmod() for Simultaneous Quotient & Remainder

q, r = divmod(10, 3)
print(q, r)  # 3 1

q, r = divmod(10, 3)
print(q, r)  # 3 1

Python

Use enumerate() for Cleaner Loops

Instead of:

arr = [10, 20, 30]
for i in range(len(arr)):
    print(i, arr[i])

arr = [10, 20, 30]
for i in range(len(arr)):
    print(i, arr[i])

Python

Use:

for i, val in enumerate(arr, start=1):
    print(i, val)

for i, val in enumerate(arr, start=1):
    print(i, val)

Python

Reverse a String or List in One Line

s = "hello"
print(s[::-1])  # "olleh"

arr = [1, 2, 3, 4]
print(arr[::-1])  # [4, 3, 2, 1]

s = "hello"
print(s[::-1])  # "olleh"

arr = [1, 2, 3, 4]
print(arr[::-1])  # [4, 3, 2, 1]

Python

For in-place list reversal (better performance):

arr.reverse()

arr.reverse()

Python

This will not work for string

reversed()

It works on sequences like lists, tuples, strings, etc.
It does not modify the original sequence; it just gives you the items in reverse order.
Since it returns an iterator, if you want a reversed list, you can do:

reversed_list = list(reversed(my_list))
print(reversed_list)
# Output: [5, 4, 3, 2, 1]



word = "hello"
print(reversed(word)) #<reversed object at 0x100c27d60>
print(''.join(reversed(word)))  # Output: "olleh"

reversed_list = list(reversed(my_list))
print(reversed_list)
# Output: [5, 4, 3, 2, 1]



word = "hello"
print(reversed(word)) #<reversed object at 0x100c27d60>
print(''.join(reversed(word)))  # Output: "olleh"

Python

Take out every thing except ‘i’ element

lst = [1,2,3,4,5,6,7,8]
i =3
current   = lst[i]
remaining = lst[:i]+lst[i+1:]


print(current)   # 4
print(remaining) # [1, 2, 3, 5, 6, 7, 8]

lst = [1,2,3,4,5,6,7,8]
i =3
current   = lst[i]
remaining = lst[:i]+lst[i+1:]


print(current)   # 4
print(remaining) # [1, 2, 3, 5, 6, 7, 8]

Python

One-Liner If-Else (Ternary Operator)

Instead of:

x = 10
if x > 5:
    y = "big"
else:
    y = "small"

x = 10
if x > 5:
    y = "big"
else:
    y = "small"

Python

Use:

y = "big" if x > 5 else "small"

y = "big" if x > 5 else "small"

Python

Find Unique Elements in a List Faster

arr = [1, 2, 2, 3, 3, 4]

unique_arr = list(set(arr))
print(unique_arr)

arr = [1, 2, 2, 3, 3, 4]

unique_arr = list(set(arr))
print(unique_arr)

Python

a = path vs a = path[:]

In Python, assigning a list can either create a reference or a copy:

a = path creates a reference to the same list. Changes to a will affect path and vice versa.
a = path[:] creates a shallow copy of the list. Changes to a will not affect path.

Use a = path[:] when:

You want to preserve the original list.
You’re in recursive or backtracking algorithms and need a snapshot of the current state.

Use a = path when:

You want to modify the original list through another name.
You don’t need to preserve the original list.

In backtracking, always use res.append(path[:]) to avoid bugs from shared list references.Refer

Common List Lengths in String/Array Operations

Operation	List Length	Reason
String Multiplication	`[0] * (len(num1) + len(num2))`	Max digits in result = m + n
String Addition	`[0] * (max(len(num1), len(num2)) + 1)`	One extra digit possible from carry
Array Number Addition	`[0] * (max(len(arr1), len(arr2)) + 1)`	Same as string addition
Polynomial Multiplication	`[0] * (len(A) + len(B) - 1)`	Degree of result = (m-1) + (n-1)
Prefix Sum Array	`[0] * (len(nums) + 1)`	Extra space for simpler range sum queries
Suffix Sum Array	`[0] * (len(nums) + 1)`	Similar to prefix sum, but in reverse
1D DP Array	`[0] * (n + 1)`	Space for base cases and up to `n`
2D DP Table	`[[0] * (m + 1) for _ in range(n + 1)]`	For problems needing rows × cols + base cases

Multi-key sorting

Sorting by multiple columns

Example

employees = [
    {"name": "Zara", "age": 25, "salary": 90000},
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Bob", "age": 30, "salary": 80000},
]

employees = [
    {"name": "Zara", "age": 25, "salary": 90000},
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Bob", "age": 30, "salary": 80000},
]

Python

Sorting Priorities:

Salary → descending (highest salary first)
Age → ascending (youngest first)
Name → lexicographically (alphabetical order)

Expected Output

[
    {"name": "Zara", "age": 25, "salary": 90000},  # Salary 90k, youngest in 90k group
    {"name": "Alex", "age": 30, "salary": 90000},  # Same salary, older
    {"name": "Mike", "age": 25, "salary": 80000},  # Salary 80k, youngest in 80k group
    {"name": "Bob", "age": 30, "salary": 80000},   # Same salary, older
]

[
    {"name": "Zara", "age": 25, "salary": 90000},  # Salary 90k, youngest in 90k group
    {"name": "Alex", "age": 30, "salary": 90000},  # Same salary, older
    {"name": "Mike", "age": 25, "salary": 80000},  # Salary 80k, youngest in 80k group
    {"name": "Bob", "age": 30, "salary": 80000},   # Same salary, older
]

Python

Follow same priority order as it is.

employees = [
    {"name": "Zara", "age": 25, "salary": 90000},
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Bob", "age": 30, "salary": 80000},
]



Step 1  Salary → descending (highest salary first)

employees = [
    {"name": "Zara", "age": 25, "salary": 90000},
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Bob", "age": 30, "salary": 80000},
]




Step 2 Age → ascending (youngest first)

employees = [
    {"name": "Zara", "age": 25, "salary": 90000},
     {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Bob", "age": 30, "salary": 80000},
]

Step 3  : Name → lexicographically (alphabetical order)

Our Output

employees = [
      {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Bob", "age": 30, "salary": 80000},
     {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Zara", "age": 25, "salary": 90000},
    
]




Expected Output

[
    {"name": "Zara", "age": 25, "salary": 90000},  # Salary 90k, youngest in 90k group
    {"name": "Alex", "age": 30, "salary": 90000},  # Same salary, older
    {"name": "Mike", "age": 25, "salary": 80000},  # Salary 80k, youngest in 80k group
    {"name": "Bob", "age": 30, "salary": 80000},   # Same salary, older
]

employees = [
    {"name": "Zara", "age": 25, "salary": 90000},
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Bob", "age": 30, "salary": 80000},
]



Step 1  Salary → descending (highest salary first)

employees = [
    {"name": "Zara", "age": 25, "salary": 90000},
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Bob", "age": 30, "salary": 80000},
]




Step 2 Age → ascending (youngest first)

employees = [
    {"name": "Zara", "age": 25, "salary": 90000},
     {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Bob", "age": 30, "salary": 80000},
]

Step 3  : Name → lexicographically (alphabetical order)

Our Output

employees = [
      {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Bob", "age": 30, "salary": 80000},
     {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Zara", "age": 25, "salary": 90000},
    
]




Expected Output

[
    {"name": "Zara", "age": 25, "salary": 90000},  # Salary 90k, youngest in 90k group
    {"name": "Alex", "age": 30, "salary": 90000},  # Same salary, older
    {"name": "Mike", "age": 25, "salary": 80000},  # Salary 80k, youngest in 80k group
    {"name": "Bob", "age": 30, "salary": 80000},   # Same salary, older
]

Python

Why this is wrong:

Sorting by age after sorting by salary does not preserve the salary order because you’re sorting the full list again, not just within salary groups.
Sorting by name last again sorts the whole list, destroying the previous order completely.

Reverse priority orde

When sorting by multiple columns, apply the last rule first and first rule last, to preserve priority.”

Note:

If you want to sort by multiple criteria (say, A then B), the primary sort key should be applied last.
The secondary (and less important) sort keys should be applied first.

This is because each successive sort must preserve the order of the previous more important sort — and this is only guaranteed when the sorting is stable (i.e., elements with equal keys retain their relative order).

Why this works:

Sorting from least to most important key (i.e., last rule first) ensures that when a more important rule is applied later, it groups the items while keeping the relative order imposed by less important rules.

This avoids overwriting the priority of the more important keys.

Example

employees = [
    {"name": "Zara", "age": 25, "salary": 90000},
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Bob", "age": 30, "salary": 80000},
]


Step 1 :Name → lexicographically (alphabetical order) 

employees = [
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Bob", "age": 30, "salary": 80000},
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Zara", "age": 25, "salary": 90000}, 
]



Step 2 Age → ascending (youngest first)

employees = [
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Zara", "age": 25, "salary": 90000}, 
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Bob", "age": 30, "salary": 80000},
]




Step 3  Salary → descending (highest salary first)

# Our Output 

employees = [
    {"name": "Zara", "age": 25, "salary": 90000}, 
    {"name": "Alex", "age": 30, "salary": 90000},
     {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Bob", "age": 30, "salary": 80000},
]


# Expected Output

[
    {"name": "Zara", "age": 25, "salary": 90000},  # Salary 90k, youngest in 90k group
    {"name": "Alex", "age": 30, "salary": 90000},  # Same salary, older
    {"name": "Mike", "age": 25, "salary": 80000},  # Salary 80k, youngest in 80k group
    {"name": "Bob", "age": 30, "salary": 80000},   # Same salary, older
]

employees = [
    {"name": "Zara", "age": 25, "salary": 90000},
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Bob", "age": 30, "salary": 80000},
]


Step 1 :Name → lexicographically (alphabetical order) 

employees = [
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Bob", "age": 30, "salary": 80000},
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Zara", "age": 25, "salary": 90000}, 
]



Step 2 Age → ascending (youngest first)

employees = [
    {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Zara", "age": 25, "salary": 90000}, 
    {"name": "Alex", "age": 30, "salary": 90000},
    {"name": "Bob", "age": 30, "salary": 80000},
]




Step 3  Salary → descending (highest salary first)

# Our Output 

employees = [
    {"name": "Zara", "age": 25, "salary": 90000}, 
    {"name": "Alex", "age": 30, "salary": 90000},
     {"name": "Mike", "age": 25, "salary": 80000},
    {"name": "Bob", "age": 30, "salary": 80000},
]


# Expected Output

[
    {"name": "Zara", "age": 25, "salary": 90000},  # Salary 90k, youngest in 90k group
    {"name": "Alex", "age": 30, "salary": 90000},  # Same salary, older
    {"name": "Mike", "age": 25, "salary": 80000},  # Salary 80k, youngest in 80k group
    {"name": "Bob", "age": 30, "salary": 80000},   # Same salary, older
]

Python

Code

employees.sort(key=lambda x:x["name"])
employees.sort(key=lambda x:x["age"])
employees.sort(key=lambda x:x["salary"],reverse=True)


# Output

[
  {'name': 'Zara', 'age': 25, 'salary': 90000}, 
  {'name': 'Alex', 'age': 30, 'salary': 90000}, 
  {'name': 'Mike', 'age': 25, 'salary': 80000},
  {'name': 'Bob', 'age': 30, 'salary': 80000}
]


employees.sort(key=lambda x:x["name"])
employees.sort(key=lambda x:x["age"])
employees.sort(key=lambda x:x["salary"],reverse=True)


# Output

[
  {'name': 'Zara', 'age': 25, 'salary': 90000}, 
  {'name': 'Alex', 'age': 30, 'salary': 90000}, 
  {'name': 'Mike', 'age': 25, 'salary': 80000},
  {'name': 'Bob', 'age': 30, 'salary': 80000}
]

Python

When sorting by multiple columns, apply the last rule first and first rule last, to preserve priority.

Python tips and tricks for competitive programming

Table of Contents

String Operation

Join

Perform join in integer

Split

strip()

rstrip and lstrip

index() and find()

rindex() and rfind()

Find out all occurrence

partition()

replace()

String to list

String to ASCII

ASCII to String

Loops

Range

Array/List

Initialisation with Default value

Delete

Negative index in List

Dictionary

Default Value

Swap Two Variables

Use itertools for Combinations & Permutations

Use enumerate to Avoid Extra Index Handling

Use divmod() for Simultaneous Quotient & Remainder

Use enumerate() for Cleaner Loops

Reverse a String or List in One Line

Take out every thing except ‘i’ element

One-Liner If-Else (Ternary Operator)

Find Unique Elements in a List Faster

a = path vs a = path[:]

Common List Lengths in String/Array Operations

Multi-key sorting

Why this is wrong:

Why this works:

Leave a Comment Cancel reply