🪔 Diwali offer: from ₹99 till 8 NovSee prices →

Wipro coding questions (2026): practice problems with solutions

Updated 17 October 2026

Eight practice problems in the style of the coding questions students report from Wipro's fresher hiring: arrays, strings, number logic and grids. Each one has the idea in plain words, a solution in Python, C++ and Java that we ran against the examples and extra edge cases, and its time and space complexity.

We wrote every problem ourselves to match the common question types, so these aren't official Wipro questions. Use them to learn the patterns, then take the real test on your own.

The problems

  1. Which buildings can see the sunset?Arrays · Easy
  2. Find the missing ticketArrays · Maths · Easy
  3. Keep only the first copy of each letterStrings · Easy
  4. Does the sentence read the same backwards?Strings · Two pointers · Easy
  5. Add the digits until one is leftMaths · Strings · Easy
  6. Count the carriesMaths · Strings · Medium
  7. Read the grid in a spiralMatrices · Medium
  8. Turn a picture a quarter turnMatrices · Easy

What Wipro's own hiring pages say

Wipro lists its fresher programmes on its careers site; the details are on its campus hiring pages. Those pages are for earlier batches (2023 for Elite, 2025 for Turbo and WILP), and no page for the 2026 or 2027 batch was up when we checked, so treat these as the most recent official details, not the next drive's.

ProgrammeForOnline assessment
Elite National Talent Hunt (2023 page)B.E. or B.Tech (or a 5-year integrated M.E. or M.Tech), most branches. Role: Project Engineer, ₹3,50,000 joining compensation80 minutes: verbal, analytical, quantitative and written communication, followed by coding
Turbo (2025 page)B.E. or B.Tech in CS, IT and circuital branches at 46 premier institutes. Role: Project Engineer, ₹5.5 lakh CTC plus a ₹1 lakh retention bonusAptitude (verbal, quantitative, logical), coding in C, C++, Java or Python, and a written communication test; then a voice assessment
WILP (2025 page)BCA or B.Sc graduates (CS, IT, Maths, Statistics, Electronics or Physics) with core Maths. Role: Scholar Trainee, from ₹15,000 a month plus a ₹75,000 joining bonus; Wipro sponsors an M.Tech80 minutes (verbal, analytical, quantitative, written communication), then a 20-minute voice assessment

Sources: Wipro's early careers page and its campus pages for Elite National Talent Hunt, Turbo and WILP. Checked on 17 October 2026. Rules change with each drive, so check the current page before you apply.

How to practise with this page

1Which buildings can see the sunset?

ArraysEasy

N buildings stand in a row, listed from left to right, and the sun sets on the right. A building can see the sunset if it is taller than every building to its right, so the last building always can. A building of the same height in the way blocks the view. Print the heights of the buildings that can see the sunset, from left to right.

Input
N (1 ≤ N ≤ 105), then N heights, each from 1 to 109.
Output
The heights of the buildings that can see the sunset, from left to right, separated by spaces.

Example input

7
4 9 3 7 2 5 1

Output

9 7 5 1

9, 7, 5 and the last building, 1, are each taller than everything to their right. The 4 is hidden by the 9, the 3 by the 7, and the 2 by the 5.

Approach

Checking every building against all the buildings to its right takes O(N²) steps, too slow for 105. Walk from the right instead, and remember tallest, the tallest building seen so far. A building can see the sunset exactly when it is taller than tallest, and then it becomes the new tallest.

This collects the answer from right to left, so reverse it before printing. Compare with "taller than" (>), not "at least as tall" (≥), so that a building of the same height counts as blocking the view.

Solution

Python
import sys

data = list(map(int, sys.stdin.read().split()))
n, heights = data[0], data[1:]

can_see = []
tallest = 0                       # tallest building to the right so far
for h in reversed(heights[:n]):   # walk from the sunset side
    if h > tallest:
        can_see.append(h)
        tallest = h
