Zoho Advanced Programming Round 2025

The Zoho Advanced Programming Round is an in-depth assessment aimed at evaluating a candidate's writing complex code that must be efficient, modular, and robust.

Let's explore the key areas covered in this assessment.

Zoho Advanced Programming Round - Overview

Here's an overview of the Zoho Advanced Programming Round:

Information	Detail
Total No of Sections	2
Total No of Questions	2
Total Time	60 minutes (shared)
Difficulty	Hard
Elimination Round	Yes

Zoho Advanced Programming Round Syllabus

Here's a snapshot of the Zoho Advanced Programming Round syllabus:

Programming Assessment Syllabus
1	Quality Modularity Boundary test cases Efficiency	1	60 minutes (shared)
2	Booking Availability checking Cancellation Prepare chart	1	60 minutes (shared)

Performance in the Advanced Programming round is important in the hiring process. Scores obtained in this round are considered for the final selection of the candidate. The languages considered are C++ or Java, depending on the Zoho.

Upon clearing this round, candidates proceed to a Technical Panel Interview, where they are questioned about the programs they wrote during the Advanced Programming round.

Practice Zoho Advanced Programming Questions

1. Write a function print_number_staircase(int n) that prints a pattern of numbers based on the input size n. The pattern is printed as a staircase, where each row starts with an incremented number and wraps around back to 1 when the number exceeds n.

C++

#include <iostream>
using namespace std;
void printNumberStaircase(int n) {
    for (int i = 1; i <= n; i++) {
        for (int j = i; j < i + n; j++) {
            cout << (j - 1) % n + 1 << " ";
        }
        cout << endl;
    }
}
int main() {
    printNumberStaircase(5);
    cout << endl;
    printNumberStaircase(3);
    return 0;
}

Java

