Akshit Saini

Test ID: 450010943000021 7017561895 [email protected]

Test Date: March 20, 2025

Computer Science Logical Ability Computer Programming Quantitative Ability

(Advanced)

100 /100 69 /100 72 /100 39 /100

English Comprehension WriteX - Essay Writing Automata Fix Automata Pro

52 /100 55 /100 58 /100 53 /100

Personality

Completed

Computer Science 100 / 100

OS and Computer Architecture DBMS Computer Networks

100 / 100 100 / 100 100 / 100

Logical Ability 69 / 100

Inductive Reasoning Deductive Reasoning Abductive Reasoning

63 / 100 77 / 100 66 / 100

© 2025 SHL and/or its affiliates. All rights reserved.. 1/29

Computer Programming 72 / 100

Basic Programming Data Structures OOP and Complexity Theory

69 / 100 73 / 100 73 / 100

Quantitative Ability (Advanced) 39 / 100

Basic Mathematics Advanced Mathematics Applied Mathematics

39 / 100 39 / 100 38 / 100

English Comprehension 52 / 100 CEFR: B1

Grammar Vocabulary Comprehension

51 / 100 54 / 100 51 / 100

WriteX - Essay Writing 55 / 100 CEFR: B1

Content Score Grammar Score

55 / 100 56 / 100

Automata Fix 58 / 100

Logical Error Code Reuse Syntactical Error

75 / 100 0 / 100 100 / 100

Automata Pro 53 / 100

Programming Ability Programming Practices Functional Correctness

50 / 100 50 / 100 48 / 100

© 2025 SHL and/or its affiliates. All rights reserved.. 2/29

Personality Completed

100
People Interaction
81

80 70

56
60 48
Self-Drive
39
40

Trainability
20 11

0
Repetitive Job Suitability
Conscientiousness Openness to Experience Polychronicity

Extraversion Agreeableness Emotional Stability

Competencies Work attributes

© 2025 SHL and/or its affiliates. All rights reserved.. 3/29

1 Introduction

About the Report

This report provides a detailed analysis of the candidate's performance on different assessments. The tests for this
job role were decided based on job analysis, O*Net taxonomy mapping and/or criterion validity studies. The
candidate’s responses to these tests help construct a profile that reflects her/his likely performance level and
achievement potential in the job role

This report has the following sections:

The Summary section provides an overall snapshot of the candidate’s performance. It includes a graphical
representation of the test scores and the subsection scores.

The Insights section provides detailed feedback on the candidate’s performance in each of the tests. The descriptive
feedback includes the competency definitions, the topics covered in the test, and a note on the level of the
candidate’s performance.

The Response section captures the response provided by the candidate. This section includes only those tests that
require a subjective input from the candidate and are scored based on artificial intelligence and machine learning.

The Learning Resources section provides online and offline resources to improve the candidate's knowledge, abilities,
and skills in the different areas on which s/he was evaluated.

Score Interpretation

All the test scores are on a scale of 0-100. All the tests except personality and behavioural evaluation provide
absolute scores. The personality and behavioural tests provide a norm-referenced score and hence, are percentile
scores. Throughout the report, the colour codes used are as follows:

Scores between 67 and 100

Scores between 33 and 67

Scores between 0 and 33

© 2025 SHL and/or its affiliates. All rights reserved.. 4/29

2 Insights

English Comprehension 52 / 100 CEFR: B1

This test aims to measure your vocabulary, grammar and reading comprehension skills.

You are able to construct short sentences and understand simple text. The ability to read and comprehend is
important for most jobs. However, it is of utmost importance for jobs that involve research, content development,
editing, teaching, etc.

Logical Ability 69 / 100

Inductive Reasoning 63 / 100

This competency aims to measure the your ability to synthesize information and derive conclusions.

It is commendable that you have excellent inductive reasoning skills. You are able to make specific
observations to generalize situations and also formulate new generic rules from variable data.

Deductive Reasoning 77 / 100

This competency aims to measure the your ability to synthesize information and derive conclusions.

It is commendable that you have excellent inductive reasoning skills. You are able to make specific
observations to generalize situations and also formulate new generic rules from variable data.

Abductive Reasoning 66 / 100

Quantitative Ability (Advanced) 39 / 100

This test aims to measure your ability to solve problems on basic arithmetic operations, probability, permutations and
combinations, and other advanced concepts.

You are good at basic arithmetic. You are able to solve real-world problems that involve simple addition, subtraction,
multiplication and division.

Personality

Competencies

© 2025 SHL and/or its affiliates. All rights reserved.. 5/29

 39

Extraversion
Reserved Sociable

Extraversion refers to a person's inclination to prefer social interaction over spending time alone.
Individuals with high levels of extraversion are perceived to be outgoing, warm and socially confident.

• You are comfortable socializing to a certain extent. You prefer small gatherings in familiar
environments.
• You feel at ease interacting with your close friends but may be reserved among strangers.
• You indulge in activities involving thrill and excitement that are not too risky.
• You contemplate the consequences before expressing any opinion or taking an action.
• You take charge when the situation calls for it and you are comfortable following instructions as
well.
• Your personality may be suitable for jobs demanding flexibility in terms of working well with a
team as well as individually.