print(*reversed(can_see))         # back to left-to-right order
C++
#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> h(n);
    for (int &x : h) cin >> x;

    vector<int> canSee;
    int tallest = 0;                      // tallest building to the right so far
    for (int i = n - 1; i >= 0; i--) {    // walk from the sunset side
        if (h[i] > tallest) {
            canSee.push_back(h[i]);
            tallest = h[i];
        }
    }

    for (int i = (int)canSee.size() - 1; i >= 0; i--)   // back to left-to-right order
        cout << canSee[i] << (i > 0 ? ' ' : '\n');
}
Java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] h = new int[n];
        for (int i = 0; i < n; i++) h[i] = sc.nextInt();

        int[] canSee = new int[n];
        int count = 0, tallest = 0;            // tallest building to the right so far
        for (int i = n - 1; i >= 0; i--) {     // walk from the sunset side
            if (h[i] > tallest) {
                canSee[count++] = h[i];
                tallest = h[i];
            }
        }

        StringBuilder out = new StringBuilder();
        for (int i = count - 1; i >= 0; i--)   // back to left-to-right order
            out.append(canSee[i]).append(i > 0 ? " " : "\n");
        System.out.print(out);
    }
}

Time: O(N) · Extra space: O(N) for the answer

2Find the missing ticket

ArraysMathsEasy

A show sold N tickets, numbered 1 to N. At the gate, every ticket except one was collected, in no particular order. Given the numbers on the N − 1 collected tickets, find the number of the missing one.

Input
N (2 ≤ N ≤ 105), then N − 1 different numbers, each from 1 to N.
Output
The number of the missing ticket.

Example input

6
3 1 6 2 5

Output

4

Tickets 1, 2, 3, 5 and 6 were collected, so 4 is missing.

Approach

Sorting the tickets and looking for the gap works, in O(N log N). A formula is quicker: all N tickets add up to 1 + 2 + … + N = N(N + 1) / 2. Take every collected ticket away from that total, and what's left is the missing number.

When N is 105, the total is about 5 × 109, too big for an int, so use long long in C++ or long in Java. (A trick that avoids big numbers: XOR all the numbers from 1 to N together with all the collected ones. Each pair cancels out, leaving the missing number.)

Solution

Python
import sys

data = list(map(int, sys.stdin.read().split()))
n, tickets = data[0], data[1:]

expected = n * (n + 1) // 2              # 1 + 2 + ... + n
print(expected - sum(tickets[:n - 1]))   # what's left is the missing ticket
C++
#include <iostream>
using namespace std;

int main() {
    long long n;
    cin >> n;

    long long left = n * (n + 1) / 2;   // 1 + 2 + ... + n, up to about 5 x 10^9
    for (long long i = 0; i < n - 1; i++) {
        long long t;
        cin >> t;
        left -= t;                      // take away every ticket that was collected
    }
    cout << left << '\n';               // what's left is the missing ticket
}
Java
import java.util.*;

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

        long left = n * (n + 1) / 2;   // 1 + 2 + ... + n, up to about 5 x 10^9
        for (long i = 0; i < n - 1; i++)
            left -= sc.nextLong();     // take away every ticket that was collected
        System.out.println(left);      // what's left is the missing ticket
    }
}

Time: O(N) · Extra space: O(1) beyond the input

3Keep only the first copy of each letter

StringsEasy

Given a word, remove every letter that has already appeared earlier in the word, so only the first copy of each letter stays. The letters that stay keep their original order.

Input
One word of 1 to 105 small letters (a to z).
Output
The word after the repeats are removed.

Example 1 input

programming

Output

progamin

Example 2 input

banana

Output

ban

In programming, the second r, the second m and the last g have all appeared before, so they go. In banana, only b, a and n are new.

Approach

Keep 26 true/false flags, one per letter, that say whether you've seen the letter yet. Walk through the word: if a letter hasn't been seen, add it to the answer and set its flag; if it has, skip it. The Python version uses a set for the same job.

Because there are only 26 small letters, the answer is never longer than 26 letters, however long the word is.

Solution

Python
import sys

word = sys.stdin.readline().strip()

seen = set()
kept = []
for ch in word:
    if ch not in seen:   # the first time we meet this letter
        seen.add(ch)
        kept.append(ch)
print("".join(kept))
C++
#include <iostream>
#include <string>
using namespace std;

