# Compare the Triplets

# Introduction

This problem requires a little thinking, but is considered basic amongst advanced programmers . This problem tests your understanding of array patterns, which is a good skill to have to become a top developer. The solution would come naturally to those in the data science related fields. So, without wasting too much time, lets get into the problem statement.

**Problem Statement**

Alice and Bob each created one problem for HackerRank. A reviewer rates the two challenges, awarding points on a scale from *1* to *100* for three categories: *problem clarity*, *originality*, and *difficulty*.

The rating for Alice’s challenge is the triplet *a = (a[0], a[1], a[2])*, and the rating for Bob’s challenge is the triplet *b = (b[0], b[1], b[2])*.

The task is to find their *comparison points* by comparing *a[0]* with *b[0]*, *a[1]* with *b[1]*, and *a[2]* with *b[2]*.

- If
*a[i] > b[i]*, then Alice is awarded*1*point. - If
*a[i] < b[i]*, then Bob is awarded*1*point. - If
*a[i] = b[i]*, then neither person receives a point.

Comparison points is the total points a person earned.

Given *a* and *b*, determine their respective comparison points.

**Example**

*a = [1, 2, 3]*

*b = [3, 2, 1]*

- For elements *0*, Bob is awarded a point because
*a[0] .* - For the equal elements
*a[1]*and*b[1]*, no points are earned. - Finally, for elements
*2*,*a[2] > b[2]*so Alice receives a point.

*The return array is [1, 1] with Alice’s score first and Bob’s second.*

*Function Description*

*Complete the function compareTriplets in the editor below.*

*compareTriplets has the following parameter(s):*

*int a[3]*: Alice’s challenge rating*int b[3]*: Bob’s challenge rating

*Return*

*int[2]*: Alice’s score is in the first position, and Bob’s score is in the second.

**Input Format**

The first line contains *3* space-separated integers, *a[0]*, *a[1]*, and *a[2]*, the respective values in triplet *a*.

The second line contains *3* space-separated integers, *b[0]*, *b[1]*, and *b[2]*, the respective values in triplet *b*.

**Constraints**

*1 ≤ a[i] ≤ 100**1 ≤ b[i] ≤ 100*

**Sample Input 0**

`5 6 7`

3 6 10

**Sample Output 0**

`1 1`

**Explanation 0**

In this example:

- a = (a[0],a[1],a[2]=(5,6,7))
- b = (b[0],b[1],b[2]=(5,6,7))

Now, let’s compare each individual score:

- a[0] > b[0], so Alice receives 1 point.
- a[1] = b[1], so nobody receives a point.
- a[2] < b[2], so Bob receives apoint.

Alice’s comparison score is 1, and Bob’s comparison score is 1. Thus, we return the array [1,1].

**Sample Input 1**

`17 28 30`

99 16 8

**Sample Output 1**

`2 1`

**Explanation 1**

Comparing the 0th elements, 17 < 19 so Bob receives a point.

Comparing the 1st and 2nd elements,28 > 16 and 30 > 8 so Alice receives two points.

The return array is [2,1].

# Solution

defcompareTriplets(a, b):"""zip the values of a and b together.This is where python shines.It has the simplest implementation of zipping two arrays."""zipped_scores =zip(a,b)### intialize alice and bob's scores to zero.solution_score = [0,0]## iterate through the solution scores to assign pointsfora_score,b_scoreinzipped_scores:## check if alice has the greater score and award alice a pointifa_score > b_score:solution_score[0] += 1## check if bob has the greater score and award bob a pointelifb_score > a_score:solution_score[1] += 1## otherwise their scores are probably equal and neither gets a point and we move on the next scores.else:"""while using the pass key word is useful to mark the time or skip an execution. while it has in this case been used in a situation where we want the code to do nothing. Note that it is mostly used as a placeholder for code that has not yet been written and will soon be used but aids in the design process."""pass## return the solution list to complete the challenge.returnsolution_score"""

time complexity = O(1)

space complexity = O(1)"""

# Conclusion

As you can tell the performance of the algorithm is really good. To be quite honest it’s less to do with the sophistication of the algorithm and more with simplicity of the problem . Should the number of comparable scores be variable the time complexity is easily O(n), while the space complexity would remain the same. Make sure to understand this solution as it will be a step further towards your goal of becoming a good programmer. For any questions on the solution feel free to reach out. Remeber to follow for more solutions on algorithmic problems.