81

Conscientiousness
Spontaneous Diligent

Conscientiousness is the tendency to be organized, hard working and responsible in one's approach to
your work. Individuals with high levels of this personality trait are more likely to be ambitious and
tend to be goal-oriented and focused.

• You value order and self discipline and tends to pursue ambitious endeavours.
• You believe in the importance of structure and is very well-organized.
• You carefully review facts before arriving at conclusions or making decisions based on them.
• You strictly adhere to rules and carefully consider the situation before making decisions.
• You tend to have a high level of self confidence and do not doubt your abilities.
• You generally set and work toward goals, try to exceed expectations and are likely to excel in
most jobs, especially those which require careful or meticulous approach.

56

Agreeableness

Competitive Cooperative

Agreeableness refers to an individual's tendency to be cooperative with others and it defines your
approach to interpersonal relationships. People with high levels of this personality trait tend to be
more considerate of people around them and are more likely to work effectively in a team.

• You are flexible regarding your opinions and be willing to accommodate the needs of others.
• You are generally considerate of the needs of others yet may, at times, overlook social norms to
achieve personal success.
• You are selective about the people you choose to trust.
• You are caring and you empathise a friend in distress.
• You give credit to others but also tends to be open with your friends about personal
achievements.

© 2025 SHL and/or its affiliates. All rights reserved.. 6/29

 • You are more inclined to strike a compromise in tough situations and may be suitable for jobs
that demand managing expectations among different stakeholders.

48

Openness to Experience
Conventional Inquisitive

Openness to experience refers to a person's inclination to explore beyond conventional boundaries in

different aspects of life. Individuals with high levels of this personality trait tend to be more curious,
creative and innovative in nature.

• You may try new things but would prefer not to venture too far beyond your comfort zone.
• You tend to be open to accepting abstract ideas after weighing them against existing solutions.
• You appreciate the arts to a certain extent but may lack the curiosity to explore them in depth.
• You may express your feelings only to people you are comfortable with.
• Your personality is more suited for jobs involving a mix of logical and creative thinking.

11

Emotional Stability

Sensitive Resilient

Emotional stability refers to the ability to withstand stress, handle adversity, and remain calm and
composed when working through challenging situations. People with high levels of this personality trait
tend to be more in control of their emotions and are likely to perform consistently despite difficult or
unfavourable conditions.

• You are likely to be sensitive, emotional and may tend to worry about situations.
• You may react to everyday events with greater intensity and may become emotional.
• You may hesitate to face certain stressful situations and might feel anxious about your ability to
handle them.
• You may find it hard to elicit self restraint and may tend to make impulsive decisions.
• Your personality is more suited for less stressful jobs.

70

Polychronicity
Focused Multitasking

Polychronicity refers to a person's inclination to multitask. It is the extent to which the person prefers
to engage in more than one task at a time and believes that such an approach is highly productive.
While this trait describes the personality disposition of a person to multitask, it does not gauge their
ability to do so successfully.

• You pursue multiple tasks simultaneously, switching between them when needed.
• You prefer working to achieve some progress on multiple tasks simultaneously than completing
one task before moving on to the next task.
• You tend to believe that multitasking is an efficient way of doing things and prefers an action
packed work life with multiple projects.

© 2025 SHL and/or its affiliates. All rights reserved.. 7/29

3 Response

Automata Fix 58 / 100 Code Replay

Question 1 (Language: C++)

The function/method patternPrint accepts an argument num, an integer.

The function/method patternPrint prints num lines in the following pattern.

For example, num = 4, the pattern should be:

1
11
111
1111

The function/method patternPrint compiles successfully but fails to print the desired result for some test cases due to
incorrect implementation of the function/method. Your task is to fix the code so that it passes all the test cases.

Scores

Final Code Submitted Compilation Status: Pass Code Analysis

1 // You can print the values to stdout for debugging Average-case Time Complexity
2 using namespace std;
3 void patternPrint(int num)
4{ Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 int print=1; cases.
6 for(int i=0;i<num;i++)
7 { Best case code:

8 for(int j=0;j<=i;j++)
9 { *N represents

10 cout<<print<<" ";
11 print++; Errors/Warnings
12 }
13 There are no errors in the candidate's code.

14 cout<<"\n";
15 } Structural Vulnerabilites and Errors

16 } There are no errors in the candidate's code.

17
Test Case Execution Passed TC: 25%

Total score
14% 0% 100%
2/8 Basic(1/7) Advance(0/0) Edge(1/1)

© 2025 SHL and/or its affiliates. All rights reserved.. 8/29

Compilation Statistics

5 5 0 4 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:09:00

Average time taken between two compile attempts: 00:01:48

Average test case pass percentage per compile: 25%

Average-case Time Complexity

Average Case Time Complexity is the order of performance of the algorithm given a random set of inputs. This complexity is measured
here using the Big-O asymptotic notation. This is the complexity detected by empirically fitting a curve to the run-time for different input
sizes to the given code. It has been benchmarked across problems.

