Add prime-factors exercise (#226)

config.json

@@ -382,6 +382,14 @@
           "loops"
         ]
       },
+      {
+        "slug": "prime-factors",
+        "name": "Prime Factors",
+        "uuid": "fc9bb707-337c-4cf4-ba7d-7569a71958c0",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 4
+      },
       {
         "slug": "roman-numerals",
         "name": "Roman Numerals",

exercises/practice/prime-factors/.docs/instructions.md

@@ -0,0 +1,36 @@
+# Instructions
+
+Compute the prime factors of a given natural number.
+
+A prime number is only evenly divisible by itself and 1.
+
+Note that 1 is not a prime number.
+
+## Example
+
+What are the prime factors of 60?
+
+- Our first divisor is 2.
+  2 goes into 60, leaving 30.
+- 2 goes into 30, leaving 15.
+  - 2 doesn't go cleanly into 15.
+    So let's move on to our next divisor, 3.
+- 3 goes cleanly into 15, leaving 5.
+  - 3 does not go cleanly into 5.
+    The next possible factor is 4.
+  - 4 does not go cleanly into 5.
+    The next possible factor is 5.
+- 5 does go cleanly into 5.
+- We're left only with 1, so now, we're done.
+
+Our successful divisors in that computation represent the list of prime factors of 60: 2, 2, 3, and 5.
+
+You can check this yourself:
+
+```text
+2 * 2 * 3 * 5
+= 4 * 15
+= 60
+```
+
+Success!

exercises/practice/prime-factors/.gitignore

@@ -0,0 +1,2 @@
+*.o
+tests

exercises/practice/prime-factors/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "keiravillekode"
+  ],
+  "files": {
+    "solution": [
+      "prime_factors.asm"
+    ],
+    "test": [
+      "prime_factors_test.c"
+    ],
+    "example": [
+      ".meta/example.asm"
+    ]
+  },
+  "blurb": "Compute the prime factors of a given natural number.",
+  "source": "The Prime Factors Kata by Uncle Bob",
+  "source_url": "https://web.archive.org/web/20221026171801/http://butunclebob.com/ArticleS.UncleBob.ThePrimeFactorsKata"
+}

exercises/practice/prime-factors/.meta/example.asm

@@ -0,0 +1,55 @@
+;
+; Compute the prime factors of a given natural number.
+;
+; Parameters:
+;   rdi - destination
+;   rsi - number to be factored
+; Returns:
+;   rax - factor count
+;
+section .text
+global factors
+factors:
+    cld ; each stosq will increase rdi
+    mov r8, 2 ; candidate factor is 2 3 5 7 9 11 etc.
+    mov r9, 1 ; step is 1, then 2
+    mov rcx, rdi
+    jmp .square
+
+.next_candidate:
+    add r8, r9
+    mov r9, 2
+
+.square:
+    mov rax, r8
+    mul r8
+    cmp rsi, rax
+    jl .break ; exit loop when candidate squared exceeds number
+
+    mov rax, rsi
+    xor rdx, rdx
+    div r8
+    test rdx, rdx
+    jnz .next_candidate ; advance to next candidate if remainder is non-zero
+
+    mov rsi, rax ; replace number with quotient
+    mov rax, r8
+    stosq ; output factor
+    jmp .square
+
+.break:
+    cmp rsi, 1
+    je .report
+
+    mov rax, rsi
+    stosq ; output number
+
+.report:
+    mov rax, rdi
+    sub rax, rcx
+    shr rax, 3
+    ret
+
+%ifidn __OUTPUT_FORMAT__,elf64
+section .note.GNU-stack noalloc noexec nowrite progbits
+%endif

exercises/practice/prime-factors/.meta/tests.toml