int main() {
    string word, kept;
    cin >> word;

    bool seen[26] = {false};
    for (char c : word) {
        if (!seen[c - 'a']) {   // the first time we meet this letter
            seen[c - 'a'] = true;
            kept += c;
        }
    }
    cout << kept << '\n';
}
Java
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String word = br.readLine().trim();

        boolean[] seen = new boolean[26];
        StringBuilder kept = new StringBuilder();
        for (char c : word.toCharArray()) {
            if (!seen[c - 'a']) {   // the first time we meet this letter
                seen[c - 'a'] = true;
                kept.append(c);
            }
        }
        System.out.println(kept);
    }
}

Time: O(L), where L is the length of the word · Extra space: O(1): just 26 flags

4Does the sentence read the same backwards?

StringsTwo pointersEasy

A sentence is a mirror sentence if its letters and digits read the same from left to right as from right to left. Ignore spaces, punctuation and every other character, and treat capital and small letters as the same. Print YES if the sentence is a mirror sentence and NO if it isn't.

Input
One line of 1 to 105 characters: letters, digits, spaces and punctuation. It has at least one letter or digit.
Output
YES or NO.

Example 1 input

Was it a car or a cat I saw?

Output

YES

Example 2 input

Hello, world

Output

NO

Without the spaces and the question mark, the first sentence is wasitacaroracatisaw, which reads the same both ways. The second starts with h but ends with d.

Approach

Put one marker at each end of the line. Move the left marker right and the right marker left, skipping anything that isn't a letter or a digit. Whenever both markers sit on a letter or digit, compare them as small letters: if they differ, the answer is NO. If the markers meet without a mismatch, the answer is YES.

The Python version takes a shortcut: it keeps only the letters and digits, in small letters, and checks that the list equals its own reverse. Remember that digits count too: 0P is not a mirror sentence, because 0 and p are different characters.

Solution

Python
import sys

line = sys.stdin.readline()

chars = [ch.lower() for ch in line if ch.isalnum()]   # letters and digits only
print("YES" if chars == chars[::-1] else "NO")
C++
#include <cctype>
#include <iostream>
#include <string>
using namespace std;

int main() {
    string s;
    getline(cin, s);

    int i = 0, j = (int)s.size() - 1;   // one marker at each end
    bool mirror = true;
    while (i < j) {
        if (!isalnum((unsigned char)s[i])) {
            i++;                        // skip spaces and punctuation
        } else if (!isalnum((unsigned char)s[j])) {
            j--;
        } else if (tolower((unsigned char)s[i]) != tolower((unsigned char)s[j])) {
            mirror = false;
            break;
        } else {
            i++;                        // this pair matches, move both inwards
            j--;
        }
    }
    cout << (mirror ? "YES" : "NO") << '\n';
}
Java
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        if (s == null) s = "";

        int i = 0, j = s.length() - 1;   // one marker at each end
        boolean mirror = true;
        while (i < j) {
            char a = s.charAt(i), b = s.charAt(j);
            if (!Character.isLetterOrDigit(a)) {
                i++;                     // skip spaces and punctuation
            } else if (!Character.isLetterOrDigit(b)) {
                j--;
            } else if (Character.toLowerCase(a) != Character.toLowerCase(b)) {
                mirror = false;
                break;
            } else {
                i++;                     // this pair matches, move both inwards
                j--;
            }
        }
        System.out.println(mirror ? "YES" : "NO");
    }
}

Time: O(L), where L is the length of the line · Extra space: O(1) in C++ and Java (the Python version makes a copy, so O(L))

5Add the digits until one is left

MathsStringsEasy

Take a number and replace it with the sum of its digits. Keep doing this until only one digit is left. Print that digit and the number of rounds it took. A number that already has one digit takes 0 rounds.

Input
One whole number with 1 to 105 digits and no extra zeros at the front (it can be 0).
Output
Two numbers: the digit that is left, and the number of rounds.

Example input

9875

Output

2 3

9875 → 9 + 8 + 7 + 5 = 29 → 2 + 9 = 11 → 1 + 1 = 2. That's three rounds.

Approach

The number can have 100,000 digits, far too many for long long, so read it as text and add up its characters. After the first round the number is at most 9 × 100,000 = 900,000, so every later round is quick.

