Home Get Hired IBM Previous Year Coding Questions & Solutions for Freshers 2025

Table of content:

Key Features of IBM Coding Assessments
Commonly Asked Topics
Top 5 Sample Questions & Solutions for IBM Coding Questions
Conclusion
Frequently Asked Questions (FAQs)

IBM Previous Year Coding Questions & Solutions for Freshers 2025

Boost your preparation with IBM's previous year's coding questions. Gain insights into the exam format, topics, and tips to excel in your coding assessment. Read on for details.

7 mins read

IBM Previous Year Coding Questions & Solutions for Freshers 2025

IBM’s coding assessment is a crucial step in its hiring process, aimed at evaluating candidates' technical skills, problem-solving abilities, and algorithmic thinking. For freshers aspiring to secure a role at IBM, reviewing the previous year's coding questions can be a game-changer.

It not only familiarises you with the exam pattern but also boosts your confidence. This article serves as a complete guide to help you excel in the IBM coding test.

Key Features of IBM Coding Assessments

Category	Details
Exam Mode	Online proctored or in-person (as per hiring needs).
Sections	Logical Reasoning, MCQs on Programming, Hands-on Coding.
Coding Platforms	The in-built platform provided by IBM during the test.
Languages Supported	Java, Python, C++, and C.
Time Allotted	Approximately 60-120 minutes.
Assessment Scope	Testing analytical and logical reasoning, algorithm efficiency, and syntax.

Why Focus on Previous Year Questions?

Understand Exam Trends
Familiarise yourself with the frequently tested concepts and their complexity.
Skill Benchmarking
Assess your problem-solving pace and accuracy against IBM standards.
Confidence Building
Reduce anxiety by practising realistic questions under timed conditions.

Commonly Asked Topics

Array Operations

Reversal, rotation, and sorting techniques.
Searching and modifying elements efficiently.

Strings

Palindrome verification, string matching, and manipulation.
Applications of regular expressions in coding.

Algorithms

Sorting (quick, merge) and searching (binary, linear).
Algorithm optimisation and complexity analysis.

Data Structures

Mastery of stacks, queues, linked lists, and binary trees.

Dynamic Programming

Solving problems with optimal substructure properties.

Are you looking for IBM coding questions related to previous years? Click here to access coding practice sessions from moderate to challenging levels.

Top 5 Questions with Solutions for IBM Coding

Problem Statement 1

Given two strings, word1 and word2, return the minimum number of operations required to convert word1 to word2. You have the following three operations permitted on a word:

Insert a character

Delete a character

Replace a character

Input Format

Two Strings will be passed in the form of alphabets as word1 and word2.

Output Format

An integer value will be returned equal to the minimum number of operations required to convert word1 to word2. Two Strings will be passed in alphabets as word1 and word2.

Constraints

0 <= word1.length, word2.length <= 500

word1 and word2 consist of lowercase English letters.

Solution C++

#include "bits/stdc++.h"
using namespace std;

int solve(string& s, int m, string& t, int n, vector<vector<int>> &memo)
{
    if(m<0)
    {
        return n+1;
    }
    if(n<0)
    {
        return m+1;
    }

    if(memo[m][n]!=-1)
    {
        return memo[m][n];
    }

    if(s[m]==t[n])
    {
        return memo[m][n] = solve(s, m-1, t, n-1, memo);
    }

    return memo[m][n]=min(solve(s, m-1, t, n-1, memo), 
                            min(solve(s, m-1, t, n, memo),solve(s, m, t, n-1, memo)))+1;
}

int main() {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
    string s,t;
    cin>>s>>t;
    int m=s.length(), n=t.length();
    vector<vector<int>> memo(m, vector<int>(n, -1));

    cout<<solve(s,m-1, t, n-1, memo);

    return 0;
}

Solution Java

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone{
   public static int minDistance(String word1, String word2) {
    int n1 = word1.length();
    int n2 = word2.length();
        
    int[][] dp = new int[n1 + 1][n2 + 1];
        
    for (int i = 0; i <= n1; i++) {
      dp[i][0] = i;
    }
        
    for (int i = 0; i <= n2; i++) {
      dp[0][i] = i;
    }
         
    for (int i = 1; i <= n1; i++) {
      for (int j = 1; j <= n2; j++) {
        if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
          dp[i][j] = dp[i - 1][j - 1];
        } else {
          dp[i][j] = Math.min(dp[i - 1][j - 1],Math.min(dp[i - 1][j], dp[i][ j - 1])) + 1;
        }
      }
    }
    return (dp[n1][n2]);
    }
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner scn = new Scanner(System.in);
		String s1 = scn.next();
		String s2 = scn.next();
		System.out.println(minDistance(s1,s2));
	}
}