Test Case Execution

There are three types of test-cases for every coding problem:

Basic: The basic test-cases demonstrate the primary logic of the problem. They include the most common and obvious cases that an
average candidate would consider while coding. They do not include those cases that need extra checks to be placed in the logic.

Advanced: The advanced test-cases contain pathological input conditions that would attempt to break the codes which have
incorrect/semi-correct implementations of the correct logic or incorrect/semi-correct formulation of the logic.

Edge: The edge test-cases specifically confirm whether the code runs successfully even under extreme conditions of the domain of
inputs and that all possible cases are covered by the code

Question 2 (Language: C++)

The function/method allExponent returns a real number representing the result of exponentiation of base raised to
power exponent for all input values. The function/method allExponent accepts two arguments - baseValue, an integer
representing the base and exponentValue, an integer representing the exponent.

The incomplete code in the function/method allExponent works only for positive values of the exponent. You must
complete the code and make it work for negative values of exponent as well.

Another function/method positiveExponent uses an efficient way for exponentiation but accepts only
positive exponent values. You are supposed to use this function/method to complete the code
in allExponent function/method.

Helper Description

The following function is used to represent a positiveExponent and is already implemented in the default code (Do not
write this definition again in your code):

© 2025 SHL and/or its affiliates. All rights reserved.. 9/29

write this definition again in your code):
int positiveExponent(int baseValue, int exponentValue)

/*It calculates the Exponent for the positive value of exponentValue

This can be called as -

int res = (float)positiveExponent(baseValue, exponentValue);*/

Scores

Final Code Submitted Compilation Status: Pass Code Analysis

1 // You can print the values to stdout for debugging Average-case Time Complexity
2 using namespace std;
3 float allExponent(int baseValue, int exponentValue)
4{ Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 float res = 1; cases.
6 if(exponentValue >=0)
7 { Best case code:

8 res = (float)positiveExponent(baseValue, exponentValue);

9 } *N represents

10 else
11 { Errors/Warnings
12 // write your code here for negative exponentInput
13 } There are no errors in the candidate's code.

14 return res;
15 } Structural Vulnerabilites and Errors

16 There are no errors in the candidate's code.

17
Test Case Execution Passed TC: 66.67%

Total score
100% 33% 100%
4/6 Basic(2/2) Advance(1/3) Edge(1/1)

© 2025 SHL and/or its affiliates. All rights reserved.. 10/29

Compilation Statistics

0 0 0 1 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:01:31

Average time taken between two compile attempts: 00:00:00

Average test case pass percentage per compile: 66.7%

Average-case Time Complexity

Average Case Time Complexity is the order of performance of the algorithm given a random set of inputs. This complexity is measured
here using the Big-O asymptotic notation. This is the complexity detected by empirically fitting a curve to the run-time for different input
sizes to the given code. It has been benchmarked across problems.

Test Case Execution

There are three types of test-cases for every coding problem:

Basic: The basic test-cases demonstrate the primary logic of the problem. They include the most common and obvious cases that an
average candidate would consider while coding. They do not include those cases that need extra checks to be placed in the logic.

Advanced: The advanced test-cases contain pathological input conditions that would attempt to break the codes which have
incorrect/semi-correct implementations of the correct logic or incorrect/semi-correct formulation of the logic.

Edge: The edge test-cases specifically confirm whether the code runs successfully even under extreme conditions of the domain of
inputs and that all possible cases are covered by the code

Question 3 (Language: C++)

Lisa always forgets her birthday which is on the 5th of July. So, develop a function/method which will be helpful to
remember her birthday.

The function/method checkBirthDay return an integer ‘1’ if it is her birthday else returns 0. The function/method
checkBirthDay accepts two arguments - month, a string representing the month of her birthday and day, an integer
representing the date of her birthday.

The function/method checkBirthDay compiles successfully but fails to return the desired result for some test cases.
Your task is to fix the code so that it passes all the test cases.

Scores

© 2025 SHL and/or its affiliates. All rights reserved.. 11/29

Final Code Submitted Compilation Status: Pass Code Analysis
1 // You can print the values to stdou Average-case Time Complexity
t for debugging
2 #include<string.h>
3 using namespace std; Candidate code: Complexity is reported only when the code

4 int checkBirthDay(char* month, int day) is correct and it passes all the basic and advanced test
cases.
5{
6 if(strcmp(month,"July")==0 && (day==5)) Best case code:
7 return 1;
8 else *N represents

9 return 0;
10 } Errors/Warnings
11
There are no errors in the candidate's code.

Structural Vulnerabilites and Errors

There are no errors in the candidate's code.

Test Case Execution Passed TC: 100%

Total score
100% 100% 0%
9/9 Basic(6/6) Advance(3/3) Edge(0/0)

Compilation Statistics

3 3 0 2 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:02:10

Average time taken between two compile attempts: 00:00:43

Average test case pass percentage per compile: 40.7%

© 2025 SHL and/or its affiliates. All rights reserved.. 12/29

 Average-case Time Complexity