There is a shortcut for the digit alone: for a number above 0, it is 1 + (N − 1) mod 9 (called the digital root). But the shortcut doesn't tell you how many rounds it took, so here you still do the rounds.

Solution

Python
import sys

number = sys.stdin.read().split()[0]   # kept as text: it can have 100,000 digits

rounds = 0
while len(number) > 1:
    number = str(sum(int(d) for d in number))   # one round of adding the digits
    rounds += 1
print(number, rounds)
C++
#include <iostream>
#include <string>
using namespace std;

int main() {
    string number;
    cin >> number;   // kept as text: it can have 100,000 digits

    int rounds = 0;
    while (number.size() > 1) {
        long long sum = 0;
        for (char d : number) sum += d - '0';   // one round of adding the digits
        number = to_string(sum);
        rounds++;
    }
    cout << number << ' ' << rounds << '\n';
}
Java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String number = sc.next();   // kept as text: it can have 100,000 digits

        int rounds = 0;
        while (number.length() > 1) {
            long sum = 0;
            for (char d : number.toCharArray()) sum += d - '0';   // one round of adding the digits
            number = Long.toString(sum);
            rounds++;
        }
        System.out.println(number + " " + rounds);
    }
}

Time: O(L) for the first round, where L is the number of digits; the later rounds are tiny · Extra space: O(L) to hold the number

6Count the carries

MathsStringsMedium

When you add two numbers on paper, you add one column of digits at a time, starting from the right. When a column adds up to 10 or more, you write down its last digit and carry 1 to the next column. Given two numbers, count how many times you carry, including a carry out of the leftmost column.

Input
Two whole numbers A and B, separated by a space or a new line. Each has 1 to 105 digits and no extra zeros at the front (either can be 0).
Output
The number of carries.

Example 1 input

555 555

Output

3

Example 2 input

9999 1

Output

4

555 + 555: 5 + 5 = 10, then 5 + 5 + 1 = 11 twice, so there are three carries and the sum is 1110. 9999 + 1 carries in all four columns, giving 10000.

Approach

Read both numbers as text, since they can be very long. Walk from the right end of both at the same time, with carry starting at 0. In each column, add the two digits and the carry; a number that has run out of digits adds 0. If the column comes to 10 or more, set carry to 1 and count it; otherwise set it back to 0.

Two common slips: stopping when the shorter number runs out (9999 + 1 keeps carrying after the 1 is used up), and forgetting to add the carry from the column before.

Solution

Python
import sys

a, b = sys.stdin.read().split()   # kept as text: they can be very long

carry = carries = 0
i, j = len(a) - 1, len(b) - 1      # start from the rightmost column
while i >= 0 or j >= 0:
    column = carry
    if i >= 0:
        column += int(a[i])
    if j >= 0:
        column += int(b[j])        # a shorter number has no digit here, so it adds 0
    carry = 1 if column >= 10 else 0
    carries += carry
    i -= 1
    j -= 1
print(carries)
C++
#include <iostream>
#include <string>
using namespace std;

int main() {
    string a, b;
    cin >> a >> b;   // kept as text: they can be very long

    int carry = 0, carries = 0;
    int i = (int)a.size() - 1, j = (int)b.size() - 1;   // start from the rightmost column
    while (i >= 0 || j >= 0) {
        int column = carry;
        if (i >= 0) column += a[i] - '0';
        if (j >= 0) column += b[j] - '0';   // a shorter number has no digit here, so it adds 0
        carry = column >= 10 ? 1 : 0;
        carries += carry;
        i--;
        j--;
    }
    cout << carries << '\n';
}
Java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String a = sc.next(), b = sc.next();   // kept as text: they can be very long

        int carry = 0, carries = 0;
        int i = a.length() - 1, j = b.length() - 1;   // start from the rightmost column
        while (i >= 0 || j >= 0) {
            int column = carry;
            if (i >= 0) column += a.charAt(i) - '0';
            if (j >= 0) column += b.charAt(j) - '0';   // a shorter number has no digit here, so it adds 0
            carry = column >= 10 ? 1 : 0;
            carries += carry;
            i--;
            j--;
        }
        System.out.println(carries);
    }
}

