close icon platform

Discover more from

Personalized news feed, dev communities and search, much better than whatโ€™s out there. Maybe ;)

Start reading - Free forever
Start reading - Free forever
Continue reading >

Fun Coding Problems: From Easy to Hard

Fun Coding Problems: From Easy to Hard
Nimrod Kramer
Related tags on
Table of contents


Explore a range of fun coding problems that cater to all levels, from beginners to pros. Enhance your problem-solving abilities and sharpen your logical thinking in programming.

Looking to boost your coding skills or prepare for job interviews? Dive into these fun coding problems that cater to all levels, from beginners to pros. You'll find a mix of challenges that will test and enhance your problem-solving abilities in programming. Whether you're new to coding or honing your skills, these problems will provide a comprehensive workout for your brain.

Key Highlights:

  • Basics for Beginners: Start with simple tasks like 'Hello World' variations, basic math problems, and converting minutes to seconds.

  • Intermediate Challenges: Tackle array rotation, the Two Sum problem, and exercises that enhance your string manipulation abilities.

  • Advanced Adventures: Dive into complex challenges like balanced binary tree checks, in-order successor in BSTs, and alien dictionary ordering.

  • Expert-Level Enigmas: Push your limits with tasks involving distributed key-value stores, file compression with Huffman coding, and solving mazes with backtracking.

  • Technology-Specific Challenges: Sharpen your skills in web development, data science, and DevOps with targeted exercises.

Dive into these coding problems to sharpen your logical thinking and problem-solving skills in a fun and challenging way.

Getting Started: What You Need to Know

Before you jump into coding challenges, it's smart to get a good grip on the basics of programming. Here are a few things you should know first:

Learn Programming Basics

Start with the fundamentals such as:

  • What variables are and the different types (like text, numbers, true or false values)

  • How to use basic math and compare things

  • How to make decisions in your code with if statements

  • How to repeat actions with loops

  • How to group code into functions

  • Understanding simple lists and collections

Pick a Language

Start with one programming language. Some easy ones for beginners include:

  • Python - really friendly for beginners and easy to read

  • JavaScript - great for making websites interactive

  • Java - used in a lot of back-end development

  • C++ - a bit more complex but great for understanding how computers work

Learn the basics like how to show messages, use variables, types of data, and how to make functions.

Understand the Problem

When you see a coding problem:

  • Read it well to know what it's asking

  • Think about special cases and limits

  • Plan what inputs go in and what should come out

  • Figure out the steps before coding

Use Online Resources

If you're stuck, look up help like:

  • The official guides for the programming language

  • Stack Overflow for specific questions

  • Online tutorials for more practice

Start Simple

Try easy problems first, then slowly move to harder ones:

  • Work with variables, join texts

  • Do basic math, comparisons

  • Go through lists

  • Make functions that give back results

Understanding the basics well will make tackling harder problems easier.

Beginner-Friendly Challenges

1. Hello World Variations

The first program most people learn in a new programming language is the "Hello World" program. It's a simple code that shows the message "Hello World" on your screen.

Here are some easy and fun ways to change up the Hello World program:

Try It in a Different Language

  • You can write "Hello World" in another language, like:

  • Spanish - "Hola Mundo"

  • French - "Bonjour le monde"

  • Japanese - "Kon'nichiwa sekai"

Make It About You

  • Change "Hello World" to "Hello [Your Name]". Just replace [Your Name] with your actual name.

Say More Than Hello

  • Add a new line with to say "Hello World" and then "Have a nice day!" right after.

Create a Picture

You can also use letters and symbols to draw something like:

*********     ***       *       *
*       *   *     *    ***     * *
*       *  *       *  *****   *   *
*       *  *       *    *    *     *
*       *  *       *    *   *       *  
*       *  *       *    *    *     *
*       *   *     *     *     *   *
*********     ***       *       *

Do It Over and Over

  • Write a loop in your code to print "Hello World" 10 times.

These ideas are just the start. You can try out different things and see what fun you can have with printing messages!

2. Sum of Two Numbers

Let's tackle a basic math problem that's perfect for beginners. Here's what you need to do:

The Problem

Your task is to write a simple program. This program should ask for two numbers, then show you the total of these numbers.







  • Ask the user for two numbers.

  • Save these numbers in two spots, let's call them num1 and num2.

  • Add num1 and num2 together, and save this in a new spot called sum.

  • Show the user the sum.