Solution Python

# Enter your code here. Read input from STDIN. Print output to STDOUT
def minDistance(word1: str, word2: str) -> int:
    # Get the lengths of both words
    m, n = len(word1), len(word2)
    
    # Create a (m+1) x (n+1) DP table initialized to 0
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    
    # Initialize the base cases for converting an empty string
    for i in range(m + 1):
        dp[i][0] = i  # Deleting all characters from word1
    for j in range(n + 1):
        dp[0][j] = j  # Inserting all characters into word1 to form word2
    
    # Fill the DP table
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if word1[i - 1] == word2[j - 1]:
                # If characters match, no operation needed
                dp[i][j] = dp[i - 1][j - 1]
            else:
                # Take the minimum of insert, delete, or replace operation
                dp[i][j] = min(dp[i - 1][j],      # Delete
                               dp[i][j - 1],      # Insert
                               dp[i - 1][j - 1]   # Replace
                              ) + 1
    
    # The answer is in dp[m][n]
    return dp[m][n]

# Input
word1 = input().strip()
word2 = input().strip()

# Output the minimum number of operations
print(minDistance(word1, word2))

Problem Statement 2

Aryan and Ankit play a game with N boxes. There are an even number of boxes arranged in a row, and each box has a positive integer number of stone balls, denoted by balls(i). The objective of the game is to end with the most balls. The total number of balls across all the boxes is odd, so there are no ties.

Rules:

Aryan and Ankit take turns picking all the balls from either the beginning or the end of the row of boxes. Aryan always plays first. Both players play optimally, meaning they make decisions to maximize their number of balls.

The game ends when there are no more boxes left. Assume Aryan and Ankit play optimally. Print Aryan if Aryan wins, and print Ankit if Ankit wins.

Input Format

The first line of input contains an integer N, representing the size of the array.

The second line of input contains N space separated integers representing the number of balls in the boxes.

Output Format

Display "Aryan" if Aryan wins or Display"Ankit" if Ankit wins.

Constraints

1<=N<=10^2

Assuming Arr denotes the array and Arr(i) denotes array element at ith index of the array.

1<=Arr(i)<=10^4

Solution C++

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;
using ll = long long;

#define all(a)             (a).begin(), (a).end()
#define rall(a)            (a).rbegin(), (a).rend()
#define sz(a)              (int) ((a).size())
#define pb                 push_back
#define fi                 first
#define se                 second
#define f0r(i, a, b)       for(int i = (a); i < (b); ++i)
#define f0rr(i, a, b)      for(int i = (a - 1); i >= (b); --i)
#define trav(i, v)         for(auto &i : (v))

template<class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;
template<typename T> T pow(T a, T b) { T res = 1; f0r(i, 0, b) res = res * a; return res; }
template<typename T> void ckmax(T &a, T b) { a = max(a, b);  }
template<typename T> void ckmin(T &a, T b) { a = min(a, b);  }

int dx4[] = {0, 1, 0, -1};
int dy4[] = {1, 0, -1, 0};
int dx8[] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy8[] = {-1, 0, 1, 1, 1, 0, -1, -1};

const int N2 = 1004, N = 200004;
const ll linf = 1000000000000000000;
const int inf = 1000010000;

int n, m, x, y;
ll v[N], a[N], b[N];
ll dp[N2][N2];
// <===================================================================================================>

ll f(int i, int j) {
   if(i > j) return 0LL;
   if(dp[i][j] != -1) return dp[i][j];
   ll ans = 0;
   ans = v[i] + f(i + 1, j);
   ckmax(ans, v[j] + f(i, j - 1));
   return dp[i][j] = ans;
}

