Avinash Maurya

Test ID: 450011319000767 7084404086 [email protected]

Test Date: April 9, 2025

Computer Science Logical Ability Computer Programming Quantitative Ability

(Advanced)

49 /100 69 /100 54 /100 50 /100

English Comprehension WriteX - Essay Writing Automata Automata Fix

49 /100 5 /100 79 /100 0 /100

Personality

Completed

Computer Science 49 / 100

OS and Computer Architecture DBMS Computer Networks

60 / 100 22 / 100 54 / 100

Logical Ability 69 / 100

Inductive Reasoning Deductive Reasoning Abductive Reasoning

70 / 100 75 / 100 61 / 100

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

Computer Programming 54 / 100

Basic Programming Data Structures OOP and Complexity Theory

52 / 100 52 / 100 57 / 100

Quantitative Ability (Advanced) 50 / 100

Basic Mathematics Advanced Mathematics Applied Mathematics

48 / 100 40 / 100 62 / 100

English Comprehension 49 / 100 CEFR: B1

Grammar Vocabulary Comprehension

57 / 100 45 / 100 45 / 100

WriteX - Essay Writing 5 / 100 CEFR: A1

Content Score Grammar Score

5 / 100 5 / 100

Automata 79 / 100

Programming Ability Programming Practices Functional Correctness

80 / 100 75 / 100 47 / 100

Automata Fix 0 / 100

Syntactical Error Code Reuse Logical Error

0 / 100 0 / 100 0 / 100

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

Personality Completed

100 92
People Interaction

80

60 Self-Drive
41
36
40
24
Trainability
20 9 9

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/30

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/30

2 Insights

English Comprehension 49 / 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 70 / 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 75 / 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 61 / 100

Quantitative Ability (Advanced) 50 / 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/30

 24

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 feel comfortable spending time by yourself.

• You prefer spending time alone rather than in social gatherings.
• You may not enjoy activities that involve thrill and excitement.
• You are thoughtful, introspective and refrains from impulsive remarks/actions. You often keep
your opinions and ideas to yourself
• You prefer to work on individual projects rather than group projects.
• You are more likely to prefer jobs that require minimal interaction with people.

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 have an easy going attitude towards work.

• You tend to act spontaneously and may prefer to get started on a project or at work without
laying out an organized plan.
• You tend to make quick decisions rather than spending time on reviewing the facts at hand.
• You have a flexible and spontaneous approach to work and is less likely to adhere to strict
guidelines and policies.
• You sometimes feel insecure about your capabilities and could benefit from emotional support.
• You are likely to be content with your level of achievement and may not strive to achieve more.
• Your personality is more suited for jobs which demand fast results and are not as concerned
with attention to detail.

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 outspoken. You often play the role of a devil's advocate in discussions and question
others' opinions and views.
• You are not gullible and are likely to carefully examine the situation before trusting
something/someone.
• You may not be strongly affected by human suffering and may be perceived as indifferent.
• You are confident of your achievements and do not shy away from talking about them.

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

 • You sometimes place self-interest above the needs of those around you. You are not willing to
compromise your own views in order to accommodate the views of others.
• You are suitable for jobs that require tough objective decisions and hard negotiation.

41

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.

36

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 calm and relaxed in most situations.

• You experience a range of emotions in high pressure situations. You tend to worry when
working in critical conditions.
• You do not like attention drawn towards you. You take some time to become confident and
comfortable around people.
• You subdue your impulses and tend to act in a rational manner.
• Your personality is suited for jobs that have a moderate amount of stress.

92

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/30

© 2025 SHL and/or its affiliates. All rights reserved.. 8/30
3 Response

Automata 79 / 100 Code Replay

Question 1 (Language: Java)

A company wants to provide a cab service for their N employees. The employees have IDs ranging from 0 to N-1. The
company has calculated the total distance from an employee's residence to the company, considering the path to be
followed by the cab to be a straight path. The distance to the company from itself is 0. The distance for the employees
who live to the left side of the company is represented with a negative sign. The distance for the employees who live
to the right side of the company is represented with a positive sign. The cab will be allotted a range of distance. The
company wants to find the distance for the employees who live within the particular distance range.