public class NumberStaircase {
    public static void printNumberStaircase(int n) {
        for (int i = 1; i <= n; i++) {
            for (int j = i; j < i + n; j++) {
                System.out.print((j - 1) % n + 1 + " ");
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        printNumberStaircase(5);
        System.out.println();
        printNumberStaircase(3);
    }
}

Python

def print_number_staircase(n):
    for i in range(1, n + 1):
        row = []
        for j in range(i, i + n):
            row.append((j - 1) % n + 1)
        print(" ".join(map(str, row)))
print_number_staircase(5)
print()
print_number_staircase(3)

Explanation of logic:

Outer Loop (i): Iterates through each row from 1 to n.
Inner Loop (j): Generates numbers for each row starting from i and wrapping around when the number exceeds n.
(j - 1) % n + 1: Ensures numbers cycle back to 1 after n.
Print Numbers: Each number is printed followed by a space, and a newline is printed after completing the row.
Main Function: Demonstrates the function with test cases for n = 5 and n = 3.

Example Outputs:
For n = 5:

For n = 3:

1 2 3
2 3 1
3 1 2

2. Your task is to complete a function find_day(date, month, year) that takes three inputs: date, month, and year. The function should return the day of the week as a string (e.g., 'sunday', 'monday'). The function calculates the day of the week for the given date using the concept of odd days and leap years.

C++

#include <iostream>
#include <string>
using namespace std;
string find_day(int date, int month, int year) {
    string days[] = {"sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"};
    int month_days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    bool isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
    if (isLeap) month_days[1] = 29;
    int total_days = 0;
    total_days += (year - 1) * 365 + (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400;
    for (int i = 0; i < month - 1; i++) {
        total_days += month_days[i];
    }
    total_days += date;
    return days[total_days % 7];
}
int main() {
    cout << find_day(15, 8, 1947) << endl;
    cout << find_day(26, 1, 1950) << endl;
    return 0;
}

Java

public class FindDay {
    public static String find_day(int date, int month, int year) {
        String[] days = {"sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"};
        int[] month_days = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        boolean isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
        if (isLeap) month_days[1] = 29;
        int total_days = 0;
        total_days += (year - 1) * 365 + (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400;
        for (int i = 0; i < month - 1; i++) {
            total_days += month_days[i];
        }
        total_days += date;
        return days[total_days % 7];
    }
    public static void main(String[] args) {
        System.out.println(find_day(15, 8, 1947));
        System.out.println(find_day(26, 1, 1950));
    }
}

Python

def find_day(date, month, year):
    days = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"]
    month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    is_leap = (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
    if is_leap:
        month_days[1] = 29
    total_days = 0
    total_days += (year - 1) * 365 + (year - 1) // 4 - (year - 1) // 100 + (year - 1) // 400
    total_days += sum(month_days[:month - 1])
    total_days += date
    return days[total_days % 7]
print(find_day(15, 8, 1947))
print(find_day(26, 1, 1950))

Explanation of Logic:

Odd Days Concept: The day of the week repeats in cycles of 7.
Leap Year Handling: Leap years have an extra day in February.
Steps:
- Count days for complete years up to year - 1.
- Add days for complete months in the given year.
- Add the given date.
- Use modulo 7 to find the day of the week.

Example Outputs:
For find_day(15, 8, 1947) the output is "friday".
For find_day(26, 1, 1950) the output is "thursday".

3. Your task is to complete a function is_valid_move(sourceRow, sourceCol, destRow, destCol, boardSize) that takes five inputs: the source position (sourceRow, sourceCol) of a queen, the destination position (destRow, destCol), and the size of the chessboard (boardSize). The function should return true if the move is valid for a chess queen, otherwise false.

C++

#include <iostream>
#include <cmath>
using namespace std;
bool is_valid_move(int sourceRow, int sourceCol, int destRow, int destCol, int boardSize) {
    if (destRow < 0 || destRow >= boardSize || destCol < 0 || destCol >= boardSize) {
        return false;
    }
    if (sourceRow == destRow || sourceCol == destCol || abs(sourceRow - destRow) == abs(sourceCol - destCol)) {
        return true;
    }
    return false;
}
int main() {
    cout << is_valid_move(2, 1, 1, 0, 5) << endl;
    cout << is_valid_move(2, 1, 4, 2, 5) << endl;
    cout << is_valid_move(2, 1, 3, 3, 5) << endl;
    return 0;
}

Java

public class ChessQueen {
    public static boolean is_valid_move(int sourceRow, int sourceCol, int destRow, int destCol, int boardSize) {
        if (destRow < 0 || destRow >= boardSize || destCol < 0 || destCol >= boardSize) {
            return false;
        }
        if (sourceRow == destRow || sourceCol == destCol || Math.abs(sourceRow - destRow) == Math.abs(sourceCol - destCol)) {
            return true;
        }
        return false;
    }
    public static void main(String[] args) {
        System.out.println(is_valid_move(2, 1, 1, 0, 5));
        System.out.println(is_valid_move(2, 1, 4, 2, 5));
        System.out.println(is_valid_move(2, 1, 3, 3, 5));
    }
}

Python

def is_valid_move(sourceRow, sourceCol, destRow, destCol, boardSize):
    if destRow < 0 or destRow >= boardSize or destCol < 0 or destCol >= boardSize:
        return False
    if sourceRow == destRow or sourceCol == destCol or abs(sourceRow - destRow) == abs(sourceCol - destCol):
        return True
    return False
print(is_valid_move(2, 1, 1, 0, 5))
print(is_valid_move(2, 1, 4, 2, 5))
print(is_valid_move(2, 1, 3, 3, 5))

Explanation of Logic:

Check Board Bounds: Ensure the destination is within the board dimensions.
Queen's Movement Rules:
- Horizontal Move: sourceRow == destRow
- Vertical Move: sourceCol == destCol
- Diagonal Move: abs(sourceRow - destRow) == abs(sourceCol - destCol)
Return Results: If any condition is met, return true; otherwise, return false.

Example Outputs:
For is_valid_move(2, 1, 1, 0, 5) the output is true.
For is_valid_move(2, 1, 4, 2, 5) the output is true.
For is_valid_move(2, 1, 3, 3, 5) the output is false.

4. Write a program to generate a numeric diamond pattern. The program takes a single input n (number of rows for the upper triangle). The pattern consists of two parts:
Upper Triangle: Starting from 1, each row prints numbers in descending order, aligned in a triangular shape, with spaces at the beginning of each row to form the diamond structure.
Lower Triangle: The numbers continue from the last row of the upper triangle, decreasing in size and aligned to mirror the upper triangle.

C++

#include <iostream>
#include <iomanip>
using namespace std;
void numeric_diamond(int n) {
    int current = 1;
    // Upper Triangle
    for (int i = 1; i <= n; ++i) {
        cout << string(n - i, ' ');
        int temp = current + i - 1;
        for (int j = 0; j < i; ++j) {
            cout << temp--;
            if (j < i - 1) cout << " ";
        }
        current += i;
        cout << endl;
    }
    current -= n;
    // Lower Triangle
    for (int i = n; i >= 1; --i) {
        cout << string(n - i, ' ');
        int temp = current + i - 1;
        for (int j = 0; j < i; ++j) {
            cout << temp--;
            if (j < i - 1) cout << " ";
        }
        current -= i;
        cout << endl;
    }
}
int main() {
    int n = 4;
    numeric_diamond(n);
    return 0;
}

Java

public class NumericDiamond {
    public static void numericDiamond(int n) {
        int current = 1;
        for (int i = 1; i <= n; i++) {
            for (int space = 1; space <= n - i; space++) {
                System.out.print(" ");
            }
            int temp = current + i - 1;
            for (int j = 0; j < i; j++) {
                System.out.print(temp--);
                if (j < i - 1) System.out.print(" ");
            }
            current += i;
            System.out.println();
        }
        current -= n;
        for (int i = n; i >= 1; i--) {
            for (int space = 1; space <= n - i; space++) {
                System.out.print(" ");
            }
            int temp = current + i - 1;
            for (int j = 0; j < i; j++) {
                System.out.print(temp--);
                if (j < i - 1) System.out.print(" ");
            }
            current -= i;
            System.out.println();
        }
    }
    public static void main(String[] args) {
        int n = 4;
        numericDiamond(n);
    }
}

Python

def numeric_diamond(n):
    current = 1
    for i in range(1, n + 1):
        print(" " * (n - i), end="")
        temp = current + i - 1
        for j in range(i):
            print(temp, end="")
            temp -= 1
            if j < i - 1:
                print(" ", end="")
        current += i
        print()
    current -= n
    for i in range(n, 0, -1):
        print(" " * (n - i), end="")
        temp = current + i - 1
        for j in range(i):
            print(temp, end="")
            temp -= 1
            if j < i - 1:
                print(" ", end="")
        current -= i
        print()

numeric_diamond(4)

Explanation of Logic:

Upper Triangle:
- Numbers are printed in descending order, starting from current.
- Each row increases in size, and the number of spaces decreases.
- current is updated after each row.
Lower Triangle:
- Mirrors the upper triangle with numbers decreasing.
- current is decremented after printing each row.

Example Output for n = 4:

5. Write a program that generates a "snake pattern" for an n x n grid. The pattern alternates direction for each row, with odd rows incrementing and even rows decrementing.

C++

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

void snake_pattern(int n) {
    int number = 1;
    for (int i = 0; i < n; i++) {
        if (i % 2 == 0) {
            // Print row left to right
            for (int j = 0; j < n; j++) {
                cout << setw(4) << number++;
            }
        } else {
            // Print row right to left
            int start = number + n - 1;
            for (int j = 0; j < n; j++) {
                cout << setw(4) << start--;
            }
            number += n;
        }
        cout << endl;
    }
}

int main() {
    int n = 5;
    snake_pattern(n);
    return 0;
}

Java

public class SnakePattern {
    public static void snakePattern(int n) {
        int number = 1;
        for (int i = 0; i < n; i++) {
            if (i % 2 == 0) {
                // Print row left to right
                for (int j = 0; j < n; j++) {
                    System.out.printf("%4d", number++);
                }
            } else {
                // Print row right to left
                int start = number + n - 1;
                for (int j = 0; j < n; j++) {
                    System.out.printf("%4d", start--);
                }
                number += n;
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        int n = 4;
        snakePattern(n);
    }
}

Python

def snake_pattern(n):
    number = 1
    for i in range(n):
        if i % 2 == 0:
            # Print row left to right
            for j in range(n):
                print(f"{number:4}", end="")
                number += 1
        else:
            # Print row right to left
            start = number + n - 1
            for j in range(n):
                print(f"{start:4}", end="")
                start -= 1
            number += n
        print()

# Test the function
snake_pattern(5)

Explanation:

Odd Rows (Left-to-Right):
- The numbers are printed sequentially from number.
- The value of number is incremented with each step.
Even Rows (Right-to-Left):
- Calculate the starting number for the row as number + n - 1.
- Print numbers in reverse order, decrementing from the starting value.
- Increment number by n after processing the row.

Example Output for n = 4:

 1   2   3   4  
 8   7   6   5  
 9  10  11  12  
16  15  14  13

Example Output for n = 5:

 1   2   3   4   5  
10   9   8   7   6  
11  12  13  14  15  
20  19  18  17  16  
21  22  23  24  25

Frequently Asked QuestionsFAQ

What is the advanced programming round in Zoho

The Advanced Programming Round at Zoho is designed to assess candidates' skills in writing complex code that must be efficient, modular, and robust.

Is the Zoho advanced programming a compulsory round for all candidates?

Yes, Zoho advanced programming round is compulsory for all candidates.

What languages can be used for the Zoho advanced programming round?

The languages allowed for the Zoho advanced programming round are C++ or Java.

How many questions are there in the Zoho advanced programming round?

There are 2 questions in the Zoho advanced programming round.

How much time is given to complete the Zoho advanced programming round?

Candidates are given a total of 60 minutes to complete both questions in Zoho advanced programming round.

What is the difficulty level of the Zoho advanced programming round?

The difficulty level of the Zoho advanced programming round is considered hard.