int main(){
   cin.tie(nullptr)->sync_with_stdio(false);

   int tt = 1;
   // cin >> tt;
   f0r(T, 1, tt + 1) {
      cin >> n;
      ll tot = 0;
      f0r(i, 1, n + 1) {
         cin >> v[i];
         tot += v[i];
      }
      memset(dp, -1, sizeof(dp));
      f0r(i, 1, n + 1) {
         dp[i][i] = v[i];
      }
      ll alice = f(1, n);
      ll bob = tot - alice;
      if(alice > bob) cout << "Aryan";
      else cout << "Ankit";
   }
   return 0;
}

Solution Java

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
    System.out.println("Aryan");
    }
}

Solution Python

# Enter your code here. Read input from STDIN. Print output to STDOUT
n=int(input())
l=list(map(int, input().split()))
p=len(l)
s=0
k=0
for i in range(p//2):
        s+=l[i]
for i in range((p//2),p):
        k+=l[i]
if(l[0]>l[-1]):
    if(s>k):
        print("Aryan")
    else:
        print("Ankit")
else:
    if(k>s):
        print("Aryan")
    else:
        print("Ankit")

Problem Statement 3

You are given an integer array nums of unique elements, return all possible power sets. (All subsets). The solution set must not contain duplicate subsets. Print the subsets in a specific order, starting with the largest indexed element and proceeding with combinations that include the largest indexed elements first and then the second largest indexed element, and so on.

Input Format

The first line contains an integer N.

The Next N lines contain the integer A[i], where 0 <= i < N.

Output Format

Print all possible subsets (the power set) of the given array. Each subset should be printed on a new line. Subsets should be printed in order, starting with the subsets containing the largest indexed element, followed by combinations that include the second largest indexed elements first, and so on.

Constraints

1 <= nums.length <= 10

-10 <= nums[i] <= 10

All the numbers of nums are unique.

Solution C++

#include <bits/stdc++.h>
using namespace std;

vector<vector<int>> ans;

void solve(vector<int>& nums, int i, vector<int> temp) {

    if(i == nums.size()) {
        ans.push_back(temp);
        return;
    }

    solve(nums, i+1, temp);
    temp.push_back(nums[i]);
    solve(nums, i+1, temp);
}
void subsets(vector<int> &nums) {
    vector<int> temp;
    solve(nums, 0, temp);
}

int main() {

    int n;
    cin>>n;
    vector<int> nums(n);
    for(auto &i : nums) cin>>i;

    subsets(nums);

    for(auto &i : ans) {
        for(auto &j : i) {
            cout<<j<<" ";
        }
        cout<<endl;
    }   
    return 0;
}

Solution Java

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int [] arr= new int[n];
        for(int i=0;i<n;i++){
            arr[i]=sc.nextInt();
        }
        List<List<Integer>> result = Solution(n,arr);
        Collections.reverse(result);
        for(int i=0;i<result.size();i++){
            for(int j=0;j<result.get(i).size();j++){
                System.out.print(result.get(i).get(j)+" ");
            }
            System.out.println();
        }

    }
    public static List<List<Integer>> Solution(int n,int [] arr){
        List<Integer> temp = new ArrayList<>();
        List<List<Integer>> ans = new ArrayList<>();
        custom(ans,temp,n,arr,0);
        return ans;
    }
    public static void custom(List<List<Integer>> ans,List<Integer> temp,int n, int [] arr , int x){
        if(x==n){
            ans.add(new ArrayList<>(temp));
            return;
        }
        temp.add(arr[x]);
        custom(ans,temp,n,arr,x+1);
        temp.remove(temp.size()-1);
        custom(ans,temp,n,arr,x+1);
        return ;
    }
}

Solution Python

def solve(ar):
  ans = []
  def backtrack(ind, res):
    if ind == len(ar):
      ans.append(res.copy())
      return
    res.append(ar[ind])
    backtrack(ind+1, res)
    res.pop()
    backtrack(ind+1, res)
  backtrack(0, [])
  for i in range(len(ans)-1,-1,-1):
    for j in range(len(ans[i])):
      print(ans[i][j], end=' ')
    print()

input()
solve(list(map(int, input().split())))

Problem Statement 4

A matrix diagonal is a diagonal line of cells starting from some cell in either the topmost row or leftmost column and going in the bottom-right direction until reaching the matrix's end.

For example, the matrix diagonal starting from mat[2][0], where mat is a 6 x 3 matrix, includes cells mat[2][0], mat[3][1], and mat[4][2]. Given an m x n matrix mat of integers, sort each matrix diagonal in ascending order and return the resulting matrix.

Input Format

The first line contains two integers, M and N, representing the number of rows and columns in the matrix. The next M lines each contain N integers, representing the elements of the matrix mat. Each line corresponds to a row in the matrix.

Output Format

Print the Diagonally sorted matrix. Each row of the matrix should be printed on a new line.

Constraints

1 <= M, N <= 10^2

1 <= mat[i][j] <= 10^2

Solution C++

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>

using namespace std;

vector<vector<int>> diagonalSort(vector<vector<int>>& mat) {
    int m = mat.size();
    int n = mat[0].size();
    
    map<int, vector<int>> diagonals;
    
    // Traverse the top row and left column to create diagonals
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            diagonals[i - j].push_back(mat[i][j]);
        }
    }
    
    // Sort each diagonal
    for (auto& it : diagonals) {
        sort(it.second.begin(), it.second.end(), greater<int>()); // Sort in descending order
    }
    
    // Fill the sorted values back into the matrix
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            mat[i][j] = diagonals[i - j].back();
            diagonals[i - j].pop_back();
        }
    }
    
    return mat;
}