Write an algorithm to find the distance for the employees who live within the distance range.

Scores

Programming Ability Programming Practices

80 / 100 50 / 100
Correct with inadvertent errors. Correct control structures and High readability, low on program structure. The source code
critical data dependencies incorporated. Some inadvertent errors contains redundant/improper coding constructs and a few
make the code fail test cases. readability and formatting issues.

Functional Correctness

66 / 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.

Final Code Submitted Compilation Status: Pass Code Analysis

1 import java.util.*; Average-case Time Complexity

2 import java.lang.*;
3 import java.io.*;
4 Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 /* cases.
6*
7 */ Best case code: O(N logN)

8 public class Solution

9{ *N represents size of the list

10 public static int[] funcDistance(int[] inputDist, int start, int end)

11 { Errors/Warnings
12 int[] answer = new int[100];
13 // Write your code here There are no errors in the candidate's code.

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

14 int j=0; Structural Vulnerabilites and Errors
15 for(int i =0;i<inputDist.length;i++){
16 if(inputDist[i]>=0 && inputDist[i]>=start && inputDist[i]<=en Readability & Language Best Practices
d){
17 answer[j]=inputDist[i];
Line 14: Variables are given very short names.

18 j++;
19 }
Performance & Correctness

20 if(inputDist[i]<0 && (-1*inputDist[i])>=start && (-1*inputDist Line 30: System.arraycopy is more efficient
[i])<=end){
21 answer[j]=inputDist[i];
22 j++;
23 }
24 }
25 if(j==0){
26 answer[j]=-1;
27 }
28
29 int[] ans2= new int[j];
30 for(int i=0;i<j;i++){
31 ans2[i]=answer[i];
32 }
33
34 return ans2;
35 }
36
37 public static void main(String[] args)
38 {
39 Scanner in = new Scanner(System.in);
40 //input for inputDist
41 int inputDist_size = in.nextInt();
42 int inputDist[] = new int[inputDist_size];
43 for(int idx = 0; idx < inputDist_size; idx++)
44 {
45 inputDist[idx] = in.nextInt();
46 }
47 // input for start
48 int start = in.nextInt();
49
50 // input for end
51 int end = in.nextInt();
52
53
54 int[] result = funcDistance(inputDist, start, end);
55 for(int idx = 0; idx < result.length - 1; idx++)
56 {
57 System.out.print(result[idx] + " ");
58 }
59 System.out.print(result[result.length - 1]);
60 }
61 }

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

 62
Test Case Execution Passed TC: 83.33%

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

Compilation Statistics

4 4 0 0 0 4

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:13:57

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

Average test case pass percentage per compile: 20.83%

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: Java)

An employee in a company has begun working on N projects (numbered 0 to N-1). Each week an employee can work
on a single module of one of the projects. The modules that are chosen on any two successive weeks should come
from different projects. A project i can have at most Ci modules. The modules of the projects are such that a module is
completed in a week.

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

Write an algorithm to find the number of weeks during which the employee can work on projects following the above-
mentioned rules.

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

28 / 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 import java.util.*; Average-case Time Complexity

2 import java.lang.*;
3 import java.io.*;
4 Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 /* cases.
6*
7 */ Best case code: O(N logN)

8 public class Solution

9{ *N represents number of projects

10 public static int workingWeeks(int[] projC)

11 { Errors/Warnings
12 int answer = 0;
13 // Write your code here There are no errors in the candidate's code.

14 Arrays.sort(projC);
15 // for(int i=0;i<projC.length;i++){ Structural Vulnerabilites and Errors

16 // answer+=projC[i]; There are no errors in the candidate's code.

17 // }
18
19 int left=0;
20 int right=projC.length-1;
21 while(right>left){
22 if(projC[right]>0){
23 projC[right]--;
24 answer++;
25 }else{
26 right--;
27

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

 28 }
29 if(projC[left]>0){
30 projC[left]--;
31 answer++;
32 }else{
33 left++;
34 continue;
35 }
36 }
37 return answer;
38 }
39
40 public static void main(String[] args)
41 {
42 Scanner in = new Scanner(System.in);
43 //input for projC
44 int projC_size = in.nextInt();
45 int projC[] = new int[projC_size];
46 for(int idx = 0; idx < projC_size; idx++)
47 {
48 projC[idx] = in.nextInt();
49 }
50
51 int result = workingWeeks(projC);
52 System.out.print(result);
53
54 }
55 }
56
Test Case Execution Passed TC: 30%