Here's a way to do this in Python:

num1 = int(input("Enter first number: "))
num2 = int(input("Enter second number: "))

sum = num1 + num2

print("The sum is:", sum) 

And if you're using JavaScript, it looks like this:

let num1 = parseInt(prompt("Enter first number: "));
let num2 = parseInt(prompt("Enter second number: "));

let sum = num1 + num2;

console.log(`The sum is: ${sum}`);


  • Make sure to change the user's input into numbers before adding them up.

  • Show the result in a way that's easy for the user to understand.

  • You can also check if the user actually entered numbers.

This simple problem helps you practice getting information from the user, doing something with it, and then showing the result. It's a good step to get comfortable with before you dive into more complicated programming challenges!

3. Convert Minutes into Seconds

The Problem

Your job is to write a simple program that changes minutes into seconds. This means if someone tells you a number in minutes, your program will tell them what that number is in seconds.







  • First, ask the person using your program for a number in minutes. Let's put this number in a spot called minutes.

  • Since 1 minute is the same as 60 seconds, you just need to multiply the minutes by 60 to get the seconds.

  • Keep this answer in a new spot called seconds.

  • Finally, tell the person how many seconds that is.


Here's how you can do it in Python:

minutes = int(input("Enter number of minutes: "))

seconds = minutes * 60

print(minutes, "minutes is", seconds, "seconds")

And if you're using JavaScript, it looks like this:

let minutes = parseInt(prompt("Enter number of minutes: "));

let seconds = minutes * 60;

console.log(`${minutes} minutes is ${seconds} seconds`); 


  • It's important to check if the minutes entered are a real number. This helps make sure your program works right.

  • When you share the result, make it clear, like saying "X minutes is Y seconds".

Learning to change one type of measurement to another is a useful skill in coding. It's a good way to get comfortable with basic math in programming and sets you up for more challenging tasks later on.

4. FizzBuzz

FizzBuzz is a well-known problem often found in coding interviews. It's a simple way to check your understanding of loops and conditions. Let's break it down:

The Problem

You need to write a program that counts from 1 to 100. But, there's a twist:

  • For numbers that are multiples of 3, you should print "Fizz" instead.

  • For multiples of 5, print "Buzz".

  • And for numbers that are multiples of both 3 and 5, print "FizzBuzz".

Example Output


This pattern continues all the way to 100.


  • Create a loop that goes through numbers 1 to 100

  • Use the modulo operator (%) to check if a number is a multiple of 3, 5, or both

  • Depending on the result, print "Fizz", "Buzz", or "FizzBuzz"

  • If a number isn't a multiple of 3 or 5, just print the number itself

Code Example

Here's a simple way to do it in JavaScript:

