Merge pull request #8 from sir-gon/compare_triplets

Compare triplets

Author: sir-gon

docs/hackerrank/warmup/compare_triplets.md

@@ -0,0 +1,104 @@
+# [Compare the Triplets](https://www.hackerrank.com/challenges/compare-the-triplets)
+
+Difficulty: #easy
+Category: #warmup
+
+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 \leq a[i] \leq 100 $
+- $ 1 \leq b[i] \leq 100 $
+
+## Sample Input 0
+
+```text
+5 6 7
+3 6 10
+```
+
+## Sample Output 0
+
+```text
+1 1
+```
+
+## Explanation 0
+
+In this example:
+
+- $ a = (a[0], a[1], a[2]) = (5, 6, 7) $
+- $ b = (b[0], b[1], b[2]) = (3, 6, 10) $
+
+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 $ 1 $ point.
+
+Alice's comparison score is $ 1 $, and Bob's comparison score is $ 1 $.
+Thus, we return the array $ [1, 1] $.
+
+## Sample Input 1
+
+```text
+17 28 30
+99 16 8
+```
+
+## Sample Output 1
+
+```text
+2 1
+```
+
+## Explanation 1
+
+Comparing the *0th* elements, $ 17 < 99 $ 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] $.

src/lib/exercises/include/exercises/basic/common.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))

src/lib/exercises/include/exercises/hackerrank/warmup/compare_triplets.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int *HACKERRANK_WARMUP_compareTriplets(int a_count, const int *a, int b_count,
+                                       const int *b, int *result_count);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

src/lib/exercises/src/hackerrank/warmup/compare_triplets.c

@@ -0,0 +1,29 @@
+#include <stdlib.h>
+
+#include <exercises/basic/common.h>
+#include <exercises/hackerrank/warmup/compare_triplets.h>
+
+/**
+ * @link Problem definition [[docs/hackerrank/warmup/compare_triplets.md]]
+ */
+
+int *HACKERRANK_WARMUP_compareTriplets(int a_count, const int *a, int b_count,
+                                       const int *b, int *result_count) {
+
+  *result_count = 2;
+  int *awards = malloc(sizeof(int) * *result_count);
+
+  awards[0] = 0;
+  awards[1] = 0;
+
+  for (int i = 0; i < MIN(a_count, b_count); i++) {
+    if (a[i] > b[i]) {
+      awards[0] = awards[0] + 1;
+    }
+    if (a[i] < b[i]) {
+      awards[1] = awards[1] + 1;
+    }
+  }
+
+  return awards;
+}

src/tests/unit/lib/hackerrank/warmup/compare_triplets.test.cpp

@@ -0,0 +1,44 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include <exercises/hackerrank/warmup/compare_triplets.h>
+#include <iostream>
+#include <vector>
+
+#include <filesystem>
+#include <fstream>
+#include <nlohmann/json.hpp>
+using json = nlohmann::json;
+
+TEST_CASE("compareTriplets JSON Test Cases",
+          "[hackerrank] [jsontestcase] [warmup]") {
+  std::filesystem::path cwd = std::filesystem::current_path();
+  std::string path =
+      cwd.string() +
+      "/unit/lib/hackerrank/warmup/compare_triplets.testcases.json";
+
+  INFO("compareTriplets JSON test cases FILE: " << path);
+
+  std::ifstream f(path);
+  json data = json::parse(f);
+
+  for (auto testcase : data) {
+    auto a_size = static_cast<int>(testcase["a"].size());
+    std::vector<int> a_input_vector = testcase["a"];
+    const int *a_input_array = a_input_vector.data();
+
+    auto b_size = static_cast<int>(testcase["b"].size());
+    std::vector<int> b_input_vector = testcase["b"];
+    const int *b_input_array = b_input_vector.data();
+    int result_count;
+
+    int *result = HACKERRANK_WARMUP_compareTriplets(
+        a_size, a_input_array, b_size, b_input_array, &result_count);
+
+    // Crear un vector a partir del array en C
+    std::vector<int> result_as_vector(result, result + result_count);
+
+    CHECK(result_as_vector == testcase["expected"]);
+
+    free(result);
+  }
+}

src/tests/unit/lib/hackerrank/warmup/compare_triplets.testcases.json

@@ -0,0 +1,6 @@
+[
+  { "a": [5, 6, 7], "b": [3, 6, 10], "expected": [1, 1] },
+  { "a": [], "b": [], "expected": [0, 0] },
+  { "a": [1], "b": [], "expected": [0, 0] },
+  { "a": [], "b": [1], "expected": [0, 0] }
+]