Home Get Hired ADP Selected Coding Questions, Answers and Tips for Freshers 2025

ADP Selected Coding Questions, Answers and Tips for Freshers 2025

Get the latest ADP coding sample questions, answers, and practical strategies to excel in ADP's technical test—perfect for freshers and aspiring professionals. Read on for details.

6 mins read

ADP Selected Coding Questions, Answers and Tips for Freshers 2025

When it comes to starting your career with a global leader in technology, ADP stands out as a top choice. Their coding test is a crucial step in the hiring process and is designed to assess your problem-solving abilities, coding expertise, and logical thinking.

Whether you're a fresher eager to make your mark or an experienced professional aiming to grow, the detailed content in this article will help you prepare effectively for the ADP coding test.

What is the ADP Coding Test?

The ADP coding test is an integral part of the recruitment process for roles requiring technical expertise. It evaluates your ability to solve real-world problems using programming languages, algorithms, and data structures.

Here's what you need to know:

Feature	Details
Mode	Online, proctored test
Duration	Typically 60–90 minutes
Number of Questions	3–5 coding problems
Languages Allowed	C, C++, Java, Python, etc.
Focus Areas	Algorithms, data structures, debugging, and code optimisation

Key Topics Covered in the ADP Coding Test

To ace the ADP coding test, focus on the following areas:

1. Data Structures

Arrays, linked lists, stacks, and queues
Trees and graphs (binary search trees, BFS, DFS)

2. Algorithms

Sorting (quick sort, merge sort)
Searching (binary search, linear search)
Dynamic programming (knapsack problem, longest subsequence)

3. Problem Solving

String manipulation (palindromes, substring problems)
Number theory (prime numbers, greatest common divisors)

4. Debugging

Identify and fix errors in existing code snippets.
Focus on reading error messages and understanding their meaning.

Selected Questions for the ADP Coding Test

Problem Statement 1

John and Davis are playing a game with ( N ) distinct coins, each numbered from 1 to ( N ). John challenges Davis to place the coins in a straight line. The challenge is that any coin with a number ( P ) that satisfies the equation 1×2×3×...×(p−1)+1 is divisible by ( P ) and must be placed at a prime position in the line. Davis is confused and needs help to find the number of ways to arrange the coins.

Note: If the number of ways is large, take the result modulo (10^9 + 7).

Input Format

The first line consists of an integer ( N ), which denotes the number of coins.

Output Format

Print a single line consisting of an integer that shows the number of ways that are possible.

Solution C++

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

    int numPrimeArrangements(int n) {
    int M = 1e9 + 7;
    if(n <= 2) return 1;
    int no_pr = 1;
    vector<bool> isp(n+1,1);
    for(int i=4;i<=n;i+=2) isp[i] = 0;
    for(long int i=3;i<=n;i+=2){
        if(isp[i]){
            no_pr++;
            isp[i] = 1;
            for(long int j = i*i; j <= n; j += i){
            isp[j] = 0;
        }
    }
}
long int ans = 1;
for(int i=1;i<=no_pr;i++){
    ans = ans*i;
    ans = ans%M;
}
for(int i=1;i<=n-no_pr;i++){
    ans = ans*i;
    ans = ans%M;
}
    return ans;
}
int main(){
int n ;
cin >>n;
cout << numPrimeArrangements(n);
    return 0;
}

Solution Java

import java.util.Scanner;

public class Main {
    public static int numPrimeArrangements(int n) {
        int M = 1000000007;
        if (n <= 2) return 1;
        
        int no_pr = 1;
        boolean[] isp = new boolean[n + 1];
        for (int i = 0; i <= n; i++) isp[i] = true;
        
        for (int i = 4; i <= n; i += 2) isp[i] = false;
        
        for (long i = 3; i <= n; i += 2) {
            if (isp[(int)i]) {
                no_pr++;
                for (long j = i * i; j <= n; j += i) {
                    isp[(int)j] = false;
                }
            }
        }
        
        long ans = 1;
        for (int i = 1; i <= no_pr; i++) {
            ans = ans * i % M;
        }
        
        for (int i = 1; i <= n - no_pr; i++) {
            ans = ans * i % M;
        }
        
        return (int) ans;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        System.out.println(numPrimeArrangements(n));
        scanner.close();
    }
}

Solution Python

