Aditya Bansul

Test ID: 432007924000032 9022249615 [email protected]

Test Date: November 18, 2024

Computer Science Logical Ability Data Science Node.js

78 /100 63 /100 67 /100 21 /100

Quantitative Ability English Comprehension ReactJS Automata Fix

(Advanced)

74 /100 64 /100 33 /100 0 /100

Automata Pro Personality

4 /100
Completed

Computer Science 78 / 100

OS and Computer Architecture DBMS Computer Networks

88 / 100 72 / 100 60 / 100

Logical Ability 63 / 100

Inductive Reasoning Deductive Reasoning Abductive Reasoning

63 / 100 72 / 100 55 / 100

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

Data Science 67 / 100

ML Algorithms and Implementation Probability and Statistics ML Experiments

60 / 100 50 / 100 100 / 100

Node.js 21 / 100

Basics and Events File Systems and Error Handling DB, Server and Testing

0 / 100 31 / 100 31 / 100

Quantitative Ability (Advanced) 74 / 100

Basic Mathematics Advanced Mathematics Applied Mathematics

77 / 100 66 / 100 80 / 100

English Comprehension 64 / 100 CEFR: B2

Grammar Vocabulary Comprehension

66 / 100 70 / 100 57 / 100

ReactJS 33 / 100

React Basics Components and Styling Forms and Routing

50 / 100 20 / 100 33 / 100

Automata Fix 0 / 100

Logical Error Syntactical Error Code Reuse

0 / 100 0 / 100 0 / 100

Automata Pro 4 / 100

Programming Ability Programming Practices Functional Correctness

10 / 100 0 / 100 10 / 100

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

Personality Completed

100
People Interaction
75
80 72

61
60 Self-Drive
43 41
36
40

Trainability
20

0
Repetitive Job Suitability
Conscientiousness Openness to Experience Polychronicity

Extraversion Agreeableness Emotional Stability

Competencies Work attributes

© 2024 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

© 2024 SHL and/or its affiliates. All rights reserved.. 4/30

2 Insights

English Comprehension 64 / 100 CEFR: B2

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

You have a good understanding of commonly used grammatical constructs. You are able to read and understand
articles, reports and letters/mails related to your day-to-day work. The ability to read, understand and interpret
business-related documents is essential in most jobs, especially the ones that involve research, technical reading and
content writing.

Logical Ability 63 / 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 72 / 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 55 / 100

Quantitative Ability (Advanced) 74 / 100

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

You have a strong hold on basic arithmetic and concepts of algebra. You are able to convert real-world problems into
equations and solve them.

Personality

Competencies

© 2024 SHL and/or its affiliates. All rights reserved.. 5/30

 61

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.

72

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.

43

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.
• You are more inclined to strike a compromise in tough situations and may be suitable for jobs
that demand managing expectations among different stakeholders.

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

 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.

75

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.

Node.js 21 / 100

© 2024 SHL and/or its affiliates. All rights reserved.. 7/30

 • You are aware of the basic syntax and structure of Node.js but needs to put in substantial effort to improve
your conceptual knowledge and understanding of algorithms.
• You should start by trying to write small programs to improve your programming skills.

ReactJS 33 / 100

© 2024 SHL and/or its affiliates. All rights reserved.. 8/30

3 Response

Automata Pro 4 / 100 Code Replay

Question 1 (Language: C)

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.

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

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

20 / 100
The source code does not pass any basic test cases. It is either
due to incorrect logic or runtime errors. 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(N logN)

8 typedef struct String string;

9 struct String *N represents number of projects

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

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