Total score
40% 0% 50%
3/10 Basic(2/5) Advance(0/3) Edge(1/2)

Compilation Statistics

7 6 1 0 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:25:56

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

Average test case pass percentage per compile: 17.14%

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

 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 Fix 0 / 100 Code Replay

Question 1 (Language: Java)

The function/method maxReplace prints space separated integers representing the input list after replacing all
elements of the input list with the maximum element of the input list.

The function/method maxReplace accept two arguments - size, an integer representing the size of the input list and
inputList, a list of integers representing the input list, respectively.

The function/method maxReplace compiles unsuccessfully due to compilation error. Your task is to debug 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 class Solution
3{
4 void maxReplace(int size, int[] inputList) Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 { int max=inputList[0]; cases.
6 for(int i=0;i<size;i++){
7 if(max<inputList[i]){ Best case code:

8 max=inputList[i];
9 }
*N represents

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

 10 Errors/Warnings
11 for(int i=0;i<size;i++){
12 System.out.print(max+" "); There are no errors in the candidate's code.
13 }
14 Structural Vulnerabilites and Errors

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

Test Case Execution Passed TC: 50%

Total score
57% 0% 0%
4/8 Basic(4/7) Advance(0/0) Edge(0/1)

Compilation Statistics

5 1 4 0 0 1

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:08:06

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

Average test case pass percentage per compile: 0%

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: Java)

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

You are given predefined structure Time containing hour, minute, and second as members. A collection of
functions/methods for performing some common operations on times is also available. You must make use of these
functions/methods to calculate and return the difference.

The function/method difference_in_times accepts two arguments - time1, and time2, representing two times and is
supposed to return an integer representing the difference in the number of seconds.

You must complete the code so that it passes all the test cases.

Helper Description

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

public class Time

public int hour;

public int minute;

public int second;

public Time(int h, int m, int s)

hour = h;

minute = m;

second = s;

public int compareTo(Object anotherTime)

/*Return 1, if time1 is greater than time2.

Return -1 if time1 is less than time2

or, Return 0, if time1 is equal to time2

This can be called as -

* If time1 and time2 are two Time then -

* time1.compareTo(time2) */

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

 public void addSecond()

/* Add one second in the time;

This can be called as -

* If time1 is Time then -

* time1.addSecond() */

Scores

Final Code Submitted Compilation Status: Pass Code Analysis

1 // You can print the values to stdout for debugging Average-case Time Complexity
2 class Solution
3{
4 int difference_in_times(Time time1, Time time2) Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 { cases.
6 // write your code here
7 int t1=time1.hour*60*60 + time1.minute*60 + time1.second; Best case code:

8 int t2=time2.hour*60*60 + time2.minute*60 + time2.second;

9 *N represents

10 if(t1<t2){
11 return t2-t1; Errors/Warnings
12 }else{
13 return t1-t2; There are no errors in the candidate's code.

14 }
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
80% 33% 100%
6/9 Basic(4/5) Advance(1/3) Edge(1/1)

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

Compilation Statistics

1 1 0 0 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:02:51

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

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: Java)

The function/method productMatrix accepts three arguments - rows, an integer representing the rows of the matrix;
columns, an integer representing the columns of the matrix and matrix, a two-dimensional array of integers,
respectively.

The function/method productMatrix return an integer representing the product of the odd elements whose ith and jth
index are the same. Otherwise, it returns 0.

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

Scores

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

Final Code Submitted Compilation Status: Pass Code Analysis
1 public class Solution Average-case Time Complexity
2{
3 public int productMatrix(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 result=1; cases.
6 for(int i=0;i<rows;i++)
7 for(int j=0;j<columns;j++) Best case code:

8 if((i==j) || (matrix[i][j]%2!=0))
9 result *=matrix[i][j];
*N represents

10 if(result<=1)
11 return 0; Errors/Warnings
12 else
13 return result; 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: 25%

Total score
20% 0% 100%
2/8 Basic(1/5) Advance(0/2) Edge(1/1)

Compilation Statistics

3 3 0 3 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:01:32

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

Average test case pass percentage per compile: 0%

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

 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: Java)

The function/method sortArray modify the input list by sorting its elements in descending order.
The function/method sortArray accepts two arguments - len, representing the length of the list and arr, a list of
integers representing the input list, respectively.

The function/method sortArray 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 class Solution
3{
4 public void sortArray(int len, int[] arr) Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 { cases.
6 int i , max , location , j , temp;
7 for( i = 0 ; i < len ; i ++ ) Best case code:

8 {
9 max = arr[i];
*N represents

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

14 {

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

 15 max = arr[j]; Structural Vulnerabilites and Errors
16 location = j;
17 } There are no errors in the candidate's code.
18 }
19 temp = arr[i];
20 arr[i] = arr[location];
21 arr[location] = temp;
22 }
23 for(int g=0;g<len/2;g++){
24 int temp2=arr[g];
25 arr[g]=arr[len-g-1];
26 arr[len-g-1]=temp2;
27 }
28 }
29 }
Test Case Execution Passed TC: 62.5%

Total score
33% 75% 100%
5/8 Basic(1/3) Advance(3/4) Edge(1/1)

Compilation Statistics

7 2 5 1 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:05:24

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

Average test case pass percentage per compile: 16.1%

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

 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: Java)

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 class is used to represent a Exponent and is already implemented in the default code (Do not write this
definition again in your code):

public class Exponent

public int base;

public int exponent;

int positiveExponent()

/*It calculate the Exponent for positive value of exponentValue

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

 This can be called as -

Exponent exp = new Exponent(baseValue, exponentValue);

float res = exp.positiveExponent();*/

Scores

Final Code Submitted Compilation Status: Pass Code Analysis

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

8 {
9 Exponent exp = new Exponent(baseValue, exponentValue);
*N represents

10 res = (float)exp.positiveExponent();
11 } Errors/Warnings
12 else
13 { There are no errors in the candidate's code.

14 // write your code here for negative exponentInput

15 }
Structural Vulnerabilites and Errors

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

17 }
18 }
Test Case Execution Passed TC: 33.33%

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

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