Average Case Time Complexity is the order of performance of the algorithm given a random set of inputs. This complexity is measured
here using the Big-O asymptotic notation. This is the complexity detected by empirically fitting a curve to the run-time for different input
sizes to the given code. It has been benchmarked across problems.

Test Case Execution

There are three types of test-cases for every coding problem:

Basic: The basic test-cases demonstrate the primary logic of the problem. They include the most common and obvious cases that an
average candidate would consider while coding. They do not include those cases that need extra checks to be placed in the logic.

Advanced: The advanced test-cases contain pathological input conditions that would attempt to break the codes which have
incorrect/semi-correct implementations of the correct logic or incorrect/semi-correct formulation of the logic.

Edge: The edge test-cases specifically confirm whether the code runs successfully even under extreme conditions of the domain of
inputs and that all possible cases are covered by the code

Question 4 (Language: C++)

The function/method descendingSortArray performs an in-place sort on the given input list which will be sorted in
descending order.
The function/method descendingSortArray accepts two arguments - len, an integer representing the length of the
input list and arr, a list of integers representing the input list, respectively.
5
The function/method descendingSortArray compiles successfully but fails to get the desired result for some test cases
due to logical errors. Your task is to fix the code so that it passes all the test cases.

Scores

Final Code Submitted Compilation Status: Pass Code Analysis

1 // You can print the values to stdout for debugging Average-case Time Complexity
2 void descendingSortArray(int len, int* arr)
3{
4 int i, j, temp; Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 for(i=0; i<=len-1;i++) cases.
6 {
7 for(j=i+1; j<len;j++) Best case code:

8 {
9 // temp = 0;
*N represents

10 if(arr[i]<arr[j])
11 { Errors/Warnings
12 temp=arr[i];
13 arr[i]=arr[j]; There are no errors in the candidate's code.

14 arr[j]=temp;

© 2025 SHL and/or its affiliates. All rights reserved.. 13/29

 15 } Structural Vulnerabilites and Errors
16 }
17 } There are no errors in the candidate's code.
18 }
Test Case Execution Passed TC: 100%

Total score
100% 100% 0%
10/10 Basic(6/6) Advance(4/4) Edge(0/0)

Compilation Statistics

1 1 0 0 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:01:38

Average time taken between two compile attempts: 00:01:38

Average test case pass percentage per compile: 100%

Average-case Time Complexity

Average Case Time Complexity is the order of performance of the algorithm given a random set of inputs. This complexity is measured
here using the Big-O asymptotic notation. This is the complexity detected by empirically fitting a curve to the run-time for different input
sizes to the given code. It has been benchmarked across problems.

Test Case Execution

There are three types of test-cases for every coding problem:

Basic: The basic test-cases demonstrate the primary logic of the problem. They include the most common and obvious cases that an
average candidate would consider while coding. They do not include those cases that need extra checks to be placed in the logic.

Advanced: The advanced test-cases contain pathological input conditions that would attempt to break the codes which have
incorrect/semi-correct implementations of the correct logic or incorrect/semi-correct formulation of the logic.

Edge: The edge test-cases specifically confirm whether the code runs successfully even under extreme conditions of the domain of
inputs and that all possible cases are covered by the code

Question 5 (Language: C++)

The function/method matrixSum returns an integer representing the sum of elements of the input matrix. The
function/method matrixSum accepts three arguments - rows, an integer representing the number of rows of the input
matrix, columns, an integer representing the number of columns of the input matrix and matrix, a two-dimensional

© 2025 SHL and/or its affiliates. All rights reserved.. 14/29

array representing the input matrix.

The function/method matrixSum compiles unsuccessfully due to syntactical error. Your task is to debug the program so
that it passes all test cases.

Scores

Final Code Submitted Compilation Status: Pass Code Analysis

1 // You can print the values to stdout for debugging Average-case Time Complexity
2 using namespace std;
3 int matrixSum(int rows, int columns, int **matrix)
4{ Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 int i, j, sum=0; cases.
6 for(i=0;i<rows;i++)
7 { Best case code:

8 for(j=0;j<columns;j++)
9 sum += matrix[i][j]; *N represents

10 }
11 return sum; Errors/Warnings
12 } There are no errors in the candidate's code.

Structural Vulnerabilites and Errors

There are no errors in the candidate's code.

Test Case Execution Passed TC: 100%

Total score
100% 100% 0%
10/10 Basic(6/6) Advance(4/4) Edge(0/0)

Compilation Statistics

1 1 0 0 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:00:28

Average time taken between two compile attempts: 00:00:28

Average test case pass percentage per compile: 100%

© 2025 SHL and/or its affiliates. All rights reserved.. 15/29

 Average-case Time Complexity

Average Case Time Complexity is the order of performance of the algorithm given a random set of inputs. This complexity is measured
here using the Big-O asymptotic notation. This is the complexity detected by empirically fitting a curve to the run-time for different input
sizes to the given code. It has been benchmarked across problems.

Test Case Execution

There are three types of test-cases for every coding problem:

Basic: The basic test-cases demonstrate the primary logic of the problem. They include the most common and obvious cases that an
average candidate would consider while coding. They do not include those cases that need extra checks to be placed in the logic.