14 char *input(FILE *fp, int size, int has_space) Structural Vulnerabilites and Errors
15 {
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)
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 = (char *)realloc(str, sizeof(char) * 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 = (char *)realloc(str, sizeof(char) * size);
40 }
41 }
42 }
43 actual_size++;
44 str = (char *)realloc(str, sizeof(char) * 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 *
60 */
61 int workingWeeks(array_single_int projC)
62 {
63 int answer;
© 2024 SHL and/or its affiliates. All rights reserved.. 10/30
 64 // Write your code here
65
66
67 return answer;
68 }
69
70 int main()
71 {
72 array_single_int projC;
73
74 //input for projC
75 scanf("%d", &projC.size);
76 projC.data = (int *)malloc(sizeof(int) * projC.size);
77 for ( int idx = 0; idx < projC.size; idx++ )
78 {
79 scanf("%d", &projC.data[idx]);
80 }
81
82
83 int result = workingWeeks(projC);
84 printf("%d", result);
85
86 return 0;
87 }
88
Test Case Execution Passed TC: 0%

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

Compilation Statistics

2 2 0 0 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:09:04

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

Average test case pass percentage per compile: 0%

© 2024 SHL and/or its affiliates. All rights reserved.. 11/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 2 (Language: C)

The owner of a chocolate shop uses a machine which takes a few minutes to make one box of chocolates ready for
delivery. They receive an order for some boxes of chocolates which they need to deliver as soon as possible. The
owner has a fixed amount of money to spend in order to make and deliver these boxes. To complete the order, the
owner can either purchase chocolate boxes from another shop, purchase a new efficient machine, or try to employ
both the options together. If the owner purchases a new machine, the owner will no longer have access to the old
machine.

Write an algorithm to find the minimum time in which the owner can deliver the order.

Scores

Programming Ability Programming Practices

0 / 100 0 / 100
NA 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

0 / 100
NA

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

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(N logN)

8 typedef struct String string;

9 struct String *N represents amount of money.

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

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

50 typedef struct array_double_int array_double_int;
51 struct array_double_int
52 {
53 int **data;
54 int row;
55 int col;
56 };
57
58
59 /*
60 * numOfBox is the number of boxes that William has to deliver.
61 prepTime is the time required to prepare one box of candy using th
e machine.
62 money is the money that he can spend.
63 machinesChar is matrix where every row represents time required
by the machine to create a box and the cost of the machine.
64 shopChar is a matrix where each row represents the number of bo
xes available in the shop and the cost to buy them.
65 */
66 int minTime(int numOfBox, int prepTime, int money, array_double_
int machinesChar, array_double_int shopChar)
67 {
68 int answer;
69 // Write your code here
70
71
72 return answer;
73 }
74
75 int main()
76 {
77 int numOfBox;
78 int prepTime;
79 int money;
80 array_double_int machinesChar;
81 array_double_int shopChar;
82
83 //input for numOfBox
84 scanf("%d", &numOfBox);
85
86 //input for prepTime
87 scanf("%d", &prepTime);
88
89 //input for money
90 scanf("%d", &money);
91
92 //input for machinesChar
93 scanf("%d", &machinesChar.row);
94 scanf("%d", &machinesChar.col);
95 machinesChar.data = (int **)malloc(sizeof(int *) * machinesChar.r
ow);

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

 96 for ( int idx = 0; idx < machinesChar.row; idx++ )
97 {
98 machinesChar.data[idx] = (int *)malloc(sizeof(int) * machinesCh
ar.col);
99 for ( int jdx = 0; jdx < machinesChar.col; jdx++ )
100 {
101 scanf("%d", &machinesChar.data[idx][jdx]);
102 }
103 }
104
105 //input for shopChar
106 scanf("%d", &shopChar.row);
107 scanf("%d", &shopChar.col);
108 shopChar.data = (int **)malloc(sizeof(int *) * shopChar.row);
109 for ( int idx = 0; idx < shopChar.row; idx++ )
110 {
111 shopChar.data[idx] = (int *)malloc(sizeof(int) * shopChar.col);
112 for ( int jdx = 0; jdx < shopChar.col; jdx++ )
113 {
114 scanf("%d", &shopChar.data[idx][jdx]);
115 }
116 }
117
118
119 int result = minTime(numOfBox, prepTime, money, machinesCha
r, shopChar);
120 printf("%d", result);
121
122 return 0;
123 }
124
Test Case Execution Passed TC: 0%

Total score
0% 0% 0%
0/20 Basic(0/8) Advance(0/10) Edge(0/2)

Compilation Statistics

0 0 0 0 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:00:15

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

Average test case pass percentage per compile: 0%

© 2024 SHL and/or its affiliates. All rights reserved.. 15/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 countOccurrence return an integer representing the count of occurrences of given value in the
input list.
The function/method countOccurrence accepts three arguments - len, an integer representing the size of the input
list, value, an integer representing the given value and arr, a list of integers, representing the input list.

The function/method countOccurrence 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

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 int countOccurrence( int len, int value, 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 = 0 , count = 0;
7 while( i < len ) Best case code:

8 {
9 if( arr[i] == value )
*N represents

count += 1;

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

 10 Errors/Warnings
11 }
12 return count; There are no errors in the candidate's code.
13 }
14 } Structural Vulnerabilites and Errors

There are no errors in the candidate's code.

