Zscaler Coding Questions 2025: Recruitment Process, Eligibility Criteria

Here is the Zscaler recruitment process:

1. Online Coding Assessment: A HackRank online coding assessment that tests your programming and problem-solving skills.

2. Pre-Placement Talk: This is an introductory session in which Zscaler explains the company culture, job roles, and recruitment process.

3. Technical Rounds of Interview (2-3 Rounds): You will be examined on data structures, algorithms, and programming, with some specifications on languages like C (for Dev roles).

4. HR Round: Final interview round that tests behavioral questions, culture fit, and salary negotiation.

Here are the top 10 common coding questions asked in zscaler:

Problem Statement 1

You are given an array of size N-1 containing integers from 1 to N. One number is missing. Your task is to find and return the missing number.

C++

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int sum = (n * (n + 1)) / 2;
    int arr_sum = 0;
    for (int i = 0; i < n - 1; i++) {
        int num;
        cin >> num;
        arr_sum += num;
    }
    cout << sum - arr_sum << endl;
    return 0;
}

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int sum = (n * (n + 1)) / 2;
        int arr_sum = 0;
        for (int i = 0; i < n - 1; i++) {
            arr_sum += sc.nextInt();
        }
        System.out.println(sum - arr_sum);
    }
}

Python

n = int(input())
total_sum = n * (n + 1) // 2
arr_sum = sum(int(input()) for _ in range(n - 1))
print(total_sum - arr_sum)

Explanation

The code calculates the sum of numbers from 1 to N using the formula N*(N+1)/2. Then, it computes the sum of the given array. The missing number is found by subtracting the array sum from the total sum.

Input

5
1 2 4

Output

3

Problem Statement 2

There are some groups of devils. People are represented as a string where "@" and "$" are devils and "P" is a person. The devils make people their group, and the largest group is the one that will be killed. Determine how many groups can be formed based on this representation.

C++

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

int main() {
    string s;
    cin >> s; // Read the input string

    int groups = 1; // Start with one group by default

    // Loop through the string starting from the second character
    for (int i = 1; i < s.length(); i++) {
        // Check if the current character is '@' or '$'
        if (s[i] == '@' || s[i] == '$') {
            // If the previous character was not '@' or '$', this starts a new group
            if (s[i - 1] != '@' && s[i - 1] != '$') {
                groups++;
            }
        }
    }

    cout << groups << endl; // Output the total number of groups

    return 0;
}

Java

import java.util.Scanner;

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

        String s = sc.nextLine(); // Read the input string
        int groups = 1; // At least one group exists initially

        // Loop through the string from the second character
        for (int i = 1; i < s.length(); i++) {
            // If the current character is '@' or '$'
            if (s.charAt(i) == '@' || s.charAt(i) == '$') {
                // And the previous character is not '@' or '$'
                if (s.charAt(i - 1) != '@' && s.charAt(i - 1) != '$') {
                    groups++; // Count it as a new group
                }
            }
        }

        System.out.println(groups); // Print the total number of groups
    }
}

Python

s = input()  # Read the input string
groups = 1   # Start with one group by default

# Go through the string from the second character onward
for i in range(1, len(s)):
    # If current character is '@' or '$'
    if s[i] == '@' or s[i] == '$':
        # And the character before it is not '@' or '$'
        if s[i - 1] != '@' and s[i - 1] != '$':
            groups += 1  # A new group starts here

print(groups)  # Output the total number of groups

Explanation

It keeps a count of groups formed by consecutive @ or $ characters. It starts with the initial count of groups as 1. If the character in the string is @ or $ and the previous character is not @ or $, then a new group starts, increasing the count.

Input

PPPPPP@PPP@PP$PP

Output

7

Problem Statement 3

Raman plays a game where he wins or loses coins in each step. To avoid going into credit, help him find the minimum starting coins required to ensure he never runs out of money.

C++

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int a[n], sum = 0, minAmount = 0;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        sum += a[i];
        if (sum < 1) {
            minAmount = max(minAmount, -sum + 1);
            sum = 0;
        }
    }
    cout << minAmount << endl;
    return 0;
}

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int sum = 0, minAmount = 0;
        for (int i = 0; i < n; i++) {
            int outcome = sc.nextInt();
            sum += outcome;
            if (sum < 1) {
                minAmount = Math.max(minAmount, -sum + 1);
                sum = 0;
            }
        }
        System.out.println(minAmount);
    }
}