for (let i = 1; i <= 100; i++) {

  if (i % 15 == 0) {
  } else if (i % 3 == 0) {
  } else if (i % 5 == 0) {
  } else {


And in Python, it looks like this:

for i in range(1, 101):
  if i % 15 == 0:
  elif i % 3 == 0: 
  elif i % 5 == 0:


  • Remember to check for multiples of 15 first because it means the number is both a multiple of 3 and 5.

  • The modulo operator (%) helps you find out if there's any remainder. It's key for checking multiples.

  • Make sure to print the right word or number based on the check.

FizzBuzz is a fun and straightforward challenge that helps you get better at controlling the flow of your program and using basic math operations. It's perfect for beginners!

5. Palindrome Checker

A palindrome is a word or phrase that reads the same backward as forward. Examples include "racecar", "madam", and even phrases like "nurses run" when you ignore the spaces.

Checking if something is a palindrome is a cool coding task. It involves flipping a sequence around and comparing it to the original. This challenge is a good way to practice handling text (strings), using loops, and making decisions in your code.

Let's dive into making a tool that can tell us if a word is a palindrome!

The Problem

Your job is to write a program that can figure out if a given word is a palindrome. This means it should look the same whether you read it from the start or the end.


Input: racecar
Output: true 

Input: hello 
Output: false


  • First, get the word from the user.

  • Next, create a version of the word that's spelled backward.

  • Then, see if the backward word is the same as the original.

  • If they match, it means the word is a palindrome, so show "true".

  • If they don't match, show "false".


Here's how you can check for palindromes in JavaScript:

function isPalindrome(word) {

  // Make the word backward
  let reversed = word.split("").reverse().join(""); 

  // Check if they are the same
  if (reversed === word) {
    return true;
  return false;


console.log(isPalindrome("racecar")); // true
console.log(isPalindrome("hello")); // false

And in Python:

def is_palindrome(word):
  reversed_word = word[::-1]

  if reversed_word == word:
    return True
  return False

print(is_palindrome("racecar")) # True 
print(is_palindrome("hello")) # False


  • Remember, the key here is to flip the word around and then compare. It's a simple yet effective way to practice coding basics.

  • This task lets you work with strings and understand how to manipulate them, which is a valuable skill in programming.

6. Find the Longest Word

This coding challenge is all about working with words in a sentence. It's a good exercise to get better at handling text.

The Problem

Your task is to write a function that looks at a sentence and figures out which word is the longest. Then, it tells you how many letters that word has.

Example Input

"The quick brown fox jumped over the lazy dog"

Example Output

6 (because "jumped" is the longest word)

Steps to Solve

  • Break the sentence into words

  • Go through each word, keeping track of the longest one you find

  • Share the number of letters in the longest word

Solution in JavaScript

function findLongestWord(sentence) {
  let words = sentence.split(' ');
  let longest = 0;
  for (let word of words) {
    if (word.length > longest) {
      longest = word.length;

  return longest;


  • Remember to think about special cases, like if there are no words or just one

  • You can use a loop or other methods like .reduce() to find the answer

  • This challenge is a good chance to practice basic programming skills and learn how to work with strings

Finding the longest word is a straightforward task that helps you get used to manipulating text and understanding simple algorithms. It's a great stepping stone to more complex challenges.

7. Sudoku Solver

Let's talk about how to make a program that can solve Sudoku puzzles. This is a cool way to get better at problem-solving and understanding how to use algorithms.

The Problem

You have a Sudoku board that's partly filled in. Your goal is to complete the puzzle by filling in the empty spots.

Understanding Sudoku Rules

  • The board is 9x9 and split into 9 smaller 3x3 squares

  • Each row, column, and 3x3 square must have the numbers 1-9, with no repeats

Steps to Solve

  • Start with a Sudoku board that has some numbers already in place

  • Create a function to make sure a number fits in a spot without breaking the rules

  • Use a method called backtracking to fill in numbers. This means you try options until you find the right one

  • Keep going until all spots are filled

Backtracking Algorithm

This method involves trying different numbers in empty spots:

  • Pick an empty spot

  • Put in a number from 1-9 that fits

  • Move to the next spot and repeat

  • If you get stuck, go back and try a different number

Code Example

Here's a simple way to solve Sudoku in Python using backtracking:

def is_valid(board, row, col, num):

  # Check row
  for x in range(9):
    if board[row][x] == num:
      return False

  # Check column
  for x in range(9):
    if board[x][col] == num:
      return False
  # Check 3x3 square
  startRow = row - row % 3
  startCol = col - col % 3
  for r in range(3):
    for c in range(3):
      if board[startRow + r][startCol + c] == num:
        return False

  return True

def solve(board):
  for row in range(9):
    for col in range(9):

      if board[row][col] == 0:

        for num in range(1, 10):
          if is_valid(board, row, col, num):
            board[row][col] = num
            if solve(board):
              return True

            board[row][col] = 0
        return False
  return True


This code tries all the numbers that could fit until the puzzle is solved!


  • Picture the board to make solving easier

  • Use helper functions for rule checking

  • Keep your code clean and easy to read

  • Be ready for puzzles that can't be solved or have weird inputs

Solving Sudoku is a great way to work on your coding skills, especially with logic and algorithms!

8. Binary Search Trees

Binary search trees are a cool way to sort and find stuff quickly. Let's dive into some coding challenges that will help you get the hang of using binary search trees!

The Problem

Your mission is to create functions that let you add, look for, and go through binary search trees. These tasks will help you understand how these trees work.

Key Things to Know

  • Each spot in the tree holds a value, and these spots are linked from top to bottom

  • The numbers on the left side are always smaller than their parent

  • The numbers on the right are always bigger

  • Searching is super fast, taking less time as the tree grows

Fun Challenges

1. Adding Values

  • Make a function that adds new numbers to the tree, keeping everything in order

  • Think about what to do if you add the same number twice or if the tree is empty

2. Looking for Values

  • Write a function to check if a certain number is in the tree

  • It should say 'true' if the number is there, and 'false' if not

  • Try to make the search as quick as possible

3. Walking Through the Tree

  • Show the numbers in the tree using different methods like pre-order, in-order, and post-order

  • Get to know the differences between these methods

4. How Tall is the Tree?

  • Figure out the tree's height (the longest path from top to bottom)

  • Find out the deepest part of the tree

5. Is the Tree Balanced?

  • See if the tree is balanced, meaning the heights of the left and right sides aren't too different

  • Say 'true' if it's balanced and 'false' if not

Tips for Solving

  • Picture the tree in your mind to see how the numbers link up

  • Break down the problems into smaller parts

  • Try your solutions with different numbers to see what happens

  • Learn the usual ways to go through a tree

Working with binary trees is a great way to boost your coding skills. These challenges are a fun way to learn about an important part of coding!

9. Efficient Prime Number Functions

Prime numbers are special numbers that can only be divided evenly by 1 and themselves. Some examples are 2, 3, 5, 7, 11, and so on. Knowing how to work with prime numbers is really useful, especially in fields like computer security and coding.

Here are some cool coding challenges to help you practice working with prime numbers in a smart way:

Basic Prime Checker

  • Write a function that checks if a number is prime. It should say 'true' if the number is prime and 'false' if it's not.

  • Make it faster by not checking every even number after 2.

Prime Number Generator

  • Create a function that gives you prime numbers one at a time, each time you ask for one.

  • Try to see how many primes you can get before it starts taking too long!

Sieve of Eratosthenes

  • Use the Sieve of Eratosthenes method to quickly find prime numbers. This method filters out non-prime numbers from a list, leaving only the primes.

  • It's a neat way to find a lot of primes fast.

Largest Prime Factor Finder

  • Make a function that finds the biggest prime factor of a number. This means breaking the number into smaller parts until you find the biggest prime number among them.

Next Prime Number Finder

  • Create a function that finds the next prime number that's bigger than a number you give it. This is handy for things like creating secure keys.


  • Remember to think about unusual cases, like when the number is negative or is 0 or 1.

  • Use division and factor checking to see if a number is prime.

  • Try using memoization, which is a way to remember previous results, to make your code run faster.

  • Test how fast your functions are to find the quickest method!

Playing around with prime numbers is a great way to get better at coding. These challenges help you think about how to solve problems efficiently.

10. Writing a Program to Play a Perfect Game of Tic-Tac-Toe

Tic-tac-toe is a simple game we all know. The idea of making a computer program that can play tic-tac-toe without ever losing is an interesting challenge!

The Problem

Your task is to create a program that always plays tic-tac-toe to at least a draw. The program needs to be smart enough to make its moves, see where the human player has gone, and decide the best move to make next.

Understanding the Rules

  • The game is played on a 3x3 grid.

  • Players take turns putting their mark (X or O) in an empty space.

  • The first player to line up three of their marks in a row, column, or diagonal wins.

Steps to Solve

  • Create a 3x3 grid to represent the game board.

  • Notice when the human player makes a move.

  • Program how the computer decides its move:

  • Try to win on the next move.

  • If it can't win, block the other player from winning.

  • Otherwise, choose the best available spot.

  • Keep an eye on the board to help make decisions.

  • Figure out when someone wins or if it's a tie.

Code Example

Here's a basic Python example for a tic-tac-toe game:

# This is a simple version of the board and checking wins

def check_win(board):

  # Look at possible winning lines
  for combo in [[0,1,2], [3,4,5], [6,7,8], # Rows
                [0,3,6], [1,4,7], [2,5,8], # Columns
                [0,4,8], [2,4,6]]: # Diagonals

    if board[combo[0]] == board[combo[1]] == board[combo[2]] != " ":
      return board[combo[0]]
  return None

def get_best_move(board, player):
  # Check if the computer can win
  for move in range(9):
    temp = board[:]
    if temp[move] == " ":
      temp[move] = "X"
      if check_win(temp) == "X":
        return move
  # Stop the other player from winning
  for move in range(9):
     temp = board[:]
     if temp[move] == " ":
       temp[move] = "O"
       if check_win(temp) == "O":
         return move

  # Choose the best spot left
  return optimal_move(board)

# More code would go here...

This code shows the basics of making decisions and playing smartly. With the right steps, the computer can always play well!


  • Think about all the possible ways the game can go.

  • Break the problem down into smaller parts to make it easier.

  • Try playing against your program to see how well it does.

Making a computer play tic-tac-toe perfectly is a great way to practice coding. It's fun and challenging, so why not give it a shot?

11. Topological Sort Implementation

Topological sort is a way to organize the steps or tasks in a project when some steps depend on others. Imagine you're trying to make breakfast. You can't eat your toast until you've toasted your bread, and you can't toast your bread until you've got the bread out of the pantry. Topological sort helps you list out these steps in the right order.

The Problem

You have a list of tasks and the order they need to be done in. Your job is to arrange these tasks so that each task is done before the ones that depend on it.

Understanding Topological Sort

  • It's like making a to-do list for a project.

  • Important points:

  • You have tasks (nodes) and dependencies (edges).

  • Start with tasks that don't depend on anything else.

  • Keep going until all tasks are on your list.

  • You'll end up with a list that makes sure you do everything in the right order.


  • Use a list to show what tasks depend on each other.

  • Make an empty list for your final order of tasks.

  • Create a helper function to visit each task:

  • Mark it as in process.

  • Visit all the tasks that need to be done before this one.

  • Add this task to your final list.

  • Mark it as done.

  • Start with tasks that don't have any prerequisites.

Code Example

Here's a simple way to do it in Python:

def topological_sort(graph):
  result = []
  visited = set()
  def visit(node):
    if node in visited:
    for child in graph[node]:

  for node in graph:
    if node not in visited:

  return result[::-1]

print(topological_sort({'A': ['B','C'], 'B': ['D'], 'C': ['D'], 'D': []})) 

# This will print ['D', 'B', 'C', 'A']

This code goes through each task, making sure all its prerequisites are done first, before adding it to the final list. It's a neat way to organize tasks to make sure everything gets done in the right order.

12. Randomize Line Sequence in a File

Let's dive into a coding task that's all about mixing up the lines in a text file. This can be handy when you need to shuffle data around for tests or just want to change the order of things for fun.

The Problem

Imagine you have a text file filled with lines of text. Your challenge is to write a program that scrambles these lines into a random order.

Example File

First line
Second line
Third line
Fourth line
Fifth line


  • Open the file to get all the lines inside it

  • Put these lines into a list

  • Mix up the list so the order of the lines is random

  • Save these mixed-up lines into a new file

Code Solution

Here's how you can do this in Python:

import random

with open('input.txt') as f:
  lines = f.readlines()


with open('output.txt', 'w') as f:

And if you're using JavaScript:

const fs = require('fs');

let lines = fs.readFileSync('input.txt').toString().split('');

lines.sort(() => Math.random() - 0.5);

fs.writeFileSync('output.txt', lines.join(''));


  • Make sure to check for any errors when opening or saving files

  • It's important to truly shuffle the lines for a random result

  • Try this with files of various sizes to see how it works

Shuffling the order of lines in a file is a simple yet effective way to work with data differently. It's a great exercise for practicing basic coding skills.

Intermediate Challenges

Here are some coding challenges that are a bit more advanced. These will make you think harder and help you become better at solving problems. If you're ready to step up from the basics, these are for you.

1. Array Rotation

This challenge is about moving numbers around in a list. It's useful for rearranging data.

The Problem

You have a list of numbers. You need to move the numbers to the right by a certain amount. The user will tell you how many times.


Input list: [1, 2, 3, 4, 5]  
Shifts: 2

Output list: [4, 5, 1, 2, 3]

Steps to Solve

  • Get the list and the number of shifts.

  • Copy the original list.

  • Use a loop to move values from the start to the end, as many times as needed.

  • Return the new list.


In JavaScript:

function rotateArray(arr, shifts) {

  let rotated = [...arr];
  for (let i = 0; i < shifts; i++) {

  return rotated;


console.log(rotateArray([1, 2, 3, 4, 5], 2)); // [4, 5, 1, 2, 3]

In Python:

def rotate_array(arr, shifts):
  rotated = arr[:]
  for _ in range(shifts):

  return rotated

print(rotate_array([1,2,3,4,5], 2)) # [4, 5, 1, 2, 3]  

2. Two Sum Problem

The Two Sum problem is a classic. It's great for working on your problem-solving skills.

The Problem

You have a list of numbers and a target sum. Find two numbers that add up to the target and return their positions.


array: [2, 5, 7, 9]
target: 11  

output: [0, 2] 

# Because array[0] + array[2] equals 11

Steps to Solve

  • Go through the list.

  • For each number, figure out what you need to add to it to get the target.

  • See if that number is also in the list.

  • If yes, return their positions.

Code Examples


function twoSum(arr, target) {

  for (let i = 0; i < arr.length; i++) {
    let diff = target - arr[i];
    if (arr.includes(diff) && arr.indexOf(diff) != i) {
      return [i, arr.indexOf(diff)];


let result = twoSum([2, 5, 7, 9], 11); 
console.log(result); // [0, 2]


def two_sum(arr, target):

  for i in range(len(arr)):
    diff = target - arr[i] 
    if diff in arr and arr.index(diff) != i:
      return [i, arr.index(diff)]

print(two_sum([2,5,7,9], 11)) # [0, 2]

3. Integer to Roman Numeral Converter

Changing numbers into Roman numerals is a fun string challenge.

The Problem

Turn a whole number into a Roman numeral.


5 -> V
39 -> XXXIX
1999 -> MCMXCIX

Understanding Roman Numerals

  • I = 1

  • V = 5

  • X = 10

  • L = 50

  • C = 100

  • D = 500

  • M = 1000

Steps to Solve

  • Split the number into thousands, hundreds, tens, and ones.

  • Change each part into Roman symbols.

  • Follow subtraction rules (like 4 is IV, not IIII).


In Python:

def int_to_roman(num):
  values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]  
  numerals = ["M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"]
  roman = ''
  i = 0
  while num > 0:
    if values[i] <= num:
      num -= values[i]  
      roman += numerals[i]
      i += 1

  return roman

print(int_to_roman(5)) # V 
print(int_to_roman(39)) # XXXIX

4. Validating Email Addresses

Checking if an email address is valid is a useful skill.

The Problem

Make sure an email address follows these rules:

  • Has one @ symbol

  • The part before @ doesn't start or end with . or -

  • The part after @ ends in .com, .net, or .org

If it does, say 'Valid'. If not, say 'Invalid'.


"" -> "Valid"
"test@example.c" -> "Invalid"
"" -> "Invalid"


  • Split the email by @.

  • Check the first part for . or - at the start or end.

  • Make sure the second part ends in .com, .net, or .org.

  • If all good, return "Valid".


In JavaScript:

function validateEmail(email) {

  let parts = email.split("@");

  if (parts[0].startsWith(".") || 
      parts[0].startsWith("-") ||
      parts[0].length < 1) {
    return "Invalid"; 

  let domain = parts[1];
  if (domain.length < 3 ||
      !domain.endsWith(".com") && 
      !domain.endsWith(".net") &&
      !domain.endsWith(".org")) {
    return "Invalid";

  return "Valid";


let result1 = validateEmail(""); // Valid
let result2 = validateEmail("test@example.c"); // Invalid

5. Pyramid Pattern Printing

Printing pyramid patterns is a fun way to practice loops.

The Problem

Create a half pyramid of stars based on the number of rows.


Rows: 5  



  • Get the number of rows.

  • Use loops to add stars for each row.

  • Print each row.


In Python:

N = int(input("Enter number of rows: "))

for i in range(1, N+1):
  row = ""
  for j in range(1, i+1):   
    row += "* "

In JavaScript:

let N = parseInt(prompt("Enter number of rows: "));

let row = "";

for (let i = 1; i <= N; i++) {

  row = "";
  for (let j = 1; j <= i; j++) {
    row += "* ";


6. Find Missing Number in Array

Finding a missing number in a list is a good brain teaser.

The Problem

You have an unsorted list from 1 to 100, but one number is missing. Find it.


Input: [2, 5, 1, 4, 9, 6, 3, 7, 10, 8]
Missing number: 11

Steps to Solve

  • Sort the list.

  • Go through it and look for a gap in the sequence.

  • If you find a gap, the missing number is the one that should be there.


In JavaScript:

function missingNum(arr) {

  arr.sort((a, b) => a - b);

  for (let i = 0; i < arr.length; i++) {
    if (arr[i+1] - arr[i] != 1) {
      return arr[i] + 1; 



let result = missingNum([2, 5, 1, 4, 9, 6, 3, 7, 10, 8]);
console.log(result); // 11

In Python:

def missing_num(arr):

  for i in range(len(arr)-1):

    if arr[i+1] - arr[i] != 1:
      return arr[i] + 1

print(missing_num([2, 5, 1, 4, 9, 6, 3, 7, 10, 8])) # 11

Sorting the list helps you see where the sequence breaks.

I hope these challenges give you a fun way to practice your coding. Try them out and see how you do.


Advanced Challenges

Here are some harder coding problems for those looking to push their skills further:

Balanced Binary Tree Checker

  • We need to write a function that checks if a binary tree is balanced.

  • A tree is balanced if the heights of the left and right sides don't differ by more than one for all nodes.

In-Order Successor in a Binary Search Tree

  • Your job is to write a function that finds the next node in order for a given node in a binary search tree.

  • Think of it as finding the next number in line that comes after the given one.

Lowest Common Ancestor in a Binary Tree

  • Find the lowest common ancestor of two nodes in a binary tree.

  • This is the furthest back node where both nodes are still part of its "family".

Alien Dictionary Ordering

  • Imagine you have a dictionary from an alien language, but the words are sorted like in English.

  • Your task is to figure out the order of letters in the alien language and write it down as a string.

Regular Expression Matcher

  • Write a function that checks if a string matches a given pattern.

  • The pattern can include '.' and '*' which are special symbols with their own rules.

Serialize and Deserialize Binary Trees

  • You need to create functions that can turn a binary tree into a string and then turn that string back into a tree.

  • This process is about converting the tree into a format that can be saved or shared.

Tackling these advanced challenges is a fantastic way to get better at coding. Break them into smaller parts and test your work. Remember, practice makes perfect, so keep at it!

Expert-Level Enigmas

These advanced coding challenges are tough but exciting. They'll really make you think and push your coding abilities to the limit. Let's dive into some puzzles that involve tricky algorithms and creative thinking.

Finding the Kth Largest Element

Imagine you have a list of numbers that's all mixed up, and you need to find the kth biggest number in it.

Here are some ways to tackle this:

  • You could sort the list and then pick the kth number from the end.

  • Use a special list called a min-heap that keeps track of the biggest numbers you've seen so far.

  • Try the Quickselect method, which is a bit like sorting but you only focus on one part of the list.

Try this on big lists of numbers and think about how fast your solution is and how much space it uses.

Shortest Remaining Time First Scheduling

This is about making a plan for tasks that need computer time. You get information like when each task arrives and how long it needs.

Your job is to:

  • Keep tasks in order based on how much time they need to finish.

  • Pick the task with the least time left when the computer is free.

  • If a more important task comes in, switch to it.

Try to make the wait time and the total time tasks take as short as possible.

Solving a Maze with Backtracking

Create a program that can find its way out of a maze using a method called backtracking. Think of the maze as a big grid with walls and open paths.

The key ideas are:

  • Mark places you've been to avoid going in circles.

  • Have a clear stopping point for the program.

  • Remember paths you've tried so you don't repeat them.

You can also try to show the path, make the maze harder or easier, or find faster ways to solve it.

Compressing Files with Huffman Coding

This is about making files smaller using a method called Huffman coding. It looks at how often characters appear and creates a special tree to represent them in a shorter way.

Here's how:

  • Count how often each character appears.

  • Merge the least common characters using a priority queue.

  • Walk through the tree to assign short codes to each character.

  • Use these codes to write a smaller version of the file.

Think about how you could use this for different types of files, not just text.

Simulating a Distributed Key-Value Store

Try building a system that stores data across many computers. It should handle dividing data, copying it for safety, and keeping everything up to date.


  • How to split data and move it around when needed.

  • Choosing leaders and agreeing on data values.

  • Finding and fixing failures.

  • Speeding things up with caching and fixing mistakes.

  • Adjusting how strict you are with making sure data is the same everywhere.

This challenge covers a lot of ideas about how computers work together, like CAP theorem and gossip protocols.

These tough challenges are great for learning. Break them into smaller parts, test everything carefully, and keep trying. Solving these will help you get really good at solving complex problems and designing systems.

Technology-Specific Challenges

In this part, we're going to talk about coding exercises that focus on certain areas of technology. These tasks are all about practicing and getting better at specific tech skills like making websites, working with data, or managing servers.

Web Development


  • Try making a webpage that looks good on any device using Flexbox or CSS Grid

  • Build a sign-up form that checks the info right on the page

  • Create a photo gallery where you can smoothly scroll through images


  • Make a basic calculator with buttons you can click

  • Set up a timer that counts down to a specific event

  • Develop an app that shows the weather for your location


  • Build a task list app where you can add, edit, and delete items

  • Create a quiz game that gets questions from an online source

  • Make a messaging app where you can chat in real time


  • Set up a simple web server that says "Hello World"

  • Make an API that can handle creating, reading, updating, and deleting data

  • Develop an app that stores form submissions in a database

Data Science & Analysis


  • Use charts to show data with Matplotlib

  • Try to guess house prices with machine learning

  • Use a neural network to tell if a picture is of a cat or a dog


  • Analyze survey data with graphs and dashboards

  • Predict future sales from past data

  • Understand what customers feel by analyzing text


  • Use queries to sort, summarize, and organize data

  • Make views and stored procedures to make tasks easier

  • Find and fix slow database queries



  • Use Bash scripts to check on disk space and memory

  • Manage users, groups, and permissions

  • Set up a web server with Linux, Nginx, MySQL, and PHP


  • Put an app into a container and run it on your computer

  • Upload your custom app images to Docker Hub

  • Start a complex app with many parts using Docker Compose


  • Run containers on a bunch of machines

  • Manage settings, secrets, and storage

  • Keep an eye on your apps and servers

Starting with simple tasks and gradually taking on more challenging ones is a good way to learn. The main thing is to keep practicing.


Working on coding problems is a great way to get better at solving tricky questions, learn about different ways to solve problems, and even get ready for job interviews. Starting with simple puzzles and then trying harder ones can help you feel more confident and understand programming better.

Here are some important points:

  • Try solving different coding problems often to keep your skills sharp. Try a mix of easy and hard problems.

  • Break big problems into smaller pieces. Go through examples step by step.

  • Practice more on websites that offer coding challenges. Many of these sites have discussion boards where you can learn from others.

  • Focus on getting really good at basic stuff like loops, how to use lists, and learning common problem-solving steps. These basics are super important.

  • If you find some problems tough, don't give up. Keep trying and learn from what went wrong.

  • After you solve a problem, look at other solutions. See how they compare to yours.

  • Use what you learn in coding challenges on your own projects. This is a good way to make sure you really understand it.

  • Make a regular schedule for practicing coding. Sticking to it is key.

Getting really good at coding problems takes time and a lot of practice. Be patient with yourself, think hard about both what went well and what didn't, and keep going. Happy coding!

What is the hardest code to learn?

Malbolge is known for being super hard to learn because it's made to be confusing on purpose. It uses a unique kind of notation and its rules are really complex. Getting good at Malbolge takes a lot of patience and hard work.

What is the most complex code ever written?

The systems used by the Social Security Administration to figure out retirement benefits and track earnings over a lifetime are super complex. They're written in Cobol and have more than 60 million lines of code that have been added over many years. Updating or fixing these systems is a big challenge because of how complicated they are.

What are some of the difficulties with codes?

When learning or teaching coding, some common challenges include:

  • Keeping students interested and motivated

  • Teaching both the coding language and how to solve problems

  • Helping students deal with failure and frustration

  • Balancing how much time is spent staring at screens

Good coding education helps students learn the technical stuff while also applying it to real life and building other important skills.

What are the best code challenge sites?

Here are some great websites for coding challenges:

  • HackerRank - Offers challenges of different levels and some sponsored by companies

  • LeetCode - Great for preparing for technical job interviews with a community to discuss solutions

  • Codewars - A fun, game-like site that's good for beginners to learn various programming languages

  • HackerEarth - Hosts competitions and challenges for hiring

  • Codility - Used by companies to test candidates with coding tasks

The best website for you depends on what you're looking to achieve, your skill level, and what kind of programming you're interested in.

Related posts

Why not level up your reading with

Stay up-to-date with the latest developer news every time you open a new tab.

Read more