Advanced: The advanced test-cases contain pathological input conditions that would attempt to break the codes which have
incorrect/semi-correct implementations of the correct logic or incorrect/semi-correct formulation of the logic.

Edge: The edge test-cases specifically confirm whether the code runs successfully even under extreme conditions of the domain of
inputs and that all possible cases are covered by the code

Question 6 (Language: C++)

The function/method selectionSortArray performs an in-place selection sort on the given input list which will be sorted
in ascending order.
The function/method selectionSortArray accepts two arguments - len, an integer representing the length of the input
list and arr, a list of integers representing the input list, respectively.

The function/method selectionSortArray compiles successfully but fails to get the desired result for some test cases
due to logical errors. Your task is to fix the code so that it passes all the test cases.

Note:
In this particular implementation of selection sort, the smallest element in the list is swapped with the element at first
index, the next smallest element is swapped with the element at the next index and so on.

Scores

Final Code Submitted Compilation Status: Pass Code Analysis

1 // You can print the values to stdout for debugging Average-case Time Complexity
2 void selectionSortArray(int len, int* arr){
3 int x=0, y =0;
4 for(x=0; x<len-1; x++){ Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 int index_of_min = x; cases.
6 for(y=x+1; y<len; y++){
7 if(arr[y]<arr[index_of_min]){ Best case code:

8 index_of_min = y;

© 2025 SHL and/or its affiliates. All rights reserved.. 16/29

 9 } *N represents

10 }
11 int temp = arr[x]; Errors/Warnings
12 arr[x] = arr[index_of_min];
13 arr[index_of_min] = temp; There are no errors in the candidate's code.
14 }
15 } Structural Vulnerabilites and Errors

There are no errors in the candidate's code.

Test Case Execution Passed TC: 100%

Total score
100% 100% 0%
9/9 Basic(4/4) Advance(5/5) Edge(0/0)

Compilation Statistics

2 2 0 1 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:02:18

Average time taken between two compile attempts: 00:01:09

Average test case pass percentage per compile: 55.6%

Average-case Time Complexity

Average Case Time Complexity is the order of performance of the algorithm given a random set of inputs. This complexity is measured
here using the Big-O asymptotic notation. This is the complexity detected by empirically fitting a curve to the run-time for different input
sizes to the given code. It has been benchmarked across problems.

Test Case Execution

There are three types of test-cases for every coding problem:

Basic: The basic test-cases demonstrate the primary logic of the problem. They include the most common and obvious cases that an
average candidate would consider while coding. They do not include those cases that need extra checks to be placed in the logic.

Advanced: The advanced test-cases contain pathological input conditions that would attempt to break the codes which have
incorrect/semi-correct implementations of the correct logic or incorrect/semi-correct formulation of the logic.

Edge: The edge test-cases specifically confirm whether the code runs successfully even under extreme conditions of the domain of
inputs and that all possible cases are covered by the code

© 2025 SHL and/or its affiliates. All rights reserved.. 17/29

Question 7 (Language: C++)

You are given a predefined structure Point and also a collection of related functions/methods that can be used to
perform some basic operations on the structure.

You must implement the function/method isTriangle which accepts three points P1, P2, P3 as inputs and checks
whether the given three points form a triangle.

If they form a triangle, the function/method returns an integer 1. Otherwise, it returns an integer 0.

Helper Description
The following class is used to represent point and is already implemented in the default code (Do not write these
definitions again in your code):

class Point

private:

int X;

int Y;

double Point_calculateDistance(Point *point1, Point *point2)

/*Return the euclidean distance between two input points.

This can be called as -

* If P1 and P2 are two points then -

* P1->Point_calculateDistance(P2);*/

Scores

Final Code Submitted Compilation Status: Pass Code Analysis

1 // You can print the values to stdout for debugging Average-case Time Complexity
2 using namespace std;
3 int isTriangle(Point *P1, Point *P2, Point *P3)
4{ Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
// write your code here

© 2025 SHL and/or its affiliates. All rights reserved.. 18/29

 5 cases.

6 return 1;
7} Best case code:

*N represents

Errors/Warnings

There are no errors in the candidate's code.

Structural Vulnerabilites and Errors

There are no errors in the candidate's code.

Test Case Execution Passed TC: 44.44%

Total score
50% 50% 0%
4/9 Basic(3/6) Advance(1/2) Edge(0/1)

Compilation Statistics

1 1 0 1 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:02:46

Average time taken between two compile attempts: 00:02:46

Average test case pass percentage per compile: 11.1%

© 2025 SHL and/or its affiliates. All rights reserved.. 19/29

 Average-case Time Complexity

Average Case Time Complexity is the order of performance of the algorithm given a random set of inputs. This complexity is measured
here using the Big-O asymptotic notation. This is the complexity detected by empirically fitting a curve to the run-time for different input
sizes to the given code. It has been benchmarked across problems.

Test Case Execution

There are three types of test-cases for every coding problem:

