Deloitte Coding Questions: Top 5 Coding Questions for Freshers

8 mins read

Deloitte conducts rigorous coding assessments during recruitment to evaluate candidates' technical skills and problem-solving abilities. These assessments are vital for both freshers and experienced professionals, ensuring they have the necessary programming knowledge and analytical thinking for various roles. This article covers Deloitte coding question types, sample questions, and preparation strategies.

Types of Deloitte Coding Questions

Deloitte coding questions can generally be categorized into the following areas:

Deloitte Interview Coding Questions for Freshers

For freshers, Deloitte often asks questions that test basic programming skills, problem-solving capabilities, and understanding of algorithms and data structures. Here are some examples:

Top 5 Sample Coding Questions for Deloitte

Problem Statement 1: John and Mocha are two friends. Mocha made his dictionary of length n with strings k1, k2 .. kn and called it Alien dictionary. John tries to test Mocha's Alien dictionary by giving one string s to Mocha. Help Mocha check if John's string can be segmented into a sequence of one or more words from Mocha's Alien dictionary.

Note: The words in the dictionary contain unique words of lowercase English letters and can be found multiple times in the segmentation.

Input Format: 

The first line contains a string s given by John.

The second line contains n, which is the length of the dictionary of strings of Mocha.

The following n lines are different strings that are present in the Mocha's Alien dictionary

Output Format:

Print "true" if the string given by John can be segmented into a sequence of one or more words of Mocha's Alien dictionary.

Else, print "false".

Constraints:

1<= s.length() <= 3*10^2

1<= n <= 10^3

1<= ki.length() <= 20

Sample Input:

applepenapple

2

apple

pen

Sample Output:

true

Solution 1: C++

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

bool wordBreak(string s, vector<string> &wordDict) {

    if(wordDict.size() == 0) return false;
    set<string> dict;

    for(int i=0; i<wordDict.size(); i++) {

        dict.insert(wordDict[i]);

    }

    vector<bool> dp(s.size() + 1, false);
    dp[0] = true;

    for(int i=1; i<=s.size(); i++) {
        for(int j=i-1; j>=0; j--) {
            if(dp[j]) {
                string word = s.substr(j, i-j);
                if(dict.find(word) != dict.end()) {
                    
                    dp[i] = true;
                    break;

                }
            }
        }
    }
    return dp[s.size()];
}

int main() {
    
    string s;
    cin>>s;
    int n;
    cin>>n;
    vector<string> wordDict;
    for(int i=0; i<n; i++) {
        string str;
        cin>>str;
        wordDict.push_back(str);
    }   
    wordBreak(s, wordDict) ? cout<<"true" : cout<<"false";
    return 0;
}

class AlienDictionary:
    def __init__(self):
        self.dictionary = set()

    def add_word(self, word):
        self.dictionary.add(word)

    def can_segment(self, s):
        n = len(s)
        dp = [False] * (n + 1)
        dp[0] = True

        for i in range(1, n + 1):
            for j in range(i):
                if dp[j] and s[j:i] in self.dictionary:
                    dp[i] = True
                    break

        return dp[n]

# Reading input
s = input().strip()
n = int(input().strip())

alien_dict = AlienDictionary()

for _ in range(n):
    word = input().strip()
    alien_dict.add_word(word)

# Checking if John's string can be segmented
result = alien_dict.can_segment(s)

# Printing the result
if result:
    print("true")
else:
    print("false")

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

public class Main {
    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
       Scanner sc=new Scanner(System.in);
       String s=sc.next();
       boolean[]dp=new boolean[s.length()+1];
       int n=sc.nextInt();
       String[]dict=new String[n];
       
       for(int i=0;i<n;i++){
        dict[i]=sc.next();
       // System.out.println(dict[i]);
       }
    
     dp[0]=true;
      for(int i=0;i<s.length();i++){
        for(int j=0;j<dict.length;j++){
            if(s.charAt(i)==dict[j].charAt(dict[j].length()-1) && i+1>=dict[j].length())
            {
                if(s.substring(i-dict[j].length()+1,i+1).equals(dict[j]))
                 dp[i+1]=dp[i+1]||dp[i-dict[j].length()+1];
            }
            
        }
      }
      System.out.println(dp[s.length()]);

    }
}

Python:
# Enter your code here. Read input from STDIN. Print output to STDOUT
import math

def lcm(a, b):
    return a * b // math.gcd(a, b)

p, n = map(int, input().split())
print(lcm(p, n))

Solution code in C++

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;


int main() {
    long long int a,b;
    cin>>a>>b;
    if(b%a==0)
    {
        cout<<b;
    }
    else
    {
        cout<<a*b;
    }
}

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

class Main {

    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        Scanner sc = new Scanner(System.in);
        long a =sc.nextLong();
        long b=sc.nextLong();
        long great=gcd(a,b);
        System.out.print((a*b)/great);
       
        
    }
    public static long gcd(long a,long b){
        while(b!=0){
            long temp=b;
            b=a%b;
            a=temp;
        }
        return a;

    }
}