@@ -0,0 +1,46 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[924fc966-a8f5-4288-82f2-6b9224819ccd]
+description = "no factors"
+
+[17e30670-b105-4305-af53-ddde182cb6ad]
+description = "prime number"
+
+[238d57c8-4c12-42ef-af34-ae4929f94789]
+description = "another prime number"
+
+[f59b8350-a180-495a-8fb1-1712fbee1158]
+description = "square of a prime"
+
+[756949d3-3158-4e3d-91f2-c4f9f043ee70]
+description = "product of first prime"
+
+[bc8c113f-9580-4516-8669-c5fc29512ceb]
+description = "cube of a prime"
+
+[7d6a3300-a4cb-4065-bd33-0ced1de6cb44]
+description = "product of second prime"
+
+[073ac0b2-c915-4362-929d-fc45f7b9a9e4]
+description = "product of third prime"
+
+[6e0e4912-7fb6-47f3-a9ad-dbcd79340c75]
+description = "product of first and second prime"
+
+[00485cd3-a3fe-4fbe-a64a-a4308fc1f870]
+description = "product of primes and non-primes"
+
+[02251d54-3ca1-4a9b-85e1-b38f4b0ccb91]
+description = "product of primes"
+
+[070cf8dc-e202-4285-aa37-8d775c9cd473]
+description = "factors include a large prime"

exercises/practice/prime-factors/Makefile