Python

n = int(input())
outcomes = list(map(int, input().split()))
sum, minAmount = 0, 0
for outcome in outcomes:
    sum += outcome
    if sum < 1:
        minAmount = max(minAmount, -sum + 1)
        sum = 0
print(minAmount)

Explanation

The program calculates the minimum amount required to keep the total sum positive throughout the game. As each outcome is added to the total, if the sum falls below 1, it adjusts by ensuring the starting amount is enough to avoid a negative balance, resulting in a minimum of 7.

Input

4
2 -9 15 2

Output

7

Problem Statement 4

Compute number of borrow operation to subtract number2 from number1. Return "Not possible" if that is impossible.

C++

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

int main() {
    string s1, s2;
    cin >> s1 >> s2;
    if (stoi(s1) < stoi(s2)) {
        cout << "Impossible" << endl;
        return 0;
    }
    reverse(s1.begin(), s1.end());
    reverse(s2.begin(), s2.end());
    int borrowCount = 0, carry = 0;
    for (int i = 0; i < s1.length(); i++) {
        int digit1 = s1[i] - '0', digit2 = s2[i] - '0';
        if (digit1 < digit2 + carry) {
            borrowCount++;
            carry = 1;
        } else {
            carry = 0;
        }
    }
    cout << borrowCount << endl;
    return 0;
}

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s1 = sc.nextLine();
        String s2 = sc.nextLine();
        if (Integer.parseInt(s1) < Integer.parseInt(s2)) {
            System.out.println("Impossible");
            return;
        }
        s1 = new StringBuilder(s1).reverse().toString();
        s2 = new StringBuilder(s2).reverse().toString();
        int borrowCount = 0, carry = 0;
        for (int i = 0; i < s1.length(); i++) {
            int digit1 = s1.charAt(i) - '0', digit2 = s2.charAt(i) - '0';
            if (digit1 < digit2 + carry) {
                borrowCount++;
                carry = 1;
            } else {
                carry = 0;
            }
        }
        System.out.println(borrowCount);
    }
}

Python

s1, s2 = input(), input()
if int(s1) < int(s2):
    print("Impossible")
else:
    s1, s2 = s1[::-1], s2[::-1]
    borrowCount, carry = 0, 0
    for i in range(len(s1)):
        digit1, digit2 = int(s1[i]), int(s2[i])
        if digit1 < digit2 + carry:
            borrowCount += 1
            carry = 1
        else:
            carry = 0
    print(borrowCount)

Explanation

The code calculates the borrow operations required to subtract s2 from s1. The strings are reversed to simulate the subtraction from the least significant digit. The count of borrow is incremented each time there's a requirement for a borrow operation in subtraction. The final result is 2.

Input

754
658

Output

2

Problem Statement 5

Given the actions of a game in which Raman wins or loses coins, dictate the least that he should begin with so that he will not go into debt.

C++

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int sum = 0, minCoins = 0;
    for (int i = 0; i < n; i++) {
        int change;
        cin >> change;
        sum += change;
        if (sum < 1) {
            minCoins = max(minCoins, -sum + 1);
            sum = 0;
        }
    }
    cout << minCoins << endl;
    return 0;
}

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int sum = 0, minCoins = 0;
        for (int i = 0; i < n; i++) {
            int change = sc.nextInt();
            sum += change;
            if (sum < 1) {
                minCoins = Math.max(minCoins, -sum + 1);
                sum = 0;
            }
        }
        System.out.println(minCoins);
    }
}

Python

n = int(input())
steps = list(map(int, input().split()))
sum, minCoins = 0, 0
for change in steps:
    sum += change
    if sum < 1:
        minCoins = max(minCoins, -sum + 1)
        sum = 0
print(minCoins)

Explanation

The program calculates the minimum amount of coins to avoid running losses. It resets the total when it is processing changes. When the total becomes negative, it rebalances in order to have sufficient funds. The minimum amount of coins required here is 7.

Input

4
2 -9 15 2

Output

7

Problem Statement 6

A prime number is called a "good prime number" if the sum of its digits is also a prime number. Given an integer N, find the Kth good prime number greater than N.

C++

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

bool isPrime(int n) {
    if (n <= 1) return false;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) return false;
    }
    return true;
}