from typing import List, Optional
from collections import deque

class TreeNode:
    def __init__(self, x: int):
        self.val = x
        self.left = None
        self.right = None

    @staticmethod
    def treeNodeToString(root: Optional['TreeNode']) -> str:
        if root is None:
            return ""

        output = ""
        queue = deque([root])
        while queue:
            node = queue.popleft()
            if node is not None:
                output += str(node.val) + " "
                queue.append(node.left)
                queue.append(node.right)
        return output.strip()

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        def helper(left: int, right: int) -> Optional[TreeNode]:
            if left > right:
                return None
            mid = (left + right) // 2
            root = TreeNode(nums[mid])
            root.left = helper(left, mid - 1)
            root.right = helper(mid + 1, right)
            return root

        return helper(0, len(nums) - 1)

# Example usage
if __name__ == "__main__":
    import sys
    input = sys.stdin.read
    data = list(map(int, input().split()))
    nums = data[1:]
    sol = Solution()
    bst_root = sol.sortedArrayToBST(nums)
    print(TreeNode.treeNodeToString(bst_root))

#include <iostream>
#include <vector>
#include <queue>
#include <string>

using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}

    static string treeNodeToString(TreeNode* root) {
        if (root == nullptr)
            return "";

        string output = "";
        queue<TreeNode*> nodeQueue;
        nodeQueue.push(root);

        while (!nodeQueue.empty()) {
            TreeNode* node = nodeQueue.front();
            nodeQueue.pop();

            if (node != nullptr) {
                output += to_string(node->val) + " ";
                nodeQueue.push(node->left);
                nodeQueue.push(node->right);
            }
        }

        return output;
    }
};

class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return helper(nums, 0, nums.size() - 1);
    }

private:
    TreeNode* helper(vector<int>& nums, int left, int right) {
        if (left > right)
            return nullptr;
        
        int mid = (left + right) / 2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = helper(nums, left, mid - 1);
        root->right = helper(nums, mid + 1, right);
        return root;
    }
};

int main() {
    int n;
    cin >> n;
    vector<int> nums(n);
    for (int i = 0; i < n; ++i)
        cin >> nums[i];

    Solution sol;
    TreeNode* bstRoot = sol.sortedArrayToBST(nums);
    cout << TreeNode::treeNodeToString(bstRoot) << endl;

    return 0;
}

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

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner scn = new Scanner(System.in);
        Solution ob = new Solution();
        int n = scn.nextInt();
        int[] nums = new int[n];
        for (int i = 0; i < n; i++)
            nums[i] = scn.nextInt();
        System.out.println(TreeNode.treeNodeToString(ob.sortedArrayToBST(nums)));
    }
}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {
        val = 0;
    }

    TreeNode(int x) {
        val = x;
    }

    public static String treeNodeToString(TreeNode root) {
        if (root == null) {
            return "";
        }

        String output = "";
        Queue<TreeNode> nodeQueue = new LinkedList<>();
        nodeQueue.add(root);
        while (!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.remove();

            if (node == null) {
                continue;
            }

            output += String.valueOf(node.val) + " ";
            nodeQueue.add(node.left);
            nodeQueue.add(node.right);
        }
        return output.trim();
    }
}

class Solution {
    int[] nums;

    public TreeNode helper(int left, int right) {
        if (left > right)
            return null;

        // always choose left middle node as a root
        int p = (left + right) / 2;

        // preorder traversal: node -> left -> right
        TreeNode root = new TreeNode(nums[p]);
        root.left = helper(left, p - 1);
        root.right = helper(p + 1, right);
        return root;
    }

    public TreeNode sortedArrayToBST(int[] nums) {
        this.nums = nums;
        return helper(0, nums.length - 1);
    }
}

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


int main() {
    int n;
    cin>>n;
    vector<int>v(n);
    for(auto &i:v) cin>>i;
    vector<int>xoro(n);
    xoro[0]=v[0];
    for(int i=1;i<n;i++) xoro[i]=xoro[i-1]^v[i];
    int q,c;
    cin>>q>>c;
    for(int i=0;i<q;i++)
    {
        int l,r;
        cin>>l>>r;
        if(l==0) cout<<xoro[r]<<endl;
        else cout<<(xoro[r]^xoro[l-1])<<endl;
    }
    return 0;
}

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

class Main {

    
    public static int[] solveXORQueries(int[] arr, int[][] queries) {
        int n = arr.length;
        
       
        int[] prefixXOR = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            prefixXOR[i] = prefixXOR[i-1] ^ arr[i-1];
        }
        
        
        int[] results = new int[queries.length];
        for (int i = 0; i < queries.length; i++) {
            int left = queries[i][0];
            int right = queries[i][1];
           
            results[i] = prefixXOR[right+1] ^ prefixXOR[left];
        }
        
        return results;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
  
        int n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        
        int q = scanner.nextInt();
        scanner.nextInt(); 
        
        int[][] queries = new int[q][2];
        for (int i = 0; i < q; i++) {
            queries[i][0] = scanner.nextInt();
            queries[i][1] = scanner.nextInt();
        }

int[] answer = solveXORQueries(arr, queries);
for (int value : answer) {
    System.out.println(value);
}
            }
        }