Time: O(L), where L is the length of the longer number · Extra space: O(L) to hold the numbers

7Read the grid in a spiral

MatricesMedium

A grid of numbers has R rows and C columns. Starting at the top-left corner, read it in a clockwise spiral: along the top row to the right, down the right-hand column, back along the bottom row to the left, and up the left-hand column. Then do the same with the smaller grid left inside, and keep going until every number has been read exactly once. Print the numbers in that order.

Input
R and C (1 ≤ R, C ≤ 500), then R lines of C numbers each. Every number is between -109 and 109.
Output
All R × C numbers in spiral order, separated by spaces.

Example input

3 4
1 2 3 4
5 6 7 8
9 10 11 12

Output

1 2 3 4 8 12 11 10 9 5 6 7

The outer ring gives 1 2 3 4 along the top, 8 12 down the right, 11 10 9 along the bottom and 5 up the left. Only 6 and 7 are left inside.

Approach

Keep four borders: top, bottom, left and right, the rows and columns of the ring you're about to read. Read the four sides of the ring, then move every border one step inwards, and repeat while top ≤ bottom and left ≤ right.

The tricky part is a ring that is only one row or one column thick. Read the bottom row only if it isn't the same row as the top (top < bottom), and the left column only if it isn't the same column as the right (left < right). Otherwise those numbers get printed twice, so test your code on a 1 × 4 and a 4 × 1 grid.

Solution

Python
import sys

data = list(map(int, sys.stdin.read().split()))
rows, cols = data[0], data[1]
grid = [data[2 + r * cols: 2 + (r + 1) * cols] for r in range(rows)]

top, bottom, left, right = 0, rows - 1, 0, cols - 1   # the ring still to be read
order = []
while top <= bottom and left <= right:
    for c in range(left, right + 1):                  # top row, left to right
        order.append(grid[top][c])
    for r in range(top + 1, bottom + 1):              # right column, downwards
        order.append(grid[r][right])
    if top < bottom:                                  # bottom row, right to left
        for c in range(right - 1, left - 1, -1):
            order.append(grid[bottom][c])
    if left < right:                                  # left column, upwards
        for r in range(bottom - 1, top, -1):
            order.append(grid[r][left])
    top, bottom, left, right = top + 1, bottom - 1, left + 1, right - 1
print(*order)
C++
#include <iostream>
#include <vector>
using namespace std;

int main() {
    int rows, cols;
    cin >> rows >> cols;
    vector<vector<int>> g(rows, vector<int>(cols));
    for (auto &row : g)
        for (int &x : row) cin >> x;

    int top = 0, bottom = rows - 1, left = 0, right = cols - 1;   // the ring still to be read
    vector<int> order;
    while (top <= bottom && left <= right) {
        for (int c = left; c <= right; c++)         // top row, left to right
            order.push_back(g[top][c]);
        for (int r = top + 1; r <= bottom; r++)     // right column, downwards
            order.push_back(g[r][right]);
        if (top < bottom)                           // bottom row, right to left
            for (int c = right - 1; c >= left; c--)
                order.push_back(g[bottom][c]);
        if (left < right)                           // left column, upwards
            for (int r = bottom - 1; r > top; r--)
                order.push_back(g[r][left]);
        top++;                                      // move in to the next ring
        bottom--;
        left++;
        right--;
    }

    for (size_t i = 0; i < order.size(); i++)
        cout << order[i] << (i + 1 < order.size() ? ' ' : '\n');
}
Java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int rows = sc.nextInt(), cols = sc.nextInt();
        int[][] g = new int[rows][cols];
        for (int r = 0; r < rows; r++)
            for (int c = 0; c < cols; c++) g[r][c] = sc.nextInt();

        int top = 0, bottom = rows - 1, left = 0, right = cols - 1;   // the ring still to be read
        List<Integer> order = new ArrayList<>();
        while (top <= bottom && left <= right) {
            for (int c = left; c <= right; c++)         // top row, left to right
                order.add(g[top][c]);
            for (int r = top + 1; r <= bottom; r++)     // right column, downwards
                order.add(g[r][right]);
            if (top < bottom)                           // bottom row, right to left
                for (int c = right - 1; c >= left; c--)
                    order.add(g[bottom][c]);
            if (left < right)                           // left column, upwards
                for (int r = bottom - 1; r > top; r--)
                    order.add(g[r][left]);
            top++;                                      // move in to the next ring
            bottom--;
            left++;
            right--;
        }

        StringBuilder out = new StringBuilder();
        for (int i = 0; i < order.size(); i++)
            out.append(order.get(i)).append(i + 1 < order.size() ? " " : "\n");
        System.out.print(out);
    }
}

