trackler 2.2.1.45 → 2.2.1.46

data/tracks/c/exercises/nucleotide-count/src/example.c

@@ -8,26 +8,26 @@ char *count(const char *dna_strand)
 {
    bool invalid_char = false;
    size_t index;
-   size_t nucleotide_A_count = 0;
-   size_t nucleotide_C_count = 0;
-   size_t nucleotide_G_count = 0;
-   size_t nucleotide_T_count = 0;
+   size_t nucleotide_a_count = 0;
+   size_t nucleotide_c_count = 0;
+   size_t nucleotide_g_count = 0;
+   size_t nucleotide_t_count = 0;
    char *count_results = calloc(1, 50);
 
    for (index = 0; (index < strlen(dna_strand)) && (invalid_char == false);
         index++) {
       switch (dna_strand[index]) {
       case 'A':
-         nucleotide_A_count++;
+         nucleotide_a_count++;
          break;
       case 'C':
-         nucleotide_C_count++;
+         nucleotide_c_count++;
          break;
       case 'G':
-         nucleotide_G_count++;
+         nucleotide_g_count++;
          break;
       case 'T':
-         nucleotide_T_count++;
+         nucleotide_t_count++;
          break;
       default:
          invalid_char = true;
@@ -36,8 +36,8 @@ char *count(const char *dna_strand)
    }
 
    if (!invalid_char) {
-      sprintf(count_results, "A:%zd C:%zd G:%zd T:%zd", nucleotide_A_count,
-              nucleotide_C_count, nucleotide_G_count, nucleotide_T_count);
+      sprintf(count_results, "A:%zd C:%zd G:%zd T:%zd", nucleotide_a_count,
+              nucleotide_c_count, nucleotide_g_count, nucleotide_t_count);
    }
    return count_results;
 }

data/tracks/c/exercises/palindrome-products/src/example.c

@@ -2,7 +2,7 @@
 #include <stdbool.h>
 
 /* Return true if the product of a and b is a palindrome, false otherwise */
-bool isPalindromeProduct(int a, int b)
+bool is_palindrome_product(int a, int b)
 {
    int ret = 0, prod = a * b;
    while (prod) {
@@ -13,21 +13,21 @@ bool isPalindromeProduct(int a, int b)
    return (a * b) == ret;
 }
 
-Pair getPalindromeProduct(int min, int max)
+product_t get_palindrome_product(int min, int max)
 {
-   Pair ret;
-   ret.small_palind = 0;
-   ret.larg_palind = 0;
+   product_t ret;
+   ret.smallest = 0;
+   ret.largest = 0;
    bool largest = false;
 
    for (int i = min; i <= max; i++) {
       for (int j = min; j <= max; j++) {
-         if (isPalindromeProduct(i, j) == true) {
+         if (is_palindrome_product(i, j) == true) {
             if (largest == false) {
-               ret.small_palind = i * j;
+               ret.smallest = i * j;
                largest = true;
             } else {
-               ret.larg_palind = i * j;
+               ret.largest = i * j;
             }
          }
       }

data/tracks/c/exercises/palindrome-products/src/example.h

@@ -2,11 +2,11 @@
 #define PALINDROME_PRODUCTS_H
 
 typedef struct {
-   int small_palind;
-   int larg_palind;
-} Pair;
+   int smallest;
+   int largest;
+} product_t;
 
-/* Return the smallest and biggest palindrome in the range of min and max */
-Pair getPalindromeProduct(int min, int max);
+/* Return the smallest and largest palindrome products in the range of min and max */
+product_t get_palindrome_product(int min, int max);
 
 #endif

data/tracks/c/exercises/palindrome-products/test/test_palindrome_products.c

@@ -3,24 +3,26 @@
 
 void test_palindromes_list(void)
 {
-   Pair palind = getPalindromeProduct(1, 9);
-   TEST_ASSERT_EQUAL_INT(1, palind.small_palind);
-   TEST_ASSERT_EQUAL_INT(9, palind.larg_palind);
+   product_t product = get_palindrome_product(1, 9);
+   TEST_ASSERT_EQUAL_INT(1, product.smallest);
+   TEST_ASSERT_EQUAL_INT(9, product.largest);
 }
 
 void test_palindromes_list2(void)
 {
    TEST_IGNORE();               // delete this line to run test
-   Pair palind = getPalindromeProduct(10, 99);
-   TEST_ASSERT_EQUAL_INT(121, palind.small_palind);
-   TEST_ASSERT_EQUAL_INT(9009, palind.larg_palind);
+   product_t product = get_palindrome_product(10, 99);
+   TEST_ASSERT_EQUAL_INT(121, product.smallest);
+   TEST_ASSERT_EQUAL_INT(9009, product.largest);
 }
 
 int main(void)
 {
    UnityBegin("test/test_palindrome_products.c");
+
    RUN_TEST(test_palindromes_list);
    RUN_TEST(test_palindromes_list2);
+
    UnityEnd();
    return 0;
 }

data/tracks/c/exercises/robot-simulator/src/example.c

@@ -1,48 +1,48 @@
 #include <string.h>
 #include "robot_simulator.h"
 
-RobotGridStatus_t robot_init(void)
+robot_grid_status_t robot_init(void)
 {
    return (robot_init_with_position
-           (Default_Bearing, Default_X_Coordinate, Default_Y_Coordinate));
+           (default_bearing, default_x_coordinate, default_y_coordinate));
 }
 
-RobotGridStatus_t robot_init_with_position(int bearing, int x, int y)
+robot_grid_status_t robot_init_with_position(int bearing, int x, int y)
 {
-   RobotGridStatus_t robot = { bearing, {x, y} };
+   robot_grid_status_t robot = { bearing, {x, y} };
 
-   if ((bearing < Heading_North) || (bearing >= Heading_Max)) {
-      robot.bearing = Default_Bearing;
+   if ((bearing < heading_north) || (bearing >= heading_max)) {
+      robot.bearing = default_bearing;
    }
    return robot;
 }
 
-void robot_turn_right(RobotGridStatus_t * robot)
+void robot_turn_right(robot_grid_status_t * robot)
 {
-   robot->bearing = (robot->bearing + 1) % Heading_Max;
+   robot->bearing = (robot->bearing + 1) % heading_max;
 }
 
-void robot_turn_left(RobotGridStatus_t * robot)
+void robot_turn_left(robot_grid_status_t * robot)
 {
-   robot->bearing = ((robot->bearing - 1) + Heading_Max) % Heading_Max;
+   robot->bearing = ((robot->bearing - 1) + heading_max) % heading_max;
 }
 
-void robot_advance(RobotGridStatus_t * robot)
+void robot_advance(robot_grid_status_t * robot)
 {
    switch (robot->bearing) {
-   case Heading_North:
+   case heading_north:
       robot->grid.y_position++;
       break;
 
-   case Heading_East:
+   case heading_east:
       robot->grid.x_position++;
       break;
 
-   case Heading_South:
+   case heading_south:
       robot->grid.y_position--;
       break;
 
-   case Heading_West:
+   case heading_west:
       robot->grid.x_position--;
       break;
 
@@ -51,19 +51,19 @@ void robot_advance(RobotGridStatus_t * robot)
    }
 }
 
-void robot_simulator(RobotGridStatus_t * robot, const char *commands)
+void robot_simulator(robot_grid_status_t * robot, const char *commands)
 {
    for (unsigned long index = 0; index < strlen(commands); index++) {
       switch (commands[index]) {
-      case Command_Left:
+      case command_left:
          robot_turn_left(robot);
          break;
 
-      case Command_Right:
+      case command_right:
          robot_turn_right(robot);
          break;
 
-      case Command_Advance:
+      case command_advance:
          robot_advance(robot);
          break;
 

data/tracks/c/exercises/robot-simulator/src/robot_simulator.h

@@ -2,40 +2,40 @@
 #define ROBOT_SIMULATOR_H
 
 typedef enum {
-   Heading_North = 0,
-   Heading_East,
-   Heading_South,
-   Heading_West,
-   Heading_Max
-} Bearing_t;
+   heading_north = 0,
+   heading_east,
+   heading_south,
+   heading_west,
+   heading_max
+} bearing_t;
 
 enum {
-   Default_Bearing = Heading_North,
-   Default_X_Coordinate = 0,
-   Default_Y_Coordinate = 0,
+   default_bearing = heading_north,
+   default_x_coordinate = 0,
+   default_y_coordinate = 0,
 };
 
 enum {
-   Command_Left = 'L',
-   Command_Right = 'R',
-   Command_Advance = 'A'
+   command_left = 'L',
+   command_right = 'R',
+   command_advance = 'A'
 };
 
-typedef struct RobotCoordinates {
+typedef struct robot_coordinates {
    int x_position;
    int y_position;
-} RobotCoordinates_t;
+} robot_coordinates_t;
 
-typedef struct RobotGridStatus {
-   Bearing_t bearing;
-   RobotCoordinates_t grid;
-} RobotGridStatus_t;
+typedef struct robot_grid_status {
+   bearing_t bearing;
+   robot_coordinates_t grid;
+} robot_grid_status_t;
 
-RobotGridStatus_t robot_init(void);
-RobotGridStatus_t robot_init_with_position(int bearing, int x, int y);
-void robot_turn_right(RobotGridStatus_t * robot);
-void robot_turn_left(RobotGridStatus_t * robot);
-void robot_advance(RobotGridStatus_t * robot);
-void robot_simulator(RobotGridStatus_t * robot, const char *commands);
+robot_grid_status_t robot_init(void);
+robot_grid_status_t robot_init_with_position(int bearing, int x, int y);
+void robot_turn_right(robot_grid_status_t * robot);
+void robot_turn_left(robot_grid_status_t * robot);
+void robot_advance(robot_grid_status_t * robot);
+void robot_simulator(robot_grid_status_t * robot, const char *commands);
 
 #endif

data/tracks/c/exercises/robot-simulator/test/test_robot_simulator.c

@@ -2,7 +2,8 @@
 #include "vendor/unity.h"
 
 // Test Helper Function
-void confirm_position(RobotGridStatus_t * expected, RobotGridStatus_t * actual)
+void confirm_position(robot_grid_status_t * expected,
+                      robot_grid_status_t * actual)
 {
    TEST_ASSERT_EQUAL(expected->bearing, actual->bearing);
    TEST_ASSERT_EQUAL(expected->grid.x_position, actual->grid.x_position);
@@ -12,9 +13,9 @@ void confirm_position(RobotGridStatus_t * expected, RobotGridStatus_t * actual)
 // Tests...
 void test_init(void)
 {
-   RobotGridStatus_t expected =
-       { Default_Bearing, {Default_X_Coordinate, Default_Y_Coordinate} };
-   RobotGridStatus_t actual = robot_init();
+   robot_grid_status_t expected =
+       { default_bearing, {default_x_coordinate, default_y_coordinate} };
+   robot_grid_status_t actual = robot_init();
 
    confirm_position(&expected, &actual);
 }
@@ -22,10 +23,10 @@ void test_init(void)
 void test_invalid_initial_heading(void)
 {
    TEST_IGNORE();               // delete this line to run test
-   RobotGridStatus_t expected =
-       { Default_Bearing, {Default_X_Coordinate, Default_Y_Coordinate} };
-   RobotGridStatus_t actual =
-       robot_init_with_position(99, Default_X_Coordinate, Default_Y_Coordinate);
+   robot_grid_status_t expected =
+       { default_bearing, {default_x_coordinate, default_y_coordinate} };
+   robot_grid_status_t actual =
+       robot_init_with_position(99, default_x_coordinate, default_y_coordinate);
 
    confirm_position(&expected, &actual);
 }
@@ -33,8 +34,8 @@ void test_invalid_initial_heading(void)
 void test_init_with_negative_positions(void)
 {
    TEST_IGNORE();
-   RobotGridStatus_t expected = { Heading_South, {-1, -1} };
-   RobotGridStatus_t actual = robot_init_with_position(Heading_South, -1, -1);
+   robot_grid_status_t expected = { heading_south, {-1, -1} };
+   robot_grid_status_t actual = robot_init_with_position(heading_south, -1, -1);
 
    confirm_position(&expected, &actual);
 }
@@ -42,21 +43,21 @@ void test_init_with_negative_positions(void)
 void test_turn_right(void)
 {
    TEST_IGNORE();
-   RobotGridStatus_t expected = { Heading_East, {0, 0} };
-   RobotGridStatus_t actual = robot_init();
+   robot_grid_status_t expected = { heading_east, {0, 0} };
+   robot_grid_status_t actual = robot_init();
 
    robot_turn_right(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = Heading_South;
+   expected.bearing = heading_south;
    robot_turn_right(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = Heading_West;
+   expected.bearing = heading_west;
    robot_turn_right(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = Heading_North;
+   expected.bearing = heading_north;
    robot_turn_right(&actual);
    confirm_position(&expected, &actual);
 }
@@ -64,21 +65,21 @@ void test_turn_right(void)
 void test_turn_left(void)
 {
    TEST_IGNORE();
-   RobotGridStatus_t expected = { Heading_West, {0, 0} };
-   RobotGridStatus_t actual = robot_init();
+   robot_grid_status_t expected = { heading_west, {0, 0} };
+   robot_grid_status_t actual = robot_init();
 
    robot_turn_left(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = Heading_South;
+   expected.bearing = heading_south;
    robot_turn_left(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = Heading_East;
+   expected.bearing = heading_east;
    robot_turn_left(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = Heading_North;
+   expected.bearing = heading_north;
    robot_turn_left(&actual);
    confirm_position(&expected, &actual);
 }
@@ -86,8 +87,8 @@ void test_turn_left(void)
 void test_advance_positive_north(void)
 {
    TEST_IGNORE();
-   RobotGridStatus_t expected = { Heading_North, {0, 1} };
-   RobotGridStatus_t actual = robot_init();
+   robot_grid_status_t expected = { heading_north, {0, 1} };
+   robot_grid_status_t actual = robot_init();
 
    robot_advance(&actual);
    confirm_position(&expected, &actual);
@@ -96,8 +97,8 @@ void test_advance_positive_north(void)
 void test_advance_positive_east(void)
 {
    TEST_IGNORE();
-   RobotGridStatus_t expected = { Heading_East, {1, 0} };
-   RobotGridStatus_t actual = robot_init_with_position(Heading_East, 0, 0);
+   robot_grid_status_t expected = { heading_east, {1, 0} };
+   robot_grid_status_t actual = robot_init_with_position(heading_east, 0, 0);
 
    robot_advance(&actual);
    confirm_position(&expected, &actual);
@@ -106,8 +107,8 @@ void test_advance_positive_east(void)
 void test_advance_negative_south(void)
 {
    TEST_IGNORE();
-   RobotGridStatus_t expected = { Heading_South, {0, -1} };
-   RobotGridStatus_t actual = robot_init_with_position(Heading_South, 0, 0);
+   robot_grid_status_t expected = { heading_south, {0, -1} };
+   robot_grid_status_t actual = robot_init_with_position(heading_south, 0, 0);
 
    robot_advance(&actual);
    confirm_position(&expected, &actual);
@@ -116,8 +117,8 @@ void test_advance_negative_south(void)
 void test_advance_negative_west(void)
 {
    TEST_IGNORE();
-   RobotGridStatus_t expected = { Heading_West, {-1, 0} };
-   RobotGridStatus_t actual = robot_init_with_position(Heading_West, 0, 0);
+   robot_grid_status_t expected = { heading_west, {-1, 0} };
+   robot_grid_status_t actual = robot_init_with_position(heading_west, 0, 0);
 
    robot_advance(&actual);
    confirm_position(&expected, &actual);
@@ -126,8 +127,8 @@ void test_advance_negative_west(void)
 void test_simulate_move_west_and_north(void)
 {
    TEST_IGNORE();
-   RobotGridStatus_t expected = { Heading_West, {-4, 1} };
-   RobotGridStatus_t actual = robot_init();
+   robot_grid_status_t expected = { heading_west, {-4, 1} };
+   robot_grid_status_t actual = robot_init();
 
    robot_simulator(&actual, "LAAARALA");
    confirm_position(&expected, &actual);
@@ -136,8 +137,8 @@ void test_simulate_move_west_and_north(void)
 void test_simulate_move_west_and_south(void)
 {
    TEST_IGNORE();
-   RobotGridStatus_t expected = { Heading_South, {-3, -8} };
-   RobotGridStatus_t actual = robot_init_with_position(Heading_East, 2, -7);
+   robot_grid_status_t expected = { heading_south, {-3, -8} };
+   robot_grid_status_t actual = robot_init_with_position(heading_east, 2, -7);
 
    robot_simulator(&actual, "RRAAAAALA");
    confirm_position(&expected, &actual);
@@ -146,8 +147,8 @@ void test_simulate_move_west_and_south(void)
 void test_simulate_move_east_and_north(void)
 {
    TEST_IGNORE();
-   RobotGridStatus_t expected = { Heading_North, {11, 5} };
-   RobotGridStatus_t actual = robot_init_with_position(Heading_South, 8, 4);
+   robot_grid_status_t expected = { heading_north, {11, 5} };
+   robot_grid_status_t actual = robot_init_with_position(heading_south, 8, 4);
 
    robot_simulator(&actual, "LAAARRRALLLL");
    confirm_position(&expected, &actual);