Compilation Statistics

0 0 0 1 1 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:00:44

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

Average test case pass percentage per compile: 33.3%

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: Java)

The function/method replaceValues is modifying the input list in such a way - if the length of input list is odd, then all
the elements of the input list are supposed to be replaced by 1s and in case it is even, the elements should be
replaced by 0s.

For example: given the input list [0 1 2], the function will modify the input list like [1 1 1]

The function/method replaceValues accepts two arguments - size, an integer representing the size of the given input
list and inputList, a list of integers representing the input list.

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

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

Scores

Final Code Submitted Compilation Status: Pass Code Analysis

1 // You can print the values to stdout for debugging Average-case Time Complexity
2 class Solution
3{
4 void replaceValues(int size, int[] inputList) Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 { cases.
6 int i , j;
7 if( size % 2 == 0 ) Best case code:

8 {
9 i=0;
*N represents

10 while(i<size)
11 { Errors/Warnings
12 inputList[i] = 0;
13 i+=2; There are no errors in the candidate's code.

14 }
15 }
Structural Vulnerabilites and Errors

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

17 {
18 j=0;
19 while(j<size)
20 {
21 inputList[j] = 1;
22 j+=2;
23 }
24 }
25 }
26 }
27
Test Case Execution Passed TC: 25%

Total score
0% 0% 100%
2/8 Basic(0/6) Advance(0/0) Edge(2/2)

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