Basic: The basic test-cases demonstrate the primary logic of the problem. They include the most common and obvious cases that an
average candidate would consider while coding. They do not include those cases that need extra checks to be placed in the logic.

Advanced: The advanced test-cases contain pathological input conditions that would attempt to break the codes which have
incorrect/semi-correct implementations of the correct logic or incorrect/semi-correct formulation of the logic.

Edge: The edge test-cases specifically confirm whether the code runs successfully even under extreme conditions of the domain of
inputs and that all possible cases are covered by the code

Automata Pro 53 / 100 Code Replay

Question 1 (Language: C++)

In an online word recognition game for kids, the user needs to find the number of times the given word occurs in the
sentence. Both the given word and the sentence displayed on the user interface consist of letters from the English
alphabet only and are case insensitive (i.e., ‘toddler’ is same as ‘Toddler’). Neither the word nor the sentence contain
any white-spaces or special symbols.

Write an algorithm to print the number of times the given word appears in the sentence.

Scores

Programming Ability Programming Practices

80 / 100 100 / 100

Correct with inadvertent errors. Correct control structures and High readability, high on program structure. The source code is
critical data dependencies incorporated. Some inadvertent errors readable and does not consist of any significant
make the code fail test cases. redundant/improper coding constructs.

Functional Correctness

72 / 100
Correct basic functionality with partially correct advanced
functionality. Passes all the basic test cases in the test suite and a
percentage of the advanced test cases.

© 2025 SHL and/or its affiliates. All rights reserved.. 20/29

Final Code Submitted Compilation Status: Pass Code Analysis

1 // Header Files Average-case Time Complexity

2 #include<iostream>
3 #include<string>
4 #include<vector> Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 #include<algorithm> cases.
6 using namespace std;
7 Best case code:

8 // Write your code here

9 string toLowerCase(string str){ *N represents length of the string

10 transform(str.begin(),str.end(),str.begin(),::tolower);
11 return str; Errors/Warnings
12 }
13 int countWords (string sentence, string word) There are no errors in the candidate's code.

14 {
15 int answer=0; Structural Vulnerabilites and Errors

16 sentence=toLowerCase(sentence); There are no errors in the candidate's code.

17 word=toLowerCase(word);
18
19 for(int i=0;i<=sentence.length()-word.length();i++){
20 bool found=true;
21 for(int j=0;j<word.length();j++){
22 if(sentence[i+j]!=word[j]){
23 found=false;
24 break;
25 }
26 }
27 if(found){
28 answer++;
29 }
30 }
31 return answer;
32 }
33
34 int main()
35 {
36
37 //input for sentence
38 string sentence;
39 getline(cin,sentence);
40
41 //input for word
42 string word;
43 getline(cin,word);
44
45 int result = countWords(sentence, word);
46 cout << result;
47
48

© 2025 SHL and/or its affiliates. All rights reserved.. 21/29

 49 return 0;
50 }
51
Test Case Execution Passed TC: 93.75%

Total score
100% 80% 100%
15/16 Basic(10/10) Advance(4/5) Edge(1/1)

Compilation Statistics

18 17 1 0 0 8

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:34:38

Average time taken between two compile attempts: 00:01:55

Average test case pass percentage per compile: 42.36%

Average-case Time Complexity

Average Case Time Complexity is the order of performance of the algorithm given a random set of inputs. This complexity is measured
here using the Big-O asymptotic notation. This is the complexity detected by empirically fitting a curve to the run-time for different input
sizes to the given code. It has been benchmarked across problems.

Test Case Execution

There are three types of test-cases for every coding problem:

Basic: The basic test-cases demonstrate the primary logic of the problem. They include the most common and obvious cases that an
average candidate would consider while coding. They do not include those cases that need extra checks to be placed in the logic.

Advanced: The advanced test-cases contain pathological input conditions that would attempt to break the codes which have
incorrect/semi-correct implementations of the correct logic or incorrect/semi-correct formulation of the logic.

Edge: The edge test-cases specifically confirm whether the code runs successfully even under extreme conditions of the domain of
inputs and that all possible cases are covered by the code

Question 2 (Language: C)

Shortest Job First (SJF) is a system for scheduling task requests.

Each task request is characterized by its request time (i.e., the time at which the task is submitted to the system) and
its duration (i.e., the time needed to complete the task).

© 2025 SHL and/or its affiliates. All rights reserved.. 22/29

When the SJF system completes a task, it selects the task with the smallest duration to execute next. If multiple tasks
have the same smallest duration, SJF selects the task with the earliest request time. The waiting time for a task is the
difference between the request time and the actual start time (i.e., the time that it spends waiting for the system to
execute it). You may assume that the tasks arrive in such frequency that the system executes tasks constantly and is
never idle.

Given a list of request times and duration times, calculate the average task waiting time when scheduled using the
Shortest Job First (SJF) algorithm.

Scores

Programming Ability Programming Practices

20 / 100 0 / 100
Code seems to be unrelated to the given problem. Programming practices score cannot be generated. This is
because source code has syntax/runtime errors and is
unparseable or the source code does not meet the minimum
code-length specifications.

Functional Correctness