int main() {
    int m, n;
    cin >> m >> n;
    
    vector<vector<int>> mat(m, vector<int>(n));
   
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cin >> mat[i][j];
        }
    }
    
    vector<vector<int>> sortedMat = diagonalSort(mat);
  
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cout << sortedMat[i][j] << " ";
        }
        cout << endl;
    }
    
    return 0;
}

Solution Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Read dimensions
        int m = scanner.nextInt();
        int n = scanner.nextInt();
        int[][] mat = new int[m][n];

        // Read matrix elements
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                mat[i][j] = scanner.nextInt();
            }
        }

        // Map to store diagonals
        Map<Integer, List<Integer>> diagonals = new HashMap<>();

        // Group elements by diagonals
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int key = i - j;
                diagonals.putIfAbsent(key, new ArrayList<>());
                diagonals.get(key).add(mat[i][j]);
            }
        }

        // Sort each diagonal
        for (List<Integer> diagonal : diagonals.values()) {
            Collections.sort(diagonal);
        }

        // Refill the matrix with sorted diagonals
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int key = i - j;
                mat[i][j] = diagonals.get(key).remove(0);
            }
        }

        // Output the sorted matrix
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(mat[i][j] + " ");
            }
            System.out.println();
        }
    }
}

Solution Python

# Enter your code here. Read input from STDIN. Print output to STDOUT
a=input()
A=a.split()
m=int(A[0])
n=int(A[1])
mat=[]
for i in range(m):
  b=input()
  B=b.split()
  for j in range(n):
    B[j]=int(B[j])
  mat.append(B)
for y in range(n):
  l=[]
  i=0
  j=y
  while i<m and j<n:
    l.append(int(mat[i][j]))
    i=i+1
    j=j+1
  l.sort()
  i=0
  j=y
  for p in range(len(l)):
    mat[i][j]=l[p]
    i=i+1
    j=j+1
for x in range(m):
  l=[]
  i=x
  j=0
  while i<m and j<n:
    l.append(int(mat[i][j]))
    i=i+1
    j=j+1
  l.sort()
  i=x
  j=0
  for p in range(len(l)):
    mat[i][j]=l[p]
    i=i+1
    j=j+1
for q in mat:
  for r in q:
    print(r, end=' ')
  print('')

Problem Statement 5

Anna, a talented mathematician at the National Institute of Mathematics, was tasked with organizing a large collection of positive integers. She needed to find the smallest group of numbers (a subsequence) that, when removed from the collection, would leave her with a set of unique numbers.

The numbers in the subsequence had to be in non-decreasing order, and Anna only had a limited amount of time to complete the task. Help Anna identify and print the subsequence that, when taken from an array of length N, leaves her with a collection of distinct integers.

Since there may be multiple subsequences that can be removed to achieve this result, the subsequence that is both non-decreasing and smallest in length will be considered the optimal solution. If no such subsequence can be found, Anna must print -1.

Input Format

The first line contains an integer, N, the number of elements in the array Arr.

The next line contains N space-separated integers, denoting the array Arr.

Output Format

Print the subsequence that, when removed from the array, leaves Anna with a set of unique numbers. The resulting subsequence should be minimum in length and non-decreasing order. If such a suitable subsequence cannot be found, then print -1.

