Continue with Google
Share on media
There is a moment every beginner knows well. You open a coding platform, stare at the screen, and feel completely paralyzed because nobody told you where to begin, what to practice, or how to know if you are making real progress.
This blog hands you 50 carefully selected best coding challenges for beginners with their solutions and organized by category. Whether you are learning Python, Java, C++, or JavaScript, the logic behind each problem is universal. The code is the vehicle; the thinking is the destination. These challenges are also designed to align with current software development trends, where problem-solving and logical thinking matter more than ever.
30 Coding Challenges for Beginners with Solutions
Category: String Problems (Challenges 1–7)
Strings are among the first data types that any programmer encounters, and the problems built around them cover a surprisingly wide range of logical thinking.
Challenge 1: Reverse a String
Problem: Write a function that takes a string as input and returns it reversed.
Solution:
def reverse_string(s):
return s[::-1]
print(reverse_string(“hello”)) # Output: “olleh”
Challenge 2: Check if a String is a Palindrome
Problem: Determine whether a given string reads the same forwards and backwards.
Solution:
def is_palindrome(s):
s = s.lower().replace(” “, “”)
return s == s[::-1]
print(is_palindrome(“racecar”)) # Output: True
print(is_palindrome(“hello”)) # Output: False
Challenge 3: Count Vowels in a String
Problem: Given a string, return the total count of vowels (a, e, i, o, u).
Solution:
def count_vowels(s):
count = 0
for char in s.lower():
if char in “aeiou”:
count += 1
return count
print(count_vowels(“Programming”)) # Output: 3
Challenge 4: Check if Two Strings are Anagrams
Problem: Two strings are anagrams if they contain exactly the same characters in any order. Return True or False.
Solution:
def are_anagrams(s1, s2):
return sorted(s1.lower()) == sorted(s2.lower())
print(are_anagrams(“listen”, “silent”)) # Output: True
print(are_anagrams(“hello”, “world”)) # Output: False
Challenge 5: Find the Frequency of Each Character
Problem: Given a string, return a dictionary showing how many times each character appears.
Solution:
def char_frequency(s):
freq = {}
for char in s:
freq[char] = freq.get(char, 0) + 1
return freq
print(char_frequency(“banana”))
# Output: {‘b’: 1, ‘a’: 3, ‘n’: 2}
Challenge 6: Find the Longest Word in a Sentence
Problem: Given a sentence, return the word that contains the most characters.
Solution:
def longest_word(sentence):
words = sentence.split()
longest = “”
for word in words:
if len(word) > len(longest):
longest = word
return longest
print(longest_word(“I love programming every day”))
# Output: “programming”
Challenge 7: Count the Number of Words in a String
Problem: Without using a built-in word-count method, determine how many words are in a given sentence.
Solution:
def count_words(sentence):
words = sentence.strip().split()
return len(words)
print(count_words(” Hello world “)) # Output: 2
Category: Array Problems (Challenges 8–15)
Arrays are the backbone of data structures. These problems build your ability to manipulate, search, and transform collections of data efficiently.
Challenge 8: Find the Maximum and Minimum Element
Problem: Given an unsorted array of integers, return both the largest and smallest values.
Solution:
def find_max_min(arr):
return max(arr), min(arr)
print(find_max_min([3, 1, 7, 2, 9, 4]))
# Output: (9, 1)
Challenge 9: Reverse an Array In Place
Problem: Reverse the elements of an array without creating a new one.
Solution:
def reverse_array(arr):
left, right = 0, len(arr) – 1
while left < right:
arr[left], arr[right] = arr[right], arr[left]
left += 1
right -= 1
return arr
print(reverse_array([1, 2, 3, 4, 5]))
# Output: [5, 4, 3, 2, 1]
Challenge 10: Find the Second Largest Element
Problem: Return the second highest value in an array without sorting it.
Solution:
def second_largest(arr):
first = second = float(‘-inf’)
for num in arr:
if num > first:
second = first
first = num
elif num > second and num != first:
second = num
return second
print(second_largest([10, 5, 8, 20, 3]))
# Output: 10
Challenge 11: Remove Duplicates from a Sorted Array
Problem: Given a sorted array, remove all repeated elements and return the unique elements.
Solution:
def remove_duplicates(arr):
if not arr:
return []
result = [arr[0]]
for i in range(1, len(arr)):
if arr[i] != arr[i – 1]:
result.append(arr[i])
return result
print(remove_duplicates([1, 1, 2, 3, 3, 4, 5, 5]))
# Output: [1, 2, 3, 4, 5]
Challenge 12: Rotate an Array by K Positions
Problem: Shift all elements of an array to the right by K steps.
Solution:
def rotate_array(arr, k):
k = k % len(arr)
return arr[-k:] + arr[:-k]
print(rotate_array([1, 2, 3, 4, 5], 2))
# Output: [4, 5, 1, 2, 3]
Challenge 13: Find All Pairs That Sum to a Target
Problem: Return all pairs of elements in an array whose sum equals a given target value.
Solution:
def find_pairs(arr, target):
pairs = []
seen = set()
for num in arr:
complement = target – num
if complement in seen:
pairs.append((complement, num))
seen.add(num)
return pairs
print(find_pairs([1, 5, 3, 7, 2, 8], 10))
# Output: [(3, 7), (2, 8)]
Challenge 14: Move All Zeroes to the End
Problem: Rearrange elements so all zeroes appear at the end while maintaining the relative order of non-zero elements.
Solution:
def move_zeroes(arr):
position = 0
for num in arr:
if num != 0:
arr[position] = num
position += 1
while position < len(arr):
arr[position] = 0
position += 1
return arr
print(move_zeroes([0, 1, 0, 3, 12]))
# Output: [1, 3, 12, 0, 0]
Challenge 15: Merge Two Sorted Arrays
Problem: Combine two already-sorted arrays into a single sorted array.
Solution:
def merge_sorted(a, b):
result = []
i = j = 0
while i < len(a) and j < len(b):
if a[i] <= b[j]:
result.append(a[i])
i += 1
else:
result.append(b[j])
j += 1
result.extend(a[i:])
result.extend(b[j:])
return result
print(merge_sorted([1, 3, 5], [2, 4, 6]))
# Output: [1, 2, 3, 4, 5, 6]
Challenge 16: Find the Sum of All Elements
Problem: Given an array of integers, return the total sum of all elements.
Solution:
def array_sum(arr):
total = 0
for num in arr:
total += num
return total
print(array_sum([1, 2, 3, 4, 5])) # Output: 15
Category: Math and Number Problems (Challenges 17–21)
Number problems sharpen your logical reasoning and introduce several fundamental algorithms that appear repeatedly across computer science regardless of which programming language you choose to practice with
Challenge 17: Check if a Number is Prime
Problem: Determine whether a given number has exactly two divisors: 1 and itself.
Solution:
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
print(is_prime(17)) # Output: True
print(is_prime(18)) # Output: False
Challenge 18: Generate the Fibonacci Sequence
Problem: Print the Fibonacci series up to N terms, where each number is the sum of the two preceding ones.
Solution:
def fibonacci(n):
a, b = 0, 1
sequence = []
for _ in range(n):
sequence.append(a)
a, b = b, a + b
return sequence
print(fibonacci(8))
# Output: [0, 1, 1, 2, 3, 5, 8, 13]
Challenge 19: Find the Factorial of a Number
Problem: Calculate the factorial of a given non-negative integer.
Solution:
def factorial(n):
result = 1
for i in range(2, n + 1):
result *= i
return result
print(factorial(5)) # Output: 120
Challenge 20: Reverse the Digits of a Number
Problem: Without converting to a string, reverse the digits of an integer mathematically.
Solution:
def reverse_number(n):
reversed_num = 0
is_negative = n < 0
n = abs(n)
while n > 0:
digit = n % 10
reversed_num = reversed_num * 10 + digit
n //= 10
return -reversed_num if is_negative else reversed_num
print(reverse_number(12345)) # Output: 54321
print(reverse_number(-678)) # Output: -876
Challenge 21: Find the Sum of Digits
Problem: Given an integer, return the sum of all its individual digits.
Solution:
def sum_of_digits(n):
n = abs(n)
total = 0
while n > 0:
total += n % 10
n //= 10
return total
print(sum_of_digits(1234)) # Output: 10
Category: Recursion Problems (Challenges 22–26)
Recursion is where beginner programmers often hit their first major wall. Alongside practice, tuning into the best coding podcasts can help you hear how experienced developers think through problems like these.
Challenge 22: Calculate Power Using Recursion
Problem: Compute base raised to the power of exponent recursively.
Solution:
def power(base, exp):
if exp == 0:
return 1
return base * power(base, exp – 1)
print(power(2, 10)) # Output: 1024
Challenge 23: Sum an Array Using Recursion
Problem: Find the sum of all elements in an array using recursion, without any loops.
Solution:
def recursive_sum(arr):
if not arr:
return 0
return arr[0] + recursive_sum(arr[1:])
print(recursive_sum([1, 2, 3, 4, 5])) # Output: 15
Challenge 24: Reverse a String Using Recursion
Problem: Reverse a string by recursively solving a smaller version of the same problem.
Solution:
def reverse_recursive(s):
if len(s) <= 1:
return s
return reverse_recursive(s[1:]) + s[0]
print(reverse_recursive(“hello”)) # Output: “olleh”
Challenge 25: Find the nth Fibonacci Number Using Recursion
Problem: Return the nth number in the Fibonacci sequence using recursion.
Solution:
def fib_recursive(n):
if n <= 1:
return n
return fib_recursive(n – 1) + fib_recursive(n – 2)
print(fib_recursive(7)) # Output: 13
Challenge 26 Count Occurrences of a Digit Using Recursion
Problem: Determine how many times a specific digit appears in a number without converting to a string.
Solution:
def count_digit(n, d):
if n == 0:
return 1 if d == 0 else 0
if n < 0:
n = -n
count = 0
while n > 0:
if n % 10 == d:
count += 1
n //= 10
return count
print(count_digit(122333, 3)) # Output: 3
Category: Hashing and Stacks (Challenges 27–30)
These problems introduce you to two of the most powerful tools in a programmer’s toolkit; hash maps for fast lookups and stacks for managing ordered operations. Hash maps mirror the fast-lookup logic that powers real-world databases, including how SQL server administration manages user permissions and access internally.
Challenge 27: Check for Balanced Parentheses
Problem: Use a stack to determine whether every opening bracket in a string has a correctly matched closing bracket.
Solution:
def is_balanced(s):
stack = []
mapping = {‘)’: ‘(‘, ‘}’: ‘{‘, ‘]’: ‘[‘}
for char in s:
if char in mapping.values():
stack.append(char)
elif char in mapping:
if not stack or stack[-1] != mapping[char]:
return False
stack.pop()
return len(stack) == 0
print(is_balanced(“({[]})”)) # Output: True
print(is_balanced(“({[})”)) # Output: False
Challenge 28: Implement a Queue Using Two Stacks
Problem: Simulate first-in, first-out (queue) behavior using only stack operations.
Solution:
class QueueUsingStacks:
def __init__(self):
self.stack1 = []
self.stack2 = []
def enqueue(self, item):
self.stack1.append(item)
def dequeue(self):
if not self.stack2:
while self.stack1:
self.stack2.append(self.stack1.pop())
return self.stack2.pop() if self.stack2 else None
q = QueueUsingStacks()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
print(q.dequeue()) # Output: 1
print(q.dequeue()) # Output: 2
Challenge 29: Find the First Non-Repeating Character
Problem: Traverse a string and return the first character that appears exactly once.
Solution:
def first_non_repeating(s):
freq = {}
for char in s:
freq[char] = freq.get(char, 0) + 1
for char in s:
if freq[char] == 1:
return char
return None
print(first_non_repeating(“aabbcde”)) # Output: “c”
print(first_non_repeating(“aabb”)) # Output: None
Challenge 30: Find Two Numbers That Add Up to a Target Using Hashing
Problem: Given an array and a target, return the indices of the two numbers that add up to the target.
Solution:
def two_sum(arr, target):
seen = {}
for i, num in enumerate(arr):
complement = target – num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return []
print(two_sum([2, 7, 11, 15], 9)) # Output: [0, 1]
print(two_sum([3, 2, 4], 6)) # Output: [1, 2]
Category: Sorting, Ciphers, and Number Theory
Challenge 31: Bubble Sort an Array
Problem: Sort an array of integers in ascending order using the bubble sort algorithm.
Solution:
def bubble_sort(arr):
n = len(arr)
for i in range(n – 1):
for j in range(0, n – i – 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr
print(bubble_sort([64, 34, 25, 12, 22, 11, 90]))
# Output: [11, 12, 22, 25, 34, 64, 90]
Challenge 32: Implement the Caesar Cipher
Problem: Encrypt a string by shifting each letter forward in the alphabet by a given number of positions. Non-letter characters remain unchanged.
Solution:
def caesar_cipher(text, shift):
result = “”
for char in text:
if char.isalpha():
base = ord(‘A’) if char.isupper() else ord(‘a’)
result += chr((ord(char) – base + shift) % 26 + base)
else:
result += char
return result
print(caesar_cipher(“Hello, World!”, 3))
# Output: “Khoor, Zruog!”
Challenge 33: Convert Celsius to Fahrenheit (and Back)
Problem: Write two functions; one that converts Celsius to Fahrenheit, and another that reverses the conversion.
Solution:
def celsius_to_fahrenheit(c):
return (c * 9/5) + 32
def fahrenheit_to_celsius(f):
return (f – 32) * 5/9
print(celsius_to_fahrenheit(100)) # Output: 212.0
print(fahrenheit_to_celsius(212)) # Output: 100.0
Challenge 34: Convert a Number from Decimal to Binary
Problem: Without using Python’s built-in bin() function, convert a positive decimal integer to its binary representation as a string.
Solution:
def decimal_to_binary(n):
if n == 0:
return “0”
binary = “”
while n > 0:
binary = str(n % 2) + binary
n //= 2
return binary
print(decimal_to_binary(13)) # Output: “1101”
print(decimal_to_binary(0)) # Output: “0”
Challenge 35: Find the GCD of Two Numbers
Problem: Calculate the Greatest Common Divisor (GCD) of two integers using the Euclidean algorithm.
Solution:
def gcd(a, b):
while b:
a, b = b, a % b
return a
print(gcd(48, 18)) # Output: 6
print(gcd(100, 75)) # Output: 25
If you’re working with real data at scale, understanding how to fix slow MySQL queries becomes the natural next step because the same hashing principles that make this solution fast are what database indexing relies on.
Conclusion
Every challenge in this list exists for a reason. These 30 best coding challenges for beginners are not just exercises; they are the building blocks of real problem-solving skills. Strings, arrays, recursion, hashing; each category pushes your thinking one step further. Stay consistent, revisit the problems you found difficult, and trust the process. The progress will show up before you expect it.
Do not rush through these questions. Understand each solution, then try writing it again from memory. That gap between reading and doing is exactly where real learning happens.
If solving these problems has sparked an interest in writing about code, we welcome contributors. Check out our web development write for us page and share your expertise with our readers.
%201.png)
%201.png)
%201.png)