Compilation Statistics

1 1 0 1 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:00:54

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

Average test case pass percentage per compile: 0%

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 7 (Language: Java)

The function/method calculateMatrixSum returns an integer representing the sum of odd elements of the given matrix
whose ith and jth index are the same.

The function/method calculateMatrixSum accepts three arguments - rows, an integer representing the number of rows
of the given matrix, columns, an integer representing the number of columns of the given matrix and matrix,
representing a two-dimensional array of integers.

The function/method calculateMatrixSum compiles successfully but fails to return 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

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

 The candidate did not make any changes in the code.

Compilation Statistics

0 0 0 0 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:00:00

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

Average test case pass percentage per compile: 0%

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 5 / 100 CEFR: A1

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

5 / 100 5 / 100

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

Response Error Summary

This is a good point for discussion, as mentioned some parents think that sports are go
Spelling 5
od while others think it is just a distraction. My openion is that sports is good for the h
ealth of children. Parents should understand that there is also a very good carrier in sp
orts too, but aaj kal ke parents does not understands these things and just stop there White Space 0
kids to go out and play. But there are also few parents who are very good and allow th
ere kids to
Style 0

Grammar 9

Typographical 0

Essay Statistics

85 4 21 55 44
Average sentence
Total words Total sentences Total unique words Total stop words
length

Error Details

Spelling

...hers think it is just a distraction. My openion is that spor Possible spelling mistake found
ts is good for the health o...

... a very good carrier in sports too, but aaj kal ke parents Possible spelling mistake found
does not understands the...

...ery good carrier in sports too, but aaj kal ke parents doe Possible spelling mistake found
s not understands these t...

...good carrier in sports too, but aaj kal ke parents does no Possible spelling mistake found
t understands these thin...

are very good and allow there kids Possible spelling mistake found. Consider replacing the
highlighted text with: 'their'.

Grammar

This is a good point for discussion, as mentioned some par Possible grammar error found. Consider replacing it with
ents think that sports are good while others think it is just "they".
a distraction.

This is a good point for discussion, as mentioned some par Possible grammar error found. Consider replacing it with
ents think that sports are good while others think it is just "are".
a distraction.

My openion is that sports is good for the health of children. Possible grammar error found. Consider replacing it with
"are".

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

Parents should understand that there is also a very good c Possible grammar error found. Consider replacing it with
arrier in sports too, but aaj kal ke parents does not unders "career".
tands these things and just stop there kids to go out and pl
ay.

Parents should understand that there is also a very good c Possible grammar error found. Consider replacing it with
arrier in sports too, but aaj kal ke parents does not unders "do".
tands these things and just stop there kids to go out and pl
ay.

Parents should understand that there is also a very good c Possible grammar error found. Consider replacing it with
arrier in sports too, but aaj kal ke parents does not unders "understand".
tands these things and just stop there kids to go out and pl
ay.

Parents should understand that there is also a very good c Possible grammar error found. Consider replacing it with
arrier in sports too, but aaj kal ke parents does not unders "their".
tands these things and just stop there kids to go out and pl
ay.

Parents should understand that there is also a very good c Possible grammar error found. Consider replacing it with
arrier in sports too, but aaj kal ke parents does not unders "from".
tands these things and just stop there kids to go out and pl
ay.

Parents should understand that there is also a very good c Possible grammar error found. Consider replacing it with
arrier in sports too, but aaj kal ke parents does not unders "going".
tands these things and just stop there kids to go out and pl
ay.

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

4 Learning Resources

English Comprehension

Learn about written english comprehension

Learn about spoken english comprehension

Test your comprehension skills

Logical Ability

Watch a video on the art of deduction

Learn about Sherlock Holmes' puzzles and develop your deductive logic

Take a course on advanced logic

Quantitative Ability (Advanced)

Learn about percentages

Learn about simple and compount interests

Watch a video on time, speed and distance

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.. 30/30