Constraints

1 <= N <= 10^5

1 <= Arr[i] <= 10^6

Solution C++

#include <bits/stdc++.h>
using namespace std;
void solve(vector<int> arr){
    map<int, vector<int>> m;

    for(int i = 0; i < arr.size(); i++){
        m[arr[i]].push_back(i);
    }
    int prev = -1;
    vector<int> ans;
    for(auto x: m){
        if(x.second.size() > 1){
            int cnt = x.second.size() - 1;
            for(auto nums: x.second){
                if(nums > prev){
                    cnt--;
                    prev = nums;
                    ans.push_back(arr[nums]);
                }
                if(cnt == 0) break;
            }
            if(cnt > 0){
                cout << "-1" << endl;
                return;
            }
        }
    }
    for(int x: ans) cout << x << " ";
    cout << endl;
}

int main(){
    int N; cin >> N;
    vector<int> arr(N);
    for(int i = 0; i < N; i++) cin >> arr[i];
    solve(arr);  
    return 0;
}

Solution Java

import java.util.*;

public class Main {
    public static void solve(List<Integer> arr) {
        Map<Integer, List<Integer>> map = new HashMap<>();

        // Group indices by array element
        for (int i = 0; i < arr.size(); i++) {
            map.putIfAbsent(arr.get(i), new ArrayList<>());
            map.get(arr.get(i)).add(i);
        }

        int prev = -1;
        List<Integer> ans = new ArrayList<>();

        // Traverse the map in sorted key order
        for (Integer key : new TreeSet<>(map.keySet())) {
            List<Integer> indices = map.get(key);

            if (indices.size() > 1) {
                int cnt = indices.size() - 1;

                for (int index : indices) {
                    if (index > prev) {
                        cnt--;
                        prev = index;
                        ans.add(arr.get(index));
                    }
                    if (cnt == 0) break;
                }

                // If we cannot satisfy the condition, print -1 and return
                if (cnt > 0) {
                    System.out.println("-1");
                    return;
                }
            }
        }

        // Print the result
        for (int x : ans) {
            System.out.print(x + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // Input handling
        int N = sc.nextInt();
        List<Integer> arr = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            arr.add(sc.nextInt());
        }

        solve(arr);
    }
}

Solution Python

def solve(arr):
    from collections import defaultdict

    # Group indices by array element
    grouped_indices = defaultdict(list)
    for i, val in enumerate(arr):
        grouped_indices[val].append(i)

    prev = -1
    ans = []

    # Traverse the grouped indices in sorted key order
    for key in sorted(grouped_indices.keys()):
        indices = grouped_indices[key]

        if len(indices) > 1:
            cnt = len(indices) - 1

            for index in indices:
                if index > prev:
                    cnt -= 1
                    prev = index
                    ans.append(arr[index])
                if cnt == 0:
                    break

            # If we cannot satisfy the condition, print -1 and return
            if cnt > 0:
                print(-1)
                return

    # Print the result
    print(" ".join(map(str, ans)))


def main():
    # Input handling
    N = int(input())
    arr = list(map(int, input().split()))
    solve(arr)


if __name__ == "__main__":
    main()

Conclusion

Cracking IBM’s coding assessment requires focused preparation and a strategic approach. By thoroughly understanding the test pattern and practicing the previous year's coding questions, you can significantly enhance your chances of success.

Stay consistent, sharpen your logic, and approach the test with confidence. Good luck!

Frequently Asked Questions (FAQs)

1. What is the structure of IBM’s coding assessment?

It comprises a mix of MCQs and 1-2 coding problems designed to evaluate programming proficiency and logical reasoning.

2. Which languages can I use for coding questions?

Commonly supported languages include Java, Python, C++, and C.

3. Are IBM’s previous year's questions repetitive?

While questions aren’t repeated verbatim, similar patterns and logic are often tested.

4. Where can I find IBM’s previous coding questions?

IBM does not officially release past questions. However, you can find curated examples on trusted online forums and platforms.

5. Can I expect dynamic programming problems in the coding test?

Yes, basic to intermediate-level dynamic programming problems are often included.

Disclaimer: While we strive for accuracy, we do not guarantee its completeness or reliability. Readers are encouraged to verify all facts and statistics from the official company website or check independently before making decisions.