# Enter your code here. Read input from STDIN. Print output to STDOUT
n=int(input())
a=list(map(int,input().split()))
q=int(input())
c=int(input())
queries=[list(map(int,input().split())) for _ in range(q)]
#print(queries)
for i in queries:
  start,end=i
  res=a[start]
  for i in range(start+1,end+1):
    res^=a[i]
  print(res)

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

class Main {

    // Function to count GLPairs
    static int GLPairs(int n, int[] num) {
        HashMap<Integer, Integer> mp = new HashMap<>(); // HashMap to store occurrences of each element
        int ans = 0; // Variable to store the count of GL(i,j)=0 pairs

        // Iterating over the array to hash in the HashMap
        for (int i = 0; i < n; i++) {
            if (mp.containsKey(num[i])) {
                mp.put(num[i], mp.get(num[i]) + 1);
            } else {
                mp.put(num[i], 1);
            }
        }

        // Iterating over the HashMap to add the contribution of each element in the GL(i,j) = 0 pairs
        for (int count : mp.values()) {
            ans += (count * (count - 1)) / 2;
        }

        return ans; // Returning the answer
    }

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

        // Taking input
        int n = scanner.nextInt();
        int[] num = new int[n];
        for (int i = 0; i < n; i++) {
            num[i] = scanner.nextInt();
        }

        // Calling the function and printing the result
        System.out.println(GLPairs(n, num));
    }
}

#include <bits/stdc++.h>
using namespace std;
int GLPairs(int n,vector<int>&num)
{
    unordered_map<long long int, long long int>mp; // creating the map to have the occurrence of each element.
    long long int ans =0; // variable to store the count of GL(i,j)=0.
    for(auto &i: num) //iterating over the array to hash in the map.
    mp[i]++;
    for(auto &i: mp) //iterating over the map to add the contribution of each element in the GL(i,j) = 0 pairs.
    {
    ans += ((i.second*(i.second-1))/2); // incrementing answer by each elements occurrence distribution.
    }
    return ans; //returning the answer.
}
int main() {
     int n ;
     cin>>n;
     vector<int>vec(n);
     for(auto &i:vec)
    {
        cin>>i;
    }
    cout<<GLPairs(n,vec)<<endl;
    return 0;
}

def GLPairs(n, num):
    mp = {}  # creating the dictionary to have the occurrence of each element.
    ans = 0  # variable to store the count of GL(i,j)=0.
    for i in num:  # iterating over the array to hash in the dictionary.
        if i in mp:
            mp[i] += 1
        else:
            mp[i] = 1
    for i in mp.values():  # iterating over the dictionary to add the contribution of each element in the GL(i,j) = 0 pairs.
        ans += (i * (i - 1)) // 2  # incrementing answer by each element's occurrence distribution.
    return ans  # returning the answer.


# Taking input and calling the function
n = int(input())
num = list(map(int, input().split()))
print(GLPairs(n, num))

Preparing for the upcoming Deloitte exam? Click here to practice coding related problem statements so that you excel in this exam. 

Deloitte Coding Questions for Freshers: Preparation Tips

To effectively prepare for Deloitte coding interviews, follow these strategies:

Disclaimer: While we have gathered as much information from Deloitte's official website as possible, we have also included sources gathered from available online sources. Therefore, readers are advised to check and stay updated with the official website.

Conclusion

Deloitte coding interviews can be tough, but with the right approach, you can ace them. You’ve learned about the recruitment process, common questions, and effective strategies to prepare. Remember, practice is key. The more problems you tackle, the more confident you'll feel. Your success depends on your preparation. Get ready to impress Deloitte with your coding prowess!

Frequently Asked Questions (FAQs)

1. What types of coding questions are asked in Deloitte interviews?

Deloitte typically asks questions on data structures, algorithms, string manipulation, sorting techniques, and dynamic programming.

2. What programming languages are allowed for Deloitte's coding assessments?

Candidates can usually choose from popular languages such as Python, Java, C++, and JavaScript.

3. Are coding assessments mandatory for all Deloitte roles?

Yes, for most technical roles, coding assessments are a crucial part of the recruitment process, especially for software engineering and consulting positions.

4. How should freshers prepare for Deloitte coding interviews?

Freshers should focus on practising coding problems and strengthen their understanding of data structures and algorithms.

5. Does Deloitte conduct technical interviews after the coding assessment?

Yes, candidates who pass the coding assessment typically go through further rounds of technical interviews to assess their deeper knowledge and problem-solving skills.

Suggested reads:

• TCS Digital Recruitment Process: Latest Updates & Tips for Freshers

• HCL Logical Reasoning Questions and Answers: Top 5 Sample MCQs

• HCL Aptitude Test: Top 5 Questions and Answers for Freshers (MCQs)

• Latest Capgemini English Test Questions and Answers for Freshers

• Deloitte Verbal Test: 5 Best Questions and Answers in MCQ format