Test Case Execution Passed TC: 11.11%

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

Compilation Statistics

1 1 0 1 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:03:30

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

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)

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

The function/method manchester print space-separated integers with the following property: for each element in the
input list arr, if the bit arr[i] is the same as arr[i-1], then the element of the output list is 0. If they are different, then
its 1. For the first bit in the input list, assume its previous bit to be 0. This encoding is stored in a new list.

The function/method manchester accepts two arguments - len, an integer representing the length of the list and
arr and arr, a list of integers, respectively. Each element of arr represents a bit - 0 or 1

For example - if arr is {0 1 0 0 1 1 1 0}, the function/method should print an list {0 1 1 0 1 0 0 1}.

The function/method compiles successfully but fails to print 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 manchester(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 res[] = new int[len];
7 boolean result; Best case code:

8 res [0] = arr [0];

9 for(int i = 1 ; i < len; i ++ ) *N represents

10 {
11 result = ( arr[i] == arr[i-1] ); Errors/Warnings
12 res[i] = (result) ? 1 : 0;
13 } There are no errors in the candidate's code.

14 for(int i = 0; i < len; i++)

15 System.out.print(res[i]+" ");
Structural Vulnerabilites and Errors

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

17 }
Test Case Execution Passed TC: 20%

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

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

 Compilation Statistics

1 1 0 1 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:00:11

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

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

The function/method multiplyNumber returns an integer representing the multiplicative product of the maximum two
of three input numbers. The function/method multiplyNumber accepts three integers- numA, numB and numC,
representing the input numbers.

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

Scores

Final Code Submitted Compilation Status: Fail Code Analysis

1 // You can print the values to stdout for debugging Average-case Time Complexity
2 class Solution
© 2024 SHL and/or its affiliates. All rights reserved.. 19/30
 3{
4 int multiplyNumber(int numA, int numB, int numC) Candidate code: Complexity is reported only when the code
is correct and it passes all the basic and advanced test
5 { cases.
6 int result,min,max,mid;
7 max=(numA>numB)?numA>numC)?numA:numC):(numB>num Best case code:
C)?numB:numC);
8 min=(numA<numB)?((numA<numC)?numA:numC):((numB<nu *N represents
mC)?numB:numC);
9 mid=(numA+numB+numC)-(min+max); Errors/Warnings
10 result=(max*int mid);
11 return result;
12 } Solution.java:7: error: : expected
13 } max=(numA>numB)?numA>numC)?numA:numC):
14 (numB>numC)?numB:numC);

15 ^
Solution.java:7: error: ';' expected
max=(numA>numB)?numA>numC)?numA:numC):
(numB>numC)?numB:numC);
^
Solution.java:7: error: not a statement
max=(numA>numB)?numA>numC)?numA:numC):
(numB>numC)?numB:numC);
^
Solution.java:7: error: ';' expected
max=(numA>numB)?numA>numC)?numA:numC):
(numB>numC)?numB:numC);
^
Solution.java:7: error: not a statement
max=(numA>numB)?numA>numC)?numA:numC):
(numB>numC)?numB:numC);
^
Solution.java:7: error: ';' expected
max=(numA>numB)?numA>numC)?numA:numC):
(numB>numC)?numB:numC);
^
Solution.java:10: error: '.class' expected
result=(max*int mid);
^
Solution.java:10: error: ';' expected
result=(max*int mid);
^
8 errors

Structural Vulnerabilites and Errors

There are no errors in the candidate's code.

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

Compilation Statistics

0 0 0 0 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:00:02

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

Question 4 (Language: Java)

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

The function/method isRightTriangle returns an integer '1', if the points make a right-angled triangle otherwise return
'0'.
The function/method isRightTriangle accepts three points - P1, P2, P3 representing the input points.

You are supposed to use the given function to complete the code of the function/method isRightTriangle so that it
passes all test cases.

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

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

public class Point

public int x, y;

public Point()

{}

public Point(int x1, int y1)

x = x1 ;

y = y1 ;

public double calculateDistance(Point P)

/*Return the euclidean distance between two input points.

This can be called as -

* If P1 and P2 are two points then -

* P1.calculateDistance(P2);*/

Scores

Final Code Submitted Compilation Status: Fail Code Analysis

1 // You can print the values to stdout for debugging Average-case Time Complexity
2 public class Solution
3{
4 int isRightTriangle(Point P1, Point P2, Point P3) 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 } Best case code:

8}
9 *N represents