int solve(int N, int K) {
    int count = 0;
    for (int i = N + 1; count < K; i++) {
        if (isPrime(i)) {
            int sum = 0, temp = i;
            while (temp > 0) {
                sum += temp % 10;
                temp /= 10;
            }
            if (isPrime(sum)) {
                count++;
                if (count == K) return i;
            }
        }
    }
    return -1;
}

int main() {
    int N, K;
    cin >> N >> K;
    cout << solve(N, K) << endl;
    return 0;
}

Java

import java.util.*;

public class Main {
    static boolean isPrime(int n) {
        if (n <= 1) return false;
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0) return false;
        }
        return true;
    }

    static int solve(int N, int K) {
        int count = 0;
        for (int i = N + 1; count < K; i++) {
            if (isPrime(i)) {
                int sum = 0, temp = i;
                while (temp > 0) {
                    sum += temp % 10;
                    temp /= 10;
                }
                if (isPrime(sum)) {
                    count++;
                    if (count == K) return i;
                }
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int K = sc.nextInt();
        System.out.println(solve(N, K));
    }
}

Python

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def solve(N, K):
    count = 0
    i = N + 1
    while count < K:
        if is_prime(i):
            digit_sum = sum(map(int, str(i)))
            if is_prime(digit_sum):
                count += 1
                if count == K:
                    return i
        i += 1
    return -1

N = int(input())
K = int(input())
print(solve(N, K))

Explanation

The program finds the K-th prime number greater than N such that the sum of its digits is also prime. In this case, for N = 10 and K = 3, the program checks consecutive primes after 10. The 3rd prime whose digit sum is prime is 31.

Input

10
3

Output

31

Problem Statement 7

Verify if two strings are anagrams. Two strings are anagrams if they contain the same characters in any order with repetition.

C++

#include <iostream>
#include <algorithm>
using namespace std;

bool areAnagrams(string s1, string s2) {
    sort(s1.begin(), s1.end());
    sort(s2.begin(), s2.end());
    return s1 == s2;
}

int main() {
    string s1, s2;
    cin >> s1 >> s2;
    cout << (areAnagrams(s1, s2) ? "Yes" : "No") << endl;
    return 0;
}

Java

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static boolean areAnagrams(String s1, String s2) {
        char[] arr1 = s1.toCharArray();
        char[] arr2 = s2.toCharArray();
        Arrays.sort(arr1);
        Arrays.sort(arr2);
        return Arrays.equals(arr1, arr2);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s1 = sc.next();
        String s2 = sc.next();
        System.out.println(areAnagrams(s1, s2) ? "Yes" : "No");
    }
}

Python

def are_anagrams(s1, s2):
    return sorted(s1) == sorted(s2)

s1, s2 = input(), input()
print("Yes" if are_anagrams(s1, s2) else "No")

Explanation

The program verifies whether two strings are anagrams or not. Two strings are referred to as anagrams if they contain the same characters, but in different places. In this instance, "listen" and "silent" contain the same characters, and therefore are anagrams, and the output will be "Yes".

Input

listen
silent

Output

Yes

Problem Statement 8

Check if a given string is a palindrome. A palindrome is a word, phrase, or sequence that reads the same backward as forward.

C++

#include <iostream>
using namespace std;

bool isPalindrome(string s) {
    int start = 0, end = s.length() - 1;
    while (start < end) {
        if (s[start] != s[end]) return false;
        start++;
        end--;
    }
    return true;
}

int main() {
    string s;
    cin >> s;
    cout << (isPalindrome(s) ? "Yes" : "No") << endl;
    return 0;
}

Java

import java.util.Scanner;

public class Main {
    static boolean isPalindrome(String s) {
        int start = 0, end = s.length() - 1;
        while (start < end) {
            if (s.charAt(start) != s.charAt(end)) return false;
            start++;
            end--;
        }
        return true;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        System.out.println(isPalindrome(s) ? "Yes" : "No");
    }
}

Python

def is_palindrome(s):
    return s == s[::-1]

s = input()
print("Yes" if is_palindrome(s) else "No")

Explanation

The program checks whether a given string is a palindrome. A palindrome is a word that reads the same forward and backward. The function compares characters from both ends of the string, moving towards the center. If all characters match, the string is a palindrome, and the program prints "Yes".

Input

madam

Output

Yes

Problem Statement 9