def numPrimeArrangements(n):
    M = 10**9 + 7
    if n <= 2:
        return 1
    
    no_pr = 1
    isp = [True] * (n + 1)
    
    for i in range(4, n + 1, 2):
        isp[i] = False
    
    for i in range(3, n + 1, 2):
        if isp[i]:
            no_pr += 1
            for j in range(i * i, n + 1, i):
                isp[j] = False
    
    ans = 1
    for i in range(1, no_pr + 1):
        ans = ans * i % M
    
    for i in range(1, n - no_pr + 1):
        ans = ans * i % M
    
    return ans

if __name__ == "__main__":
    n = int(input())
    print(numPrimeArrangements(n))

Problem Statement 2

Given two strings, S and T, your task is to check whether T can be obtained by dividing S into two equal parts and interleaving the characters of the two parts with each other without changing the order of characters within each part.

For example, the string "GHIJKL" can be split into two parts: "GHI" and "JKL". It can be interleaved into "GJHKIL" but not into "HGIKJL", as the order of characters within each part must remain intact.

Find whether T can be obtained from S under these conditions.

Input Format

The first line of input contains two space-separated strings, S and T, representing the original string and the target string, respectively.

Output Format

Display boolean value 1 if T can be formed by interleaving the two parts of S; otherwise, print 0.

Solution C++

#include <bits/stdc++.h>
	using namespace std;
	#define ll long long int
	bool isJumbled(
	   string A, string B, string C)
	{
	   // we are finding lengths of the two strings
	   int M = A.length(), N = B.length();
	  // we created a 2D table to store solutions of subproblems.  T[i][j] will be true if T[0..i+j-1] can be obtained from the first half of S[0..i-1] and the second half of S[0..j-1].
	   bool IL[M + 1][N + 1];
	   // we initialized all values as false.
	   memset(IL, 0, sizeof(IL));
	   // T can be obtained if the lengths of S and T are equal.
	   if ((M + N) != C.length())
	       return false;
	   // we are processing all characters of S
	   for (int i = 0; i <= M; ++i) {
	       for (int j = 0; j <= N; ++j) {
	           // two empty strings can result in an empty string 
	           if (i == 0 && j == 0)
	               IL[i][j] = true;
	           // first half of S is empty
	           else if (i == 0) {
	               if (B[j - 1] == C[j - 1])
	               IL[i][j] = IL[i][j - 1];
	           }
	           // second half of S is empty
	           else if (j == 0) {
	               if (A[i - 1] == C[i - 1])
	                   IL[i][j] = IL[i - 1][j];
	           }
	           // Current character of T matches with current character of first half of S but doesn't match with current character of second half of S
	           else if (
	               A[i - 1] == C[i + j - 1]
	               && B[j - 1] != C[i + j - 1])
	               IL[i][j] = IL[i - 1][j];
	           // Current character of T matches with current character of second half of S, but doesn't match with current character of first half of S
	           else if (
	               A[i - 1] != C[i + j - 1]
	               && B[j - 1] == C[i + j - 1])
	               IL[i][j] = IL[i][j - 1];
	
	                     // Current character of T matches with current character of first half of S and also with current character of second half of S 
	           else if (
	               A[i - 1] == C[i + j - 1]
	               && B[j - 1] == C[i + j - 1])
	               IL[i][j] = (IL[i - 1][j] || IL[i][j - 1]);
	       }
	   }
	   return IL[M][N];
	}
	int main()
	{
	   string s,t;
	   cin>>s>>t;
	   string s0,s1;
	   s0=s.substr(0,s.length()/2);
	   s1=s.substr(s.length()/2);
	   if(isJumbled(s0,s1,t)) cout<<1<<endl;
	   else cout<<0<<endl;
	   return 0;
	}

Solution Java

import java.util.Scanner;

