[Hacker Rank] Warmup: Time Conversion solved ✅

Author: Gonzalo Diaz

docs/hackerrank/warmup/time_conversion.md

@@ -0,0 +1,53 @@
+# [Time Conversion](https://www.hackerrank.com/challenges/time-conversion)
+
+Difficulty: #easy
+Category: #warmup
+
+Given a time in
+12-[hour AM/PM format](https://en.wikipedia.org/wiki/12-hour_clock),
+convert it to military (24-hour) time.
+
+Note:
+
+- 12:00:00AM on a 12-hour clock is 00:00:00 on a 24-hour clock.
+- 12:00:00PM on a 12-hour clock is 12:00:00 on a 24-hour clock.
+
+## Example
+
+- s = '12:01:00PM' \
+  Return '12:01:00'
+- s = '12:01:00AM' \
+  Return '00:01:00'
+
+## Function Description
+
+Complete the timeConversion function in the editor below.
+It should return a new string representing the input time in 24 hour format
+timeConversion has the following parameter(s):
+
+- string s: a time in 12 hour format
+
+## Returns
+
+- string: the time in 24 hour format
+
+## Input Format
+
+A single string s that represents a time in 12-hour clock format
+(i.e.: hh_mm_ssAM or hh:mm:ssPM).
+
+## Constraints
+
+- All input times are valid
+
+## Sample Input 0
+
+```text
+07:05:45PM
+```
+
+## Sample Output 0
+
+```text
+19:05:45
+```

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

@@ -0,0 +1,13 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+char *HACKERRANK_WARMUP_firstN(const char *s, unsigned long n);
+char *HACKERRANK_WARMUP_lastN(const char *s, unsigned long n);
+
+char *HACKERRANK_WARMUP_timeConversion(const char *s);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

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

@@ -0,0 +1,99 @@
+#include <exercises/hackerrank/warmup/time_conversion.h>
+
+/**
+ * @link Problem definition [[docs/hackerrank/warmup/time_conversion.md]]
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *HACKERRANK_WARMUP_firstN(const char *s, unsigned long n) {
+  unsigned long len = strlen(s);
+  if (n > len) {
+    return NULL;
+  }
+  if (n == 0) {
+    return NULL;
+  }
+
+  char *result = (char *)malloc((n + 1) * sizeof(char));
+  if (result == NULL) {
+    return NULL;
+  }
+
+  strncpy(result, s, n);
+
+  result[n] = '\0';
+
+  return result;
+}
+
+char *HACKERRANK_WARMUP_lastN(const char *s, unsigned long n) {
+  unsigned long len = strlen(s);
+  if (n > len) {
+    return NULL;
+  }
+  if (n == 0) {
+    return NULL;
+  }
+
+  char *result = (char *)malloc((n + 1) * sizeof(char));
+  if (result == NULL) {
+    return NULL;
+  }
+
+  strncpy(result, s + len - n, n);
+
+  result[n] = '\0';
+
+  return result;
+}
+
+char *HACKERRANK_WARMUP_timeConversion(const char *s) {
+  char *conversion;
+  char *meridian = HACKERRANK_WARMUP_lastN(s, 2);
+
+  char *hour_str = HACKERRANK_WARMUP_firstN(s, 2);
+  char *time_str = (char *)malloc((strlen(s) + 1) * sizeof(char));
+  if (time_str == NULL) {
+    free(hour_str);
+    free(meridian);
+    return NULL;
+  }
+  strcpy(time_str, s);
+  time_str = HACKERRANK_WARMUP_lastN(time_str, strlen(time_str) - 2);
+  time_str = HACKERRANK_WARMUP_firstN(time_str, strlen(time_str) - 2);
+
+  char *endptr;
+  long hour = strtol(hour_str, &endptr, 10);
+
+  if (*endptr != '\0') {
+    printf("Conversion error, non-convertible part: %s\n", endptr);
+
+    free(hour_str);
+    free(meridian);
+    free(time_str);
+    free(endptr);
+    return NULL;
+  } else {
+    printf("The integer value is: %ld\n", hour);
+  }
+
+  hour = hour % 12;
+
+  if (strcmp(meridian, "PM") == 0) {
+    hour += 12;
+  }
+
+  const int BUFFER_MAX_SIZE = 9;
+
+  conversion = malloc(BUFFER_MAX_SIZE * sizeof(char));
+
+  snprintf(conversion, BUFFER_MAX_SIZE, "%02ld%s", hour, time_str);
+  free(hour_str);
+  free(meridian);
+  free(time_str);
+
+  return conversion;
+}

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

@@ -0,0 +1,37 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include <exercises/hackerrank/warmup/time_conversion.h>
+#include <filesystem>
+#include <fstream>
+#include <nlohmann/json.hpp>
+#include <vector>
+
+using json = nlohmann::json;
+
+TEST_CASE("time_conversion JSON Test Cases",
+          "[hackerrank] [jsontestcase] [warmup]") {
+  std::filesystem::path cwd = std::filesystem::current_path();
+  std::string path =
+      cwd.string() +
+      "/unit/lib/hackerrank/warmup/time_conversion.testcases.json";
+
+  INFO("time_conversion JSON test cases FILE: " << path);
+
+  std::ifstream f(path);
+  json data = json::parse(f);
+
+  for (auto testcase : data) {
+    std::string result_str(HACKERRANK_WARMUP_timeConversion(
+        testcase["input"].get<std::string>().c_str()));
+    CHECK(result_str == testcase["expected"]);
+  }
+}
+
+TEST_CASE("time_conversion helper functions edge cases",
+          "[hackerrank] [helper] [warmup]") {
+  CHECK(HACKERRANK_WARMUP_firstN("", 10) == nullptr);
+  CHECK(HACKERRANK_WARMUP_lastN("", 10) == nullptr);
+
+  CHECK(HACKERRANK_WARMUP_firstN("", 0) == nullptr);
+  CHECK(HACKERRANK_WARMUP_lastN("", 0) == nullptr);
+}

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

@@ -0,0 +1,4 @@
+[
+  { "input": "12:01:00PM", "expected": "12:01:00" },
+  { "input": "12:01:00AM", "expected": "00:01:00" }
+]