Wipro NLTH Coding Questions 2026: Automata Round Guide

Wipro NLTH’s Automata round gives you two coding problems and 60 minutes, on a browser-based IDE that supports C, C++, Java, and Python.

This is the coding gate between an aptitude pass and a Wipro technical interview. Clearing it depends less on grinding hard DSA problems and more on being fluent with strings, arrays, and basic math at medium difficulty. The questions below are representative of the topic profile that the Automata test covers. None are sourced from Wipro’s proprietary question bank; they are practice problems built around the same problem types and difficulty level.

For the 2026 NLTH cycle, the round format stays the same: two problems, one 60-minute window. What has shifted is the competitive context behind it, which we cover in the salary and AI-skills sections at the end.

Wipro NLTH Eligibility for the 2026 Cycle

Wipro publishes eligibility criteria with each campus drive. The criteria below are consistent with drives run through 2025 and into the 2026 cycle. Confirm the exact requirements against your specific offer letter or drive notification.

Criterion	Requirement
Eligible degrees	B.E / B.Tech / M.E / M.Tech / MCA / M.Sc (CS or IT)
Minimum aggregate	60% or above in 10th, 12th, and all graduation semesters
Active backlogs	None at the time of application
Acceptable year gap	Maximum 1 year

The full NLTH pattern and syllabus covers the aptitude and verbal sections that precede the Automata round, including section-wise question counts and expected cut-off norms.

Automata Platform and Coding Round Format

Automata is Wipro’s browser-based coding environment. You write, compile, and run your code inside the browser. No local IDE or external editor is permitted during the test.

Structural facts about the round:

• 2 coding problems per candidate
• 60-minute window for both problems combined
• Languages supported: C, C++, Java, Python
• Partial scoring: marks are awarded for each test case your code passes; a partially working solution earns more than no submission at all
• Custom test input: you can run your own test cases before final submission to verify output

Typical difficulty sits at easy-to-medium on a standard DSA scale. Arrays, strings, and basic number theory cover the majority of what appears. Complex structures such as graphs, segment trees, or dynamic programming with bitmask state have not been a consistent feature of NLTH Automata tests.

The NLTH placement papers carry additional practice problems at the same difficulty range, including aptitude and verbal samples from previous drives.

Practice Questions with Solutions

The four problems below match the type and difficulty that the NLTH Automata round typically tests. They are practice exercises, not Wipro’s proprietary question set. Each includes a manual verification step so you can see the expected output before running any code.

Reverse Words in a String

• Problem: Given a string of space-separated words, print the words in reverse order.
• Sample input: Hello World from Wipro
• Sample output: Wipro from World Hello
• Approach: Split the string on spaces, reverse the resulting list, rejoin with spaces.

Python:

s = input()
words = s.split()
print(' '.join(reversed(words)))

C:

#include <stdio.h>
#include <string.h>

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = '\0';
    char *words[200];
    int count = 0;
    char *token = strtok(s, " ");
    while (token != NULL) {
        words[count++] = token;
        token = strtok(NULL, " ");
    }
    for (int i = count - 1; i >= 0; i--) {
        printf("%s", words[i]);
        if (i > 0) printf(" ");
    }
    printf("\n");
    return 0;
}

• Why it appears: String tokenisation without a library shortcut. Python handles it in two lines; C requires strtok and manual index management. Straightforward once you have practised it.

Find the Missing Number

• Problem: An array contains N-1 integers drawn from 1 to N, with exactly one number missing. Find the missing number.
• Sample input: N = 5, array = 1 2 3 5
• Sample output: 4
• Verification:
  • Expected sum of 1 to 5 = 5 * 6 / 2 = 15
  • Array sum = 1 + 2 + 3 + 5 = 11
  • Missing = 15 - 11 = 4 (correct)

Python:

n = int(input())
arr = list(map(int, input().split()))
expected = n * (n + 1) // 2
print(expected - sum(arr))

C:

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    long long expected = (long long)n * (n + 1) / 2;
    long long actual = 0;
    int x;
    for (int i = 0; i < n - 1; i++) {
        scanf("%d", &x);
        actual += x;
    }
    printf("%lld\n", expected - actual);
    return 0;
}

• Why it appears: The Gauss sum formula is the entire solution. Recognising the pattern in the problem statement saves writing a nested loop and keeps time complexity at O(n).

Even Numbers First

• Problem: Given N integers, rearrange them so all even numbers appear before all odd numbers, preserving relative order within each group.
• Sample input: 10 98 3 33 12 22 21 11
• Sample output: 10 98 12 22 3 33 21 11
• Approach: Two-pass separation: collect evens in order, then odds in order, concatenate.

Python:

n = int(input())
arr = list(map(int, input().split()))
evens = [x for x in arr if x % 2 == 0]
odds  = [x for x in arr if x % 2 != 0]
print(' '.join(map(str, evens + odds)))