public class Main {
    public static boolean isJumbled(String A, String B, String C) {
        // Finding lengths of the two strings
        int M = A.length(), N = B.length();
        // Create a 2D table to store solutions of subproblems
        boolean[][] IL = new boolean[M + 1][N + 1];
        // Initialize all values as false
        for (int i = 0; i <= M; i++) {
            for (int j = 0; j <= N; j++) {
                IL[i][j] = false;
            }
        }
        // T can be obtained if the lengths of S and T are equal
        if ((M + N) != C.length()) {
            return false;
        }
        // Process all characters of S
        for (int i = 0; i <= M; ++i) {
            for (int j = 0; j <= N; ++j) {
                // Two empty strings can result in an empty string
                if (i == 0 && j == 0) {
                    IL[i][j] = true;
                }
                // First half of S is empty
                else if (i == 0) {
                    if (B.charAt(j - 1) == C.charAt(j - 1)) {
                        IL[i][j] = IL[i][j - 1];
                    }
                }
                // Second half of S is empty
                else if (j == 0) {
                    if (A.charAt(i - 1) == C.charAt(i - 1)) {
                        IL[i][j] = IL[i - 1][j];
                    }
                }
                // Current character of T matches with current character of first half of S but doesn't match with current character of second half of S
                else if (A.charAt(i - 1) == C.charAt(i + j - 1) && B.charAt(j - 1) != C.charAt(i + j - 1)) {
                    IL[i][j] = IL[i - 1][j];
                }
                // Current character of T matches with current character of second half of S, but doesn't match with current character of first half of S
                else if (A.charAt(i - 1) != C.charAt(i + j - 1) && B.charAt(j - 1) == C.charAt(i + j - 1)) {
                    IL[i][j] = IL[i][j - 1];
                }
                // Current character of T matches with current character of first half of S and also with current character of second half of S
                else if (A.charAt(i - 1) == C.charAt(i + j - 1) && B.charAt(j - 1) == C.charAt(i + j - 1)) {
                    IL[i][j] = (IL[i - 1][j] || IL[i][j - 1]);
                }
            }
        }
        return IL[M][N];
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.next();
        String t = scanner.next();
        String s0 = s.substring(0, s.length() / 2);
        String s1 = s.substring(s.length() / 2);
        if (isJumbled(s0, s1, t)) {
            System.out.println(1);
        } else {
            System.out.println(0);
        }
        scanner.close();
    }
}

Solution Python

def is_jumbled(A, B, C):
    # Finding lengths of the two strings
    M, N = len(A), len(B)
    # Create a 2D table to store solutions of subproblems
    IL = [[False] * (N + 1) for _ in range(M + 1)]
    # T can be obtained if the lengths of S and T are equal
    if (M + N) != len(C):
        return False
    # Process all characters of S
    for i in range(M + 1):
        for j in range(N + 1):
            # Two empty strings can result in an empty string
            if i == 0 and j == 0:
                IL[i][j] = True
            # First half of S is empty
            elif i == 0:
                if B[j - 1] == C[j - 1]:
                    IL[i][j] = IL[i][j - 1]
            # Second half of S is empty
            elif j == 0:
                if A[i - 1] == C[i - 1]:
                    IL[i][j] = IL[i - 1][j]
            # Current character of T matches with current character of first half of S but doesn't match with current character of second half of S
            elif A[i - 1] == C[i + j - 1] and B[j - 1] != C[i + j - 1]:
                IL[i][j] = IL[i - 1][j]
            # Current character of T matches with current character of second half of S, but doesn't match with current character of first half of S
            elif A[i - 1] != C[i + j - 1] and B[j - 1] == C[i + j - 1]:
                IL[i][j] = IL[i][j - 1]
            # Current character of T matches with current character of first half of S and also with current character of second half of S
            elif A[i - 1] == C[i + j - 1] and B[j - 1] == C[i + j - 1]:
                IL[i][j] = IL[i - 1][j] or IL[i][j - 1]
    return IL[M][N]