Errors/Warnings

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

 Solution.java:7: error: missing return statement
}
^
1 error

Structural Vulnerabilites and Errors

There are no errors in the candidate's code.

Compilation Statistics

0 0 0 0 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:00:02

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

Question 5 (Language: Java)

The function/method sameElementCount returns an integer representing the number of elements of the input list
which are even numbers and equal to the element to its right. For example, if the input list is [4 4 4 1 8 4 1 1 2 2]
then the function/method should return the output '3' as it has three similar groups i.e, (4, 4), (4, 4), (2, 2).

The function/method sameElementCount accepts two arguments - size, an integer representing the size of the input

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

list and inputList, a list of integers representing the input list.

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

Note:
In a list, an element at index i is considered to be on the left of index i+1 and to the right of index i-1. The last
element of the input list does not have any element next to it which makes it incapable to satisfy the second condition
and hence should not be counted.

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 sameElementCount(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 count =0;
7 for(int i=0;i<size-1;i++) Best case code:

8 {
9 if((inputList[i]%2==0)&&(inputList[i]==inputList[i++]))
*N represents

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

14 } Structural Vulnerabilites and Errors

There are no errors in the candidate's code.

Test Case Execution Passed TC: 50%

Total score
43% 0% 100%
4/8 Basic(3/7) Advance(0/0) Edge(1/1)

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

Compilation Statistics

0 0 0 1 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: 50%

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 drawPrintPattern accepts num, an integer.

The function/method drawPrintPattern prints the first num lines of the pattern shown below.

For example, if num = 3, the pattern should be:

11
1111
111111

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

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

Final Code Submitted Compilation Status: Pass Code Analysis

1 // You can print the values to stdout for debugging Average-case Time Complexity
2 public class Solution
3{
4 void drawPrintPattern(int num) 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,print = 1;
7 for(i=1;i<=num;i++) Best case code:

8 {
9 for(j=1;j<=2*i;j++);
*N represents

10 {
11 System.out.print(print+" "); Errors/Warnings
12 }
13 System.out.println(); 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 }
18
Test Case Execution Passed TC: 12.5%

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

Compilation Statistics

0 0 0 1 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: 12.5%

© 2024 SHL and/or its affiliates. All rights reserved.. 26/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 7 (Language: Java)

The function/method median accepts two arguments - size and inputList, an integer representing the length of a list
and a list of integers, respectively.

The function/method median is supposed to calculate and return an integer representing the median of elements in
the input list. However, the function/method median works only for odd-length lists because of incomplete code.

You must complete the code to make it work for even-length lists as well. A couple of other functions/methods are
available, which you are supposed to use inside the function/method median to complete the code.

Helper Description

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

class MedianCalculate

public int[] items;

public int first;

public int last;

public int order;

int quick_select()

/*It calculate the median value

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

 / It calculate the median value

This can be called as -

MedianCalculate ob = new MedianCalculate(inputList, start_index, end_index, median_order);

int res = ob.quick_select();

where median_order is the half length of the inputList */

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 median(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 start_index = 0;
7 int end_index = size-1; Best case code:

8 float res = -1;

9 if(size%2!=0) // odd length arrays *N represents

10 {
11 int median_order = ((size +1)/2); Errors/Warnings
12 MedianCalculate ob = new MedianCalculate(inputList, start_i
There are no errors in the candidate's code.
ndex, end_index, median_order);
13 res = ob.quick_select();
14 } Structural Vulnerabilites and Errors

15 else // even length arrays

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

17 // Write code here

18 }
19 return res;
20 }
21 }
Test Case Execution Passed TC: 42.86%

Total score
50% 0% 100%
3/7 Basic(2/4) Advance(0/2) Edge(1/1)

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

Compilation Statistics

0 0 0 1 0 0

Total attempts Successful Compilation errors Sample failed Timed out Runtime errors

Response time: 00:00:02

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

Average test case pass percentage per compile: 42.9%

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

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

4 Learning Resources

English Comprehension

Read opinions to improve your comprehension

Improve your vocabulary of terms used in business

Improve your knowledge of Business English

Logical Ability

Learn about pattern identification

Practice your Inductive Reasoning Skills!

Take a course on advanced logic

Quantitative Ability (Advanced)

Watch a video on probability

Learn about the basics of permutations and combinations

Learn about logarithms

Icon Index

Free Tutorial Paid Tutorial Youtube Video Web Source

Wikipedia Text Tutorial Video Tutorial Google Playstore

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