@@ -0,0 +1,46 @@
+AS = nasm
+
+CFLAGS = -g -Wall -Wextra -pedantic -Werror
+LDFLAGS =
+ASFLAGS = -g -F dwarf -Werror
+
+ifeq ($(shell uname -s),Darwin)
+ifeq ($(shell sysctl -n hw.optional.arm64 2>/dev/null),1)
+	ALL_CFLAGS = -target x86_64-apple-darwin
+endif
+	ALL_LDFLAGS = -Wl,-pie -Wl,-fatal_warnings
+	ALL_ASFLAGS = -f macho64 --prefix _
+else
+	ALL_LDFLAGS = -pie -Wl,--fatal-warnings
+	ALL_ASFLAGS = -f elf64
+endif
+
+ALL_CFLAGS += -std=c99 -fPIE -m64 $(CFLAGS)
+ALL_LDFLAGS += $(LDFLAGS)
+ALL_ASFLAGS += $(ASFLAGS)
+
+C_OBJS = $(patsubst %.c,%.o,$(wildcard *.c))
+AS_OBJS = $(patsubst %.asm,%.o,$(wildcard *.asm))
+ALL_OBJS = $(filter-out example.o,$(C_OBJS) $(AS_OBJS) vendor/unity.o)
+
+CC_CMD = $(CC) $(ALL_CFLAGS) -c -o $@ $<
+
+all: tests
+	@./$<
+
+tests: $(ALL_OBJS)
+	@$(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) -o $@ $(ALL_OBJS)
+
+%.o: %.asm
+	@$(AS) $(ALL_ASFLAGS) -o $@ $<
+
+%.o: %.c
+	@$(CC_CMD)
+
+vendor/unity.o: vendor/unity.c vendor/unity.h vendor/unity_internals.h
+	@$(CC_CMD)
+
+clean:
+	@rm -f *.o vendor/*.o tests
+
+.PHONY: all clean

exercises/practice/prime-factors/prime_factors.asm

@@ -0,0 +1,9 @@
+section .text
+global factors
+factors:
+    ; Provide your implementation here
+    ret
+
+%ifidn __OUTPUT_FORMAT__,elf64
+section .note.GNU-stack noalloc noexec nowrite progbits
+%endif

exercises/practice/prime-factors/prime_factors_test.c

@@ -0,0 +1,139 @@
+// Version: 1.0.0
+
+#include "vendor/unity.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define MAX_ARRAY_SIZE 100
+
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+
+extern size_t factors(uint64_t* dest, uint64_t value);
+
+void setUp(void) {
+}
+
+void tearDown(void) {
+}
+
+void test_no_factors(void) {
+    size_t size = factors(NULL, 1);
+    TEST_ASSERT_EQUAL_UINT(0, size);
+}
+
+void test_prime_number(void) {
+    TEST_IGNORE();
+    uint64_t expected[] = {2};
+    uint64_t actual[MAX_ARRAY_SIZE];
+    size_t size = factors(actual, 2);
+    TEST_ASSERT_EQUAL_UINT(ARRAY_SIZE(expected), size);
+    TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, size);
+}
+
+void test_another_prime_number(void) {
+    TEST_IGNORE();
+    uint64_t expected[] = {3};
+    uint64_t actual[MAX_ARRAY_SIZE];
+    size_t size = factors(actual, 3);
+    TEST_ASSERT_EQUAL_UINT(ARRAY_SIZE(expected), size);
+    TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, size);
+}
+
+void test_square_of_a_prime(void) {
+    TEST_IGNORE();
+    uint64_t expected[] = {3, 3};
+    uint64_t actual[MAX_ARRAY_SIZE];
+    size_t size = factors(actual, 9);
+    TEST_ASSERT_EQUAL_UINT(ARRAY_SIZE(expected), size);
+    TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, size);
+}
+
+void test_product_of_first_prime(void) {
+    TEST_IGNORE();
+    uint64_t expected[] = {2, 2};
+    uint64_t actual[MAX_ARRAY_SIZE];
+    size_t size = factors(actual, 4);
+    TEST_ASSERT_EQUAL_UINT(ARRAY_SIZE(expected), size);
+    TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, size);
+}
+
+void test_cube_of_a_prime(void) {
+    TEST_IGNORE();
+    uint64_t expected[] = {2, 2, 2};
+    uint64_t actual[MAX_ARRAY_SIZE];
+    size_t size = factors(actual, 8);
+    TEST_ASSERT_EQUAL_UINT(ARRAY_SIZE(expected), size);
+    TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, size);
+}
+
+void test_product_of_second_prime(void) {
+    TEST_IGNORE();
+    uint64_t expected[] = {3, 3, 3};
+    uint64_t actual[MAX_ARRAY_SIZE];
+    size_t size = factors(actual, 27);
+    TEST_ASSERT_EQUAL_UINT(ARRAY_SIZE(expected), size);
+    TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, size);
+}
+
+void test_product_of_third_prime(void) {
+    TEST_IGNORE();
+    uint64_t expected[] = {5, 5, 5, 5};
+    uint64_t actual[MAX_ARRAY_SIZE];
+    size_t size = factors(actual, 625);
+    TEST_ASSERT_EQUAL_UINT(ARRAY_SIZE(expected), size);
+    TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, size);
+}
+
+void test_product_of_first_and_second_prime(void) {
+    TEST_IGNORE();
+    uint64_t expected[] = {2, 3};
+    uint64_t actual[MAX_ARRAY_SIZE];
+    size_t size = factors(actual, 6);
+    TEST_ASSERT_EQUAL_UINT(ARRAY_SIZE(expected), size);
+    TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, size);
+}
+
+void test_product_of_primes_and_non_primes(void) {
+    TEST_IGNORE();
+    uint64_t expected[] = {2, 2, 3};
+    uint64_t actual[MAX_ARRAY_SIZE];
+    size_t size = factors(actual, 12);
+    TEST_ASSERT_EQUAL_UINT(ARRAY_SIZE(expected), size);
+    TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, size);
+}
+
+void test_product_of_primes(void) {
+    TEST_IGNORE();
+    uint64_t expected[] = {5, 17, 23, 461};
+    uint64_t actual[MAX_ARRAY_SIZE];
+    size_t size = factors(actual, 901255);
+    TEST_ASSERT_EQUAL_UINT(ARRAY_SIZE(expected), size);
+    TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, size);
+}
+
+void test_factors_include_a_large_prime(void) {
+    TEST_IGNORE();
+    uint64_t expected[] = {11, 9539, 894119};
+    uint64_t actual[MAX_ARRAY_SIZE];
+    size_t size = factors(actual, 93819012551);
+    TEST_ASSERT_EQUAL_UINT(ARRAY_SIZE(expected), size);
+    TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, size);
+}
+
+int main(void) {
+    UNITY_BEGIN();
+    RUN_TEST(test_no_factors);
+    RUN_TEST(test_prime_number);
+    RUN_TEST(test_another_prime_number);
+    RUN_TEST(test_square_of_a_prime);
+    RUN_TEST(test_product_of_first_prime);
+    RUN_TEST(test_cube_of_a_prime);
+    RUN_TEST(test_product_of_second_prime);
+    RUN_TEST(test_product_of_third_prime);
+    RUN_TEST(test_product_of_first_and_second_prime);
+    RUN_TEST(test_product_of_primes_and_non_primes);
+    RUN_TEST(test_product_of_primes);
+    RUN_TEST(test_factors_include_a_large_prime);
+    return UNITY_END();
+}