24 / 100
Partially correct basic functionality. The source code compiles and
passes only some of the basic test cases. Some advanced or edge
cases may randomly pass.

Final Code Submitted Compilation Status: Pass Code Analysis

1 //Header Files Average-case Time Complexity

2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h> Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 #include<stdbool.h> cases.
6
7 /* only used in string related operations */ Best case code: O(N2)

8 typedef struct String string;

9 struct String *N represents number of tasks

10 {
11 char *str; Errors/Warnings
12 };
13 There are no errors in the candidate's code.

14 char *input(FILE *fp, int size, int has_space)

15 { Structural Vulnerabilites and Errors

16 int actual_size = 0; There are no errors in the candidate's code.

17 char *str = (char *)malloc(sizeof(char)*(size+actual_size));
18 char ch;
19 if(has_space == 1)

© 2025 SHL and/or its affiliates. All rights reserved.. 23/29

20 {
21 while(EOF != (ch=fgetc(fp)) && ch != '\n')
22 {
23 str[actual_size] = ch;
24 actual_size++;
25 if(actual_size >= size)
26 {
27 str = realloc(str,sizeof(char)*actual_size);
28 }
29 }
30 }
31 else
32 {
33 while(EOF != (ch=fgetc(fp)) && ch != '\n' && ch != ' ')
34 {
35 str[actual_size] = ch;
36 actual_size++;
37 if(actual_size >= size)
38 {
39 str = realloc(str,sizeof(char)*actual_size);
40 }
41 }
42 }
43 actual_size++;
44 str = realloc(str,sizeof(char)*actual_size);
45 str[actual_size-1] = '\0';
46 return str;
47 }
48 /* only used in string related operations */
49
50 typedef struct array_single_int array_single_int;
51 struct array_single_int
52 {
53 int *data;
54 int size;
55 };
56
57
58 /*
59 * req, representing the array with size of req_size.
60 * dur, representing the array with size of dur_size.
61 */
62 float waitingTime(array_single_int req, array_single_int dur)
63 {
64 float answer;
65 // Write your code here
66
67 answer=4.0;
68
69 return answer;
© 2025 SHL and/or its affiliates. All rights reserved.. 24/29
 70 }
71
72 int main()
73 {
74 array_single_int req;
75 array_single_int dur;
76
77 //input for req
78 scanf("%d", &req.size);
79 req.data = (int *)malloc(sizeof(int) * req.size);
80 for ( int idx = 0; idx < req.size; idx++ )
81 {
82 scanf("%d", &req.data[idx]);
83 }
84
85 //input for dur
86 scanf("%d", &dur.size);
87 dur.data = (int *)malloc(sizeof(int) * dur.size);
88 for ( int idx = 0; idx < dur.size; idx++ )
89 {
90 scanf("%d", &dur.data[idx]);
91 }
92
93
94 float result = waitingTime(req, dur);
95 printf("%.2f", result);
96
97 return 0;
98 }
99
Test Case Execution Passed TC: 4.55%

Total score
20% 0% 0%
1/22 Basic(1/5) Advance(0/13) Edge(0/4)

Compilation Statistics

33 30 3 0 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:25:20

Average time taken between two compile attempts: 00:00:46

Average test case pass percentage per compile: 0.28%

© 2025 SHL and/or its affiliates. All rights reserved.. 25/29

 Average-case Time Complexity

Average Case Time Complexity is the order of performance of the algorithm given a random set of inputs. This complexity is measured
here using the Big-O asymptotic notation. This is the complexity detected by empirically fitting a curve to the run-time for different input
sizes to the given code. It has been benchmarked across problems.

Test Case Execution

There are three types of test-cases for every coding problem:

Basic: The basic test-cases demonstrate the primary logic of the problem. They include the most common and obvious cases that an
average candidate would consider while coding. They do not include those cases that need extra checks to be placed in the logic.

Advanced: The advanced test-cases contain pathological input conditions that would attempt to break the codes which have
incorrect/semi-correct implementations of the correct logic or incorrect/semi-correct formulation of the logic.

Edge: The edge test-cases specifically confirm whether the code runs successfully even under extreme conditions of the domain of
inputs and that all possible cases are covered by the code

WriteX - Essay Writing 55 / 100 CEFR: B1

Question

Some parents feel that sports is a distraction to their kids' studies. There are others who give due importance to
sports for the holistic development of a child.
What is your view? Support your response with reasons and examples.

Scores

Content Score Grammar Score

55 / 100 56 / 100

Response Error Summary

Sports play a important role in everyone's life. It depends on the user how he is involv
Spelling 1
ed in that. All of us in the world around 80 percent of us are involved in the sportsb dir
ectly or indirectly .According to me parents should involve their child in sports as sport
s help any child to build his or her mental as well as physical strength . If a person is in White Space 2
good mental health then it would be beneficial for him in any part of his life. As we kno
w in the current generation people are losing their health in terms of physical or sexual
Style 0
health. Lot of people are not involved in any game because of that only they are losing
their strength and in long term they catch diseases easily and reducing their immune p
ower. As we see if child is enrolled in any game then he can also be set as an example Grammar 22
to whole country after bringing gold medals for our country and it would be a proud mo
ment for our country. Recently there was Champions Trophy 2025 organised by Pakista
Typographical 0
n in Dubai and in that our team India had achieved that trophy. It was the great mome
nt in our country. Everyone in our country were too much excited and enjoyed a lot. So