if __name__ == "__main__":
    import sys
    input = sys.stdin.read
    data = input().split()
    s = data[0]
    t = data[1]
    s0 = s[:len(s) // 2]
    s1 = s[len(s) // 2:]
    if is_jumbled(s0, s1, t):
        print(1)
    else:
        print(0)

Problem Statement 3

Marco likes words a lot. But he likes them in lowercase only. He got a book from his friend where words are written in upper and lowercase characters. Help Marco to convert all words into lowercase.

Input Format

The first line contains the string word.

Output Format

The first line contains the transformed string in lowercase.

Solution C++

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

string lowerCaseInput(string s) {
	int n = s.length();
	int i = 0;
	
	// Traverse until all characters becomes in lower-case.
	while(i < n) {
		if(s[i] >= 'A' && s[i] <= 'Z') {
			s[i] = s[i] + 32;	// convert to lower-case
		}
		i++;
	}
	
	return s;
}

int main() {
	string word;
	// Take the input
	cin >> word;
	cout << lowerCaseInput(word);
	return 0;
}

Solution Java

import java.util.*;

public class Main {

    // Method to convert input string to lowercase
    public static String lowerCaseInput(String s) {
        int n = s.length();
        int i = 0;

        // Convert each character to lowercase if it is uppercase
        StringBuilder result = new StringBuilder();
        while (i < n) {
            char currentChar = s.charAt(i);
            if (currentChar >= 'A' && currentChar <= 'Z') {
                currentChar += 32; // Convert to lowercase
            }
            result.append(currentChar);
            i++;
        }

        return result.toString();
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Take input
        String word = scanner.next();
        
        // Print the converted lowercase string
        System.out.println(lowerCaseInput(word));
        
        scanner.close();
    }
}

Solution Python

def lower_case_input(s):
    n = len(s)
    i = 0
    result = []
    
    # Convert each character to lowercase if it is uppercase
    while i < n:
        current_char = s[i]
        if 'A' <= current_char <= 'Z':
            current_char = chr(ord(current_char) + 32)  # Convert to lowercase
        result.append(current_char)
        i += 1
    
    return ''.join(result)

# Take input
word = input()

# Print the converted lowercase string
print(lower_case_input(word))

Problem Statement 4

Alice loves the sequence and series in mathematics. He got very interesting questions about the special series. The Nth term of the Special Series is the absolute difference between the last two terms of the special series. You have given 3 integers: A, B, and N. A and B represent the first and second terms of the special series.

Your task is to return to the Nth term of the special series.

Input Format

The first and only line contains 3 space-separated integers: A, B, and N.

Output Format

Print the 'N' th term of the special series.

Solution C++

#include <bits/stdc++.h>
using namespace std;
int SpecialSeries(int A, int B, int N)
{
  // Create an array to store the calculated Nth terms
  int dp[N + 1];
  // Initialize the first two terms of the series
  dp[1] = A;
  dp[2] = B;
  // Loop through the remaining terms of the series
  for (int i = 3; i <= N; i++) {
    // Calculate the Nth term using the formula given in the problem statement
    dp[i] = abs(dp[i - 1] - dp[i - 2]);
  }
  // Return the Nth term from the array
  return dp[N];
}
int main()
{
    int A, B, N;
    cin>>A>>B>>N;
    cout<<SpecialSeries(A,B,N)<<endl;
    return 0;
}

Solution Java

import java.util.Scanner;

public class Main {

    public static int specialSeries(int A, int B, int N) {
        // Create an array to store the calculated Nth terms
        int[] dp = new int[N + 1];
        
        // Initialize the first two terms of the series
        dp[1] = A;
        dp[2] = B;

        // Loop through the remaining terms of the series
        for (int i = 3; i <= N; i++) {
            // Calculate the Nth term using the absolute difference
            dp[i] = Math.abs(dp[i - 1] - dp[i - 2]);
        }

        // Return the Nth term from the array
        return dp[N];
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        // Input reading
        int A = sc.nextInt();
        int B = sc.nextInt();
        int N = sc.nextInt();
        
        // Calculate and output the Nth term
        int result = specialSeries(A, B, N);
        System.out.println(result);
        
        sc.close(); // Close the scanner to prevent resource leaks
    }
}

Solution Python

def special_series(A, B, N):
    # If N is 1 or 2, return A or B respectively
    if N == 1:
        return A
    if N == 2:
        return B

    # Initialize the first two terms of the series
    prev2 = A
    prev1 = B

    # Loop through the remaining terms starting from 3 up to N
    for i in range(3, N + 1):
        current = abs(prev1 - prev2)
        prev2 = prev1
        prev1 = current

    # Return the Nth term
    return current

# Input parsing
A, B, N = map(int, input().split())

# Output the Nth term
print(special_series(A, B, N))

Problem Statement 5

You are given an array of N intervals, where each interval is defined by a start and an end. Your task is to minimize the smallest difference between overlapping intervals.

Specifically, you need to find the difference between the start and end of any overlapping intervals and return the minimum difference among these.

For example, if the overlapping intervals are [1, 5] and [2, 3], the difference is calculated as 3 - 2, which equals 1. You should return the smallest such difference.

Input Format

The first line contains an integer representing the number of intervals.

The next lines each contain two space-separated integers representing the start and end of each interval.

Output Format

Print a single integer representing the minimum difference between the overlapping intervals.

Solution C++

#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> merge(vector<vector<int>>& I) {
        sort(begin(I), end(I));
        int R = 0;
        for(auto i : I)
            if(i[0] <= I[R][1])                          
                I[R][1] = max(I[R][1], i[1]);
            else                                              
                I[++R] = i;
        I.resize(R+1);
        return I;
    } 


int main() {
	// your code goes here
	int n;
	cin>>n;
	vector<vector<int>> intervals(n, vector<int>(2));
	for(int i=0;i<n;++i)
	{
		for(int j=0;j<2;++j)
		{
			cin>>intervals[i][j];
		}
	}
	vector<vector<int>> res = merge(intervals);
	int min= res[0][1] - res[0][0];
	for(int j = 1; j < res.size(); j++)
	{   
		if((res[j][1]-res[j][0])<min){
		    min= (res[j][1]-res[j][0]);
		}
			
	}
	cout<<min;
	return 0;
}

Solution Java

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class Main {

    public static List<int[]> merge(List<int[]> intervals) {
        intervals.sort(Comparator.comparingInt(a -> a[0]));
        int R = 0;
        for (int i = 1; i < intervals.size(); i++) {
            if (intervals.get(i)[0] <= intervals.get(R)[1]) {
                intervals.get(R)[1] = Math.max(intervals.get(R)[1], intervals.get(i)[1]);
            } else {
                R++;
                intervals.set(R, intervals.get(i));
            }
        }
        return intervals.subList(0, R + 1);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        List<int[]> intervals = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int start = scanner.nextInt();
            int end = scanner.nextInt();
            intervals.add(new int[]{start, end});
        }
        List<int[]> res = merge(intervals);
        int min = res.get(0)[1] - res.get(0)[0];
        for (int i = 1; i < res.size(); i++) {
            min = Math.min(min, res.get(i)[1] - res.get(i)[0]);
        }
        System.out.println(min);
        scanner.close();
    }
}

