initial commit

c/darts/GNUmakefile

@@ -0,0 +1,34 @@
+# the original 'makefile' has a flaw:
+# 1) it overrides CFLAGS
+# 2) it does not pass extra "FLAGS" to $(CC) that could come from environment
+#
+# It means we need to edit 'makefile' for different builds (DEBUG, etc...),
+# which is not practical at all.
+#
+# To use this makefile:
+#   "make": build with all predefined tests
+#   "make unit": build standalone (unit) test
+#   "make debug": build standalone test with debugging code
+#
+# Original 'makefile' targets can be used (make test, etc...)
+
+.PHONY: default all unit debug std
+
+default: all
+
+# default is to build with all predefined tests
+BUILD := teststall
+
+include makefile
+
+all: CFLAGS+=-DTESTALL
+all: clean test
+
+unit: CFLAGS+=-DUNIT_TEST
+unit: clean std
+
+debug: CFLAGS+=-DUNIT_TEST -DDEBUG
+debug: clean std
+
+std: src/*.c src/*.h
+	$(CC) $(CFLAGS) src/*.c -o test.out

c/darts/README.md

@@ -0,0 +1,55 @@
+# Darts
+
+Write a function that returns the earned points in a single toss of a Darts game.
+
+[Darts](https://en.wikipedia.org/wiki/Darts) is a game where players
+throw darts to a [target](https://en.wikipedia.org/wiki/Darts#/media/File:Darts_in_a_dartboard.jpg).
+
+In our particular instance of the game, the target rewards with 4 different amounts of points, depending on where the dart lands:
+
+* If the dart lands outside the target, player earns no points (0 points).
+* If the dart lands in the outer circle of the target, player earns 1 point.
+* If the dart lands in the middle circle of the target, player earns 5 points.
+* If the dart lands in the inner circle of the target, player earns 10 points.
+
+The outer circle has a radius of 10 units (This is equivalent to the total radius for the entire target), the middle circle a radius of 5 units, and the inner circle a radius of 1. Of course, they are all centered to the same point (That is, the circles are [concentric](http://mathworld.wolfram.com/ConcentricCircles.html)) defined by the coordinates (0, 0).
+
+Write a function that given a point in the target (defined by its `real` cartesian coordinates `x` and `y`), returns the correct amount earned by a dart landing in that point.
+
+## Getting Started
+
+Make sure you have read the "Guides" section of the
+[C track][c-track] on the Exercism site. This covers
+the basic information on setting up the development environment expected
+by the exercises.
+
+## Passing the Tests
+
+Get the first test compiling, linking and passing by following the [three
+rules of test-driven development][3-tdd-rules].
+
+The included makefile can be used to create and run the tests using the `test`
+task.
+
+    make test
+
+Create just the functions you need to satisfy any compiler errors and get the
+test to fail. Then write just enough code to get the test to pass. Once you've
+done that, move onto the next test.
+
+As you progress through the tests, take the time to refactor your
+implementation for readability and expressiveness and then go on to the next
+test.
+
+Try to use standard C99 facilities in preference to writing your own
+low-level algorithms or facilities by hand.
+
+## Source
+
+Inspired by an exercise created by a professor Della Paolera in Argentina
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+
+[c-track]: https://exercism.io/my/tracks/c
+[3-tdd-rules]: http://butunclebob.com/ArticleS.UncleBob.TheThreeRulesOfTdd

c/darts/makefile

@@ -0,0 +1,37 @@
+### If you wish to use extra libraries (math.h for instance),
+### add their flags here (-lm in our case) in the "LIBS" variable.
+
+LIBS = -lm
+
+###
+CFLAGS  = -std=c99
+CFLAGS += -g
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -pedantic
+CFLAGS += -Werror
+CFLAGS += -Wmissing-declarations
+CFLAGS += -DUNITY_SUPPORT_64
+
+ASANFLAGS  = -fsanitize=address
+ASANFLAGS += -fno-common
+ASANFLAGS += -fno-omit-frame-pointer
+
+.PHONY: test
+test: tests.out
+	@./tests.out
+
+.PHONY: memcheck
+memcheck: test/*.c src/*.c src/*.h
+	@echo Compiling $@
+	@$(CC) $(ASANFLAGS) $(CFLAGS) src/*.c test/vendor/unity.c test/*.c -o memcheck.out $(LIBS)
+	@./memcheck.out
+	@echo "Memory check passed"
+
+.PHONY: clean
+clean:
+	rm -rf *.o *.out *.out.dSYM
+
+tests.out: test/*.c src/*.c src/*.h
+	@echo Compiling $@
+	@$(CC) $(CFLAGS) src/*.c test/vendor/unity.c test/*.c -o tests.out $(LIBS)

c/darts/src/darts.c

@@ -0,0 +1,49 @@
+#include "darts.h"
+
+score_t scores[] ={
+    { 1.0F,  10 },
+    { 25.0F,  5 },
+    { 100.0F, 1 },
+    { -1.0F,  0 }
+};
+
+/* Below function is basically incorrect for general case.
+ * However, it should mostly work here, as we compare relatively small numbers.
+ * see below for better alternatives :
+ * https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+ */
+static inline bool float_almost_equal(float x, float y)
+{
+    register float f=x-y;
+    return f<MIN_FLOAT_EQUAL && f>-MIN_FLOAT_EQUAL? true: false;
+}
+
+unsigned score(coordinate_t c)
+{
+    float x=c.x, y=c.y, radius=x*x+y*y;
+    int i;
+
+    for (i=0; scores[i].score; ++i) {
+        if (float_almost_equal(radius, scores[i].radius) || radius < scores[i].radius)
+            break;
+    }
+    return scores[i].score;
+}
+
+#ifdef UNIT_TEST
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(int ac, char **av)
+{
+    int arg=1;
+    float x, y;
+
+    for (; arg<ac-1; ++arg, ++arg) {
+        x=atof(av[arg]);
+        y=atof(av[arg+1]);
+        printf("equal(%f, %f)=%d\n", x, y, float_almost_equal(x, y));
+    }
+
+}
+#endif

c/darts/src/darts.h

@@ -0,0 +1,28 @@
+#ifndef DARTS_H
+#define DARTS_H
+
+#include <stdbool.h>
+#include <float.h>
+
+typedef struct {
+    float x, y;
+} coordinate_t;
+
+typedef struct {
+    float radius;
+    int score;
+} score_t;
+
+// to allow float comparisons we consider 2 floats are equal if
+// their difference is below this value.
+// Use: avoid the '<' & '>' which may be wrong.
+#define MIN_FLOAT_EQUAL FLT_EPSILON
+
+extern unsigned score(coordinate_t);
+
+#ifdef TESTALL
+#undef  TEST_IGNORE
+#define TEST_IGNORE() {}
+#endif
+
+#endif