© 2025 SHL and/or its affiliates. All rights reserved.. 26/29

as concluding parents should involve their child in any sport as it will boost them in any
field of life.

Essay Statistics

236 12 20 132 120

Average sentence
Total words Total sentences Total unique words Total stop words
length

Error Details

Spelling

...nd 80 percent of us are involved in the sportsb directly o Possible spelling mistake found
r indirectly .According to me...

White Space

...ed in the sportsb directly or indirectly .According to me p Don't put a space before the full stop
arents should involve t...

... her mental as well as physical strength . If a person is i Don't put a space before the full stop
n good mental health th...

Grammar

Sports play a important role in everyone's life. Possible grammar error found. Consider replacing it with
"an".

Sports play a important role in everyone's life. Possible grammar error found. Consider replacing it with
"everyone".

Sports play a important role in everyone's life. Possible grammar error found. Consider inserting "is" over
here.

All of us in the world around 80 percent of us are involved i Possible grammar error found. Consider removing "the"
n the sportsb directly or indirectly . from here.

According to me parents should involve their child in sports Possible grammar error found. Consider inserting
as sports help any child to build his or her mental as well a "strength" over here.
s physical strength .

As we know in the current generation people are losing the Possible grammar error found. Consider replacing it with
ir health in terms of physical or sexual health. "generation,".

Lot of people are not involved in any game because of that Possible grammar error found. Consider replacing it with
only they are losing their strength and in long term they ca "games.".
tch diseases easily and reducing their immune power.

Lot of people are not involved in any game because of that Possible grammar error found. Consider replacing it with
only they are losing their strength and in long term they ca "lose".
tch diseases easily and reducing their immune power.

© 2025 SHL and/or its affiliates. All rights reserved.. 27/29

Lot of people are not involved in any game because of that Possible grammar error found. Consider inserting "the"
only they are losing their strength and in long term they ca over here.
tch diseases easily and reducing their immune power.

Lot of people are not involved in any game because of that Possible grammar error found. Consider replacing it with
only they are losing their strength and in long term they ca "term,".
tch diseases easily and reducing their immune power.

Lot of people are not involved in any game because of that Possible grammar error found. Consider replacing it with
only they are losing their strength and in long term they ca "reduce".
tch diseases easily and reducing their immune power.

As we see if child is enrolled in any game then he can also Possible grammar error found. Consider inserting "a" over
be set as an example to whole country after bringing gold here.
medals for our country and it would be a proud moment fo
r our country.

As we see if child is enrolled in any game then he can also Possible grammar error found. Consider replacing it with
be set as an example to whole country after bringing gold "game,".
medals for our country and it would be a proud moment fo
r our country.

As we see if child is enrolled in any game then he can also Possible grammar error found. Consider inserting "the"
be set as an example to whole country after bringing gold over here.
medals for our country and it would be a proud moment fo
r our country.

As we see if child is enrolled in any game then he can also Possible grammar error found. Consider replacing it with
be set as an example to whole country after bringing gold "to".
medals for our country and it would be a proud moment fo
r our country.

Recently there was Champions Trophy 2025 organised by P Possible grammar error found. Consider inserting "the"
akistan in Dubai and in that our team India had achieved t over here.
hat trophy.

Recently there was Champions Trophy 2025 organised by P Possible grammar error found. Consider replacing it with
akistan in Dubai and in that our team India had achieved t "team,".
hat trophy.

Recently there was Champions Trophy 2025 organised by P Possible grammar error found. Consider replacing it with
akistan in Dubai and in that our team India had achieved t "India,".
hat trophy.

Recently there was Champions Trophy 2025 organised by P Possible grammar error found. Consider replacing it with
akistan in Dubai and in that our team India had achieved t "won".
hat trophy.

It was the great moment in our country. Possible grammar error found. Consider replacing it with
"a".

Everyone in our country were too much excited and enjoye Possible grammar error found. Consider inserting "it" over
d a lot. here.

So as concluding parents should involve their child in any s Possible grammar error found. Consider replacing it with
port as it will boost them in any field of life. "in".

© 2025 SHL and/or its affiliates. All rights reserved.. 28/29

4 Learning Resources

English Comprehension

Learn about spoken english comprehension

Test your comprehension skills

Improve your reading skills by reading novels

Logical Ability

Practice inductive reasoning on visual data

Learn about pattern identification

Practice your Inductive Reasoning Skills!

Quantitative Ability (Advanced)

Learn about simple and compount interests

Watch a video on time, speed and distance

Learn about percentages

Icon Index

Free Tutorial Paid Tutorial Youtube Video Web Source

Wikipedia Text Tutorial Video Tutorial Google Playstore

© 2025 SHL and/or its affiliates. All rights reserved.. 29/29