Solution Python

def merge(intervals):
    intervals.sort()
    R = 0
    for i in range(1, len(intervals)):
        if intervals[i][0] <= intervals[R][1]:
            intervals[R][1] = max(intervals[R][1], intervals[i][1])
        else:
            R += 1
            intervals[R] = intervals[i]
    return intervals[:R+1]

def main():
    n = int(input())
    intervals = []
    for _ in range(n):
        intervals.append(list(map(int, input().split())))
    res = merge(intervals)
    min_length = res[0][1] - res[0][0]
    for i in range(1, len(res)):
        min_length = min(min_length, res[i][1] - res[i][0])
    print(min_length)

if __name__ == "__main__":
    main()

Are you looking for coding assessment questions related to job placement? Click here to access coding practice sessions from moderate to challenging levels.

Preparation Tips for ADP Coding Questions

Here are actionable steps to prepare effectively for the test:

Tips	Details
Understand the Basics	Master the fundamentals of your preferred programming language.
Practice Regularly	Solve problems related to coding on available online platforms.
Time Management	Practice coding under timed conditions to simulate the test environment.
Analyse Solutions	Review multiple approaches to solve problems and optimise your solutions.
Mock Tests	Attempt ADP-specific mock coding tests to familiarise yourself with the format.

Conclusion

The ADP coding test is your gateway to an exciting career with one of the world's leading technology companies. By mastering the topics, practising regularly, and staying calm during the test, you can set yourself up for success. Remember, preparation is key—so start early, practice smartly, and ace the coding test!

Frequently Asked Questions (FAQs)

1. What level of coding expertise is required for the ADP coding test

Freshers should have a solid grasp of programming basics, while experienced candidates may encounter advanced problem-solving tasks.

2. Can I use any programming language in the test?

Yes, ADP allows flexibility in choosing languages like C, C++, Java, and Python.

3. How can I improve my debugging skills for the test?

Regularly debug code on platforms like GeeksforGeeks or practice finding errors in sample problems.

4. Are there negative marks for wrong answers?

Generally, no negative marking is applied, but ensure to check specific test guidelines.

5. What is the best way to prepare for ADP coding questions?

Focus on practising coding problems, reviewing past test questions, and understanding algorithms.

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.