Time: O(R × C) · Extra space: O(R × C) for the grid

8Turn a picture a quarter turn

MatricesEasy

A black-and-white picture is stored as a grid of brightness values with R rows and C columns. Turn the picture 90 degrees clockwise (a quarter turn to the right) and print the new grid. The turned picture has C rows and R columns.

Input
R and C (1 ≤ R, C ≤ 500), then R lines of C numbers each, every number from 0 to 255.
Output
C lines, each with R numbers separated by spaces: the turned picture.

Example input

2 3
1 2 3
4 5 6

Output

4 1
5 2
6 3

The left column of the picture, 1 above 4, becomes the top row, read from the bottom up: 4 1.

Approach

Look at where each number goes. After a clockwise quarter turn, the first column becomes the top row, read from the bottom up; the second column becomes the second row, and so on. So row c of the answer is column c of the picture, read from the last row to the first.

In grid terms, turned[c][r] = picture[R − 1 − r][c]. You can print it straight away with two loops, without building the turned grid first. (For an anticlockwise turn, row c of the answer would be column C − 1 − c, read from the top down.)

Solution

Python
import sys

data = list(map(int, sys.stdin.read().split()))
rows, cols = data[0], data[1]
grid = [data[2 + r * cols: 2 + (r + 1) * cols] for r in range(rows)]

# Row c of the turned picture is column c of the old one, read from the bottom up.
for c in range(cols):
    print(*(grid[r][c] for r in range(rows - 1, -1, -1)))
C++
#include <iostream>
#include <vector>
using namespace std;

int main() {
    int rows, cols;
    cin >> rows >> cols;
    vector<vector<int>> g(rows, vector<int>(cols));
    for (auto &row : g)
        for (int &x : row) cin >> x;

    // Row c of the turned picture is column c of the old one, read from the bottom up.
    for (int c = 0; c < cols; c++)
        for (int r = rows - 1; r >= 0; r--)
            cout << g[r][c] << (r > 0 ? ' ' : '\n');
}
Java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int rows = sc.nextInt(), cols = sc.nextInt();
        int[][] g = new int[rows][cols];
        for (int r = 0; r < rows; r++)
            for (int c = 0; c < cols; c++) g[r][c] = sc.nextInt();

        // Row c of the turned picture is column c of the old one, read from the bottom up.
        StringBuilder out = new StringBuilder();
        for (int c = 0; c < cols; c++)
            for (int r = rows - 1; r >= 0; r--)
                out.append(g[r][c]).append(r > 0 ? " " : "\n");
        System.out.print(out);
    }
}

Time: O(R × C) · Extra space: O(R × C) for the picture

Questions

How many coding questions are in Wipro's test?

Wipro's pages don't say. The Elite National Talent Hunt page (2023 batch) describes an 80-minute online assessment of verbal, analytical, quantitative and written communication skills, followed by coding. The Turbo page (2025 batch) lists aptitude, coding and a written communication test.

Which languages can I code in for Wipro?

Wipro's Turbo page lists C, C++, Java and Python. The solutions here are in Python, C++ and Java.

What marks do I need for Wipro?

Its pages ask for at least 60% (or 6.0 CGPA) in Class 10, Class 12 and graduation, with at most one backlog at the time of the assessment, cleared by the final semester.

Are these real Wipro questions?

No. We wrote them ourselves in the style of the question types students commonly report: arrays, strings, number logic and grids. Learning these patterns helps far more than memorising answers.

Were these solutions tested?

Yes. We ran every solution in Python, C++ and Java on the examples, on extra edge cases, on random inputs checked against a slow but simple answer, and on the largest inputs the limits allow.

More placement prep