C:

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    int arr[1000], evens[1000], odds[1000];
    int ec = 0, oc = 0;
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
        if (arr[i] % 2 == 0) evens[ec++] = arr[i];
        else odds[oc++] = arr[i];
    }
    for (int i = 0; i < ec; i++) printf("%d ", evens[i]);
    for (int i = 0; i < oc; i++) {
        printf("%d", odds[i]);
        if (i < oc - 1) printf(" ");
    }
    printf("\n");
    return 0;
}

• Why it appears: Two-pass partition is a building block pattern used in QuickSort and the Dutch national flag problem. Knowing it as a standalone also gets this specific problem solved in under 10 minutes.

First Non-Repeating Character

• Problem: Find the first character in a string that appears exactly once. If no such character exists, print -1.
• Sample input: swiss
• Sample output: w
• Verification:
  • s appears at indices 0 and 4 (count 2, skip)
  • w appears at index 1 only (count 1, output)
  • Result: w (correct)

Python:

from collections import Counter

s = input()
count = Counter(s)
for ch in s:
    if count[ch] == 1:
        print(ch)
        break
else:
    print(-1)

C:

#include <stdio.h>
#include <string.h>

int main() {
    char s[1000];
    scanf("%s", s);
    int freq[256] = {0};
    int n = strlen(s);
    for (int i = 0; i < n; i++) freq[(unsigned char)s[i]]++;
    for (int i = 0; i < n; i++) {
        if (freq[(unsigned char)s[i]] == 1) {
            printf("%c\n", s[i]);
            return 0;
        }
    }
    printf("-1\n");
    return 0;
}

• Why it appears: Hash map frequency counting is a standard interview topic. Two passes (count, then scan) keep the solution at O(n) time and O(1) space for fixed-size alphabets.

Time-Allocation Strategy for the Automata Round

60 minutes for two problems is workable if you read both questions first and avoid spending 40 minutes on the harder one before attempting the easier one.

Time window (minutes)	Recommended action
0 to 5	Read both problems fully. Note constraints: array size, string length, value ranges. Decide which to attempt first.
5 to 25	Solve Problem 1. Write, compile, run on sample input. Check edge cases before submitting.
25 to 50	Solve Problem 2. Same process.
50 to 60	Submit both. Review any failing test cases. Apply a partial fix if time allows.

A few specific observations from the NLTH pattern:

• Start with the problem that feels more familiar. Completing one cleanly in the first 25 minutes locks in partial credit and settles focus for Problem 2.
• Python is generally shorter to write than C for string operations. Use it unless the problem includes an explicit performance constraint (typically stated as “your solution must handle N up to 10^6 inputs within the time limit”).
• Common edge cases to test before submitting: empty string, single-character string, all-even or all-odd array, N = 0 or N = 1.
• Partial submission is always worth it. If your solution handles 7 of 10 test cases, submit it and use remaining time to fix the rest.

Salary Bands: Velocity and CoE Tracks

Wipro runs two fresher-hire tracks that NLTH candidates typically encounter.

Track	Entry route	CTC (2026 cycle)
Velocity	NLTH aptitude + Automata + technical + HR rounds	3.5 to 4.0 LPA
Centres of Excellence (CoE)	Campus drive at one of 50 designated CoE universities	Premium (above Velocity; specific figure not publicly disclosed)

Wipro’s CHRO Saurabh Govil confirmed in Q3 FY26 earnings commentary that Wipro revised its fresher intake from 10,000-12,000 to 7,500-8,000 for FY26, while directing focus toward AI-ready talent through the CoE network. CoE candidates go through a differentiated interview process and receive a premium above the Velocity band; the specific CoE figure is not publicly disclosed.

If your college is not among the 50 CoE partner institutions, the Velocity track through NLTH is the primary entry path. Check Wipro Careers to see whether your campus has an active drive and whether it carries a CoE designation.

For what comes after the coding test, the Wipro interview questions guide covers the technical and HR stages at the same level of detail.

AI Skills and the CoE Pathway

Wipro’s 50 university Centres of Excellence co-build curriculum in AI, cybersecurity, and data analytics with the host institutions. The CHRO confirmed at the same Q3 FY26 session that Wipro pays premiums to candidates with prior experience in AI areas. These are not ML researchers. They are engineers who can write code that calls an LLM API, process unstructured text, or run a basic model evaluation script.

The 2026 AI roadmap for Indian engineers outlines what to build to reach that bar, starting from zero paid tools.

The Wipro Automata round tests whether you can solve two string and array problems in 60 minutes. The CoE track adds a second bar: whether you can also ship something that uses an AI API. TinkerLLM puts real LLM API calls in your hands for ₹499, and the project you build there is something you can describe in a Wipro technical interview the same week you clear the Automata round.