Write a program that counts the number of vowels in a given string. The vowels are 'a', 'e', 'i', 'o', 'u' (case-insensitive).

C++

#include <iostream>
using namespace std;

int countVowels(string s) {
    int count = 0;
    for (char c : s) {
        if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') count++;
    }
    return count;
}

int main() {
    string s;
    cin >> s;
    cout << countVowels(s) << endl;
    return 0;
}

Java

import java.util.Scanner;

public class Main {
    static int countVowels(String s) {
        int count = 0;
        for (char c : s.toCharArray()) {
            if ("aeiou".indexOf(c) != -1) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        System.out.println(countVowels(s));
    }
}

Python

def count_vowels(s):
    return sum(1 for c in s if c in 'aeiou')

s = input()
print(count_vowels(s))

Explanation

The program counts the number of vowels in the given string. It iterates through each character in the string, checking if it is one of the vowels ('a', 'e', 'i', 'o', 'u'). If it is, the counter is incremented. Finally, the result (vowel count) is printed.

Input

hello

Output

2

Problem Statement 10

Write a program to calculate the power of a number using a loop (without using the built-in pow function).

C++

#include <iostream>
using namespace std;

int main() {
    int base, exponent;
    cin >> base >> exponent;

    int result = 1;

    for (int i = 1; i <= exponent; i++) {
        result *= base;
    }

    cout << result << endl;
    return 0;
}

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int base = sc.nextInt();
        int exponent = sc.nextInt();
        
        int result = 1;

        for (int i = 1; i <= exponent; i++) {
            result *= base;
        }
        
        System.out.println(result);
    }
}

Python

# Take input
base, exponent = map(int, input().split())

# Initialize result to 1
result = 1

# Calculate power using loop
for _ in range(exponent):
    result *= base

# Output the result
print(result)

Explanation

The program calculates the power of a number by multiplying the base by itself for the number of times specified by the exponent using a loop. It initializes the result to 1 and multiplies it by the base in each loop iteration. Finally, it outputs the calculated result.

Input

2 3 

Output

8

Here are the tips to clear Zscaler coding rounds:

1. DSA Fundamentals: Cover all Data Structures & Algorithms, concentrating mainly on arrays, linked lists, trees, graphs, and dynamic programming.

2. Problem-Solving Practice: Review problems regularly on LeetCode, HackerRank, and Codeforces platforms.

3. Time Management: Learn to solve problems within the time limit. Practice under pressure.

4. Language Skills: Dev roles require a good command of C, and DevTest requires some comfort with C/C++ and Java.

5. Understand Problem Patterns: Identify common algorithmic patterns like sliding windows, backtracking, etc.

6. Explain Your Approach: Before coding, you must clearly share your thought process.

7. Mock Interviews: Practice interviews to become faster, more accurate, and more confident in conducting actual interviews.

8. Review Complexity: Consider your solutions' time and space complexity (Big O notation).

In conclusion, getting through Zscaler's coding rounds requires a good grasp of problem-solving's demand in programming with languages like C and Java (for Dev roles). A good understanding of concepts and zeal dedicated to regular practice can get one to the desired place with Zscaler through effective preparation. Calm down, think logically, and communicate clearly during the interview process.

1. What Questions Are Asked in a Coding Test?

Questions in Zscaler coding tests focus on data structures and algorithms. Expect some questions on arrays (find missing numbers), linked lists (detect cycles), trees (DFS/BFS), and graphs (shortest path). These questions test for the efficiency of problem-solving.

2. Is a Zscaler Interview Hard?

Zscaler interviews are rated as tough because of a strong focus on data structures, algorithms, and system design. They test your problem-solving abilities, coding speed, and a bit of logical reasoning pressure; this makes preparation important. One has to practice repeatedly tackling complex questions with some ease.

3. How Many Coding Questions Are in a 1-Hour Interview?

Generally, the Zscaler interview includes two to three coding questions related to the effectiveness of algorithms, data structures, and problem-solving. Hence, the candidate must focus on writing quick, efficient code to be tested within one hour.

4. What Is the Passing CGPA in Zscaler?

Zscaler generally considers candidates with a minimum CGPA of 7.5 to 8.0 (or equivalent). While CGPA is important, Zscaler prioritises problem-solving skills, coding proficiency, and technical knowledge. A high CGPA goes a long way in your direction, but it is not the only criterion.