Add sum of multiples (#288)

oxe-i · web-flow · commit d0cc3fd047c1 · 2025-08-10T13:22:01.000+10:00
by: oxe-i &lt;oxe-b@gmail.com&gt;
diff --git a/config.json b/config.json
@@ -446,6 +446,14 @@
           "transforming"
         ]
       },
+      {
+        "slug": "sum-of-multiples",
+        "name": "Sum of Multiples",
+        "uuid": "ce06cacb-ec4e-46f2-a1b7-f496f0db097f",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 4
+      },
       {
         "slug": "twelve-days",
         "name": "Twelve Days",
diff --git a/exercises/practice/sum-of-multiples/.docs/instructions.md b/exercises/practice/sum-of-multiples/.docs/instructions.md
@@ -0,0 +1,27 @@
+# Instructions
+
+Your task is to write the code that calculates the energy points that get awarded to players when they complete a level.
+
+The points awarded depend on two things:
+
+- The level (a number) that the player completed.
+- The base value of each magical item collected by the player during that level.
+
+The energy points are awarded according to the following rules:
+
+1. For each magical item, take the base value and find all the multiples of that value that are less than the level number.
+2. Combine the sets of numbers.
+3. Remove any duplicates.
+4. Calculate the sum of all the numbers that are left.
+
+Let's look at an example:
+
+**The player completed level 20 and found two magical items with base values of 3 and 5.**
+
+To calculate the energy points earned by the player, we need to find all the unique multiples of these base values that are less than level 20.
+
+- Multiples of 3 less than 20: `{3, 6, 9, 12, 15, 18}`
+- Multiples of 5 less than 20: `{5, 10, 15}`
+- Combine the sets and remove duplicates: `{3, 5, 6, 9, 10, 12, 15, 18}`
+- Sum the unique multiples: `3 + 5 + 6 + 9 + 10 + 12 + 15 + 18 = 78`
+- Therefore, the player earns **78** energy points for completing level 20 and finding the two magical items with base values of 3 and 5.
diff --git a/exercises/practice/sum-of-multiples/.docs/introduction.md b/exercises/practice/sum-of-multiples/.docs/introduction.md
@@ -0,0 +1,6 @@
+# Introduction
+
+You work for a company that makes an online, fantasy-survival game.
+
+When a player finishes a level, they are awarded energy points.
+The amount of energy awarded depends on which magical items the player found while exploring that level.
diff --git a/exercises/practice/sum-of-multiples/.meta/config.json b/exercises/practice/sum-of-multiples/.meta/config.json
@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "oxe-i"
+  ],
+  "files": {
+    "solution": [
+      "sum_of_multiples.asm"
+    ],
+    "test": [
+      "sum_of_multiples_test.c"
+    ],
+    "example": [
+      ".meta/example.asm"
+    ]
+  },
+  "blurb": "Given a number, find the sum of all the multiples of particular numbers up to but not including that number.",
+  "source": "A variation on Problem 1 at Project Euler",
+  "source_url": "https://projecteuler.net/problem=1"
+}
diff --git a/exercises/practice/sum-of-multiples/.meta/example.asm b/exercises/practice/sum-of-multiples/.meta/example.asm
@@ -0,0 +1,65 @@
+section .text
+global sum
+sum:
+    ; rdi - limit as uint64_t
+    ; rsi - input array of uint64_t, representing factors
+    ; rdx - size of input array as size_t (uint64_t)
+    ; return is a uint64_t in rax
+
+    mov r8, rdi
+    
+    ; prologue
+    push rbp
+    mov rbp, rsp
+    sub rsp, r8 ; array of bytes representing each potential multiple
+                ; limit is exclusive
+
+    
+    lea rdi, [rsp]
+    mov rcx, r8
+    mov al, 0
+    cld
+    rep stosb ; initializes array to all "false"
+
+    lea rdi, [rsp]
+    mov rcx, -1
+extract_factor:
+    inc rcx
+    cmp rcx, rdx
+    jge end_extraction ; reached end of input array
+
+    lodsq
+    cmp rax, 0
+    jle extract_factor ; zero has no multiple other than itself and doesn't contribute to the sum. 
+                       ; negative numbers are not factors
+                       
+    mov r9, rax
+fill_multiples:
+    cmp r9, r8
+    jge extract_factor ; limit is exclusive
+
+    mov byte [rdi + r9], 1 ; sets multiple as "true"
+    add r9, rax ; gets next multiple
+    jmp fill_multiples
+
+end_extraction:
+    xor rax, rax ; accumulator
+    mov rcx, r8
+accumulate_factors:
+    mov r10b, byte [rdi + rcx]
+    xor r11, r11
+    cmp r10b, 1
+    cmove r11, rcx ; conditional move reduces branching and makes the loop a bit more tight
+                   ; it also makes using LOOP easier, reducing overall code size
+    add rax, r11
+    loop accumulate_factors
+
+end_sum:
+    ;epilogue
+    mov rsp, rbp
+    pop rbp
+    ret
+
+%ifidn __OUTPUT_FORMAT__,elf64
+section .note.GNU-stack noalloc noexec nowrite progbits
+%endif
diff --git a/exercises/practice/sum-of-multiples/.meta/tests.toml b/exercises/practice/sum-of-multiples/.meta/tests.toml
@@ -0,0 +1,58 @@
+# 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.
+
+[54aaab5a-ce86-4edc-8b40-d3ab2400a279]
+description = "no multiples within limit"
+
+[361e4e50-c89b-4f60-95ef-5bc5c595490a]
+description = "one factor has multiples within limit"
+
+[e644e070-040e-4ae0-9910-93c69fc3f7ce]
+description = "more than one multiple within limit"
+
+[607d6eb9-535c-41ce-91b5-3a61da3fa57f]
+description = "more than one factor with multiples within limit"
+
+[f47e8209-c0c5-4786-b07b-dc273bf86b9b]
+description = "each multiple is only counted once"
+
+[28c4b267-c980-4054-93e9-07723db615ac]
+description = "a much larger limit"
+
+[09c4494d-ff2d-4e0f-8421-f5532821ee12]
+description = "three factors"
+
+[2d0d5faa-f177-4ad6-bde9-ebb865083751]
+description = "factors not relatively prime"
+
+[ece8f2e8-96aa-4166-bbb7-6ce71261e354]
+description = "some pairs of factors relatively prime and some not"
+
+[624fdade-6ffb-400e-8472-456a38c171c0]
+description = "one factor is a multiple of another"
+
+[949ee7eb-db51-479c-b5cb-4a22b40ac057]
+description = "much larger factors"
+
+[41093673-acbd-482c-ab80-d00a0cbedecd]
+description = "all numbers are multiples of 1"
+
+[1730453b-baaa-438e-a9c2-d754497b2a76]
+description = "no factors means an empty sum"
+
+[214a01e9-f4bf-45bb-80f1-1dce9fbb0310]
+description = "the only multiple of 0 is 0"
+
+[c423ae21-a0cb-4ec7-aeb1-32971af5b510]
+description = "the factor 0 does not affect the sum of multiples of other factors"
+
+[17053ba9-112f-4ac0-aadb-0519dd836342]
+description = "solutions using include-exclude must extend to cardinality greater than 3"
diff --git a/exercises/practice/sum-of-multiples/Makefile b/exercises/practice/sum-of-multiples/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
+	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
diff --git a/exercises/practice/sum-of-multiples/sum_of_multiples.asm b/exercises/practice/sum-of-multiples/sum_of_multiples.asm
@@ -0,0 +1,9 @@
+section .text
+global sum
+sum:
+    ; Provide your implementation here
+    ret
+
+%ifidn __OUTPUT_FORMAT__,elf64
+section .note.GNU-stack noalloc noexec nowrite progbits
+%endif
diff --git a/exercises/practice/sum-of-multiples/sum_of_multiples_test.c b/exercises/practice/sum-of-multiples/sum_of_multiples_test.c
@@ -0,0 +1,131 @@
+// Version: 0
+
+#include "vendor/unity.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+
+extern uint64_t sum(uint64_t limit, const uint64_t *factors, size_t factor_count);
+
+void setUp(void) {
+}
+
+void tearDown(void) {
+}
+
+void test_no_multiples_within_limit(void) {
+    const uint64_t factors[] = {3, 5};
+    TEST_ASSERT_EQUAL_UINT64(0, sum(1, factors, ARRAY_SIZE(factors)));
+}
+
+void test_one_factor_has_multiples_within_limit(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {3, 5};
+    TEST_ASSERT_EQUAL_UINT64(3, sum(4, factors, ARRAY_SIZE(factors)));
+}
+
+void test_more_than_one_multiple_within_limit(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {3};
+    TEST_ASSERT_EQUAL_UINT64(9, sum(7, factors, ARRAY_SIZE(factors)));
+}
+
+void test_more_than_one_factor_with_multiples_within_limit(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {3, 5};
+    TEST_ASSERT_EQUAL_UINT64(23, sum(10, factors, ARRAY_SIZE(factors)));
+}
+
+void test_each_multiple_is_only_counted_once(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {3, 5};
+    TEST_ASSERT_EQUAL_UINT64(2318, sum(100, factors, ARRAY_SIZE(factors)));
+}
+
+void test_a_much_larger_limit(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {3, 5};
+    TEST_ASSERT_EQUAL_UINT64(233168, sum(1000, factors, ARRAY_SIZE(factors)));
+}
+
+void test_three_factors(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {7, 13, 17};
+    TEST_ASSERT_EQUAL_UINT64(51, sum(20, factors, ARRAY_SIZE(factors)));
+}
+
+void test_factors_not_relatively_prime(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {4, 6};
+    TEST_ASSERT_EQUAL_UINT64(30, sum(15, factors, ARRAY_SIZE(factors)));
+}
+
+void test_some_pairs_of_factors_relatively_prime_and_some_not(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {5, 6, 8};
+    TEST_ASSERT_EQUAL_UINT64(4419, sum(150, factors, ARRAY_SIZE(factors)));
+}
+
+void test_one_factor_is_a_multiple_of_another(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {5, 25};
+    TEST_ASSERT_EQUAL_UINT64(275, sum(51, factors, ARRAY_SIZE(factors)));
+}
+
+void test_much_larger_factors(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {43, 47};
+    TEST_ASSERT_EQUAL_UINT64(2203160, sum(10000, factors, ARRAY_SIZE(factors)));
+}
+
+void test_all_numbers_are_multiples_of_1(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {1};
+    TEST_ASSERT_EQUAL_UINT64(4950, sum(100, factors, ARRAY_SIZE(factors)));
+}
+
+void test_no_factors_means_an_empty_sum(void) {
+    TEST_IGNORE();
+    TEST_ASSERT_EQUAL_UINT64(0, sum(10000, NULL, 0));
+}
+
+void test_the_only_multiple_of_0_is_0(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {0};
+    TEST_ASSERT_EQUAL_UINT64(0, sum(1, factors, ARRAY_SIZE(factors)));
+}
+
+void test_the_factor_0_does_not_affect_the_sum_of_multiples_of_other_factors(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {3, 0};
+    TEST_ASSERT_EQUAL_UINT64(3, sum(4, factors, ARRAY_SIZE(factors)));
+}
+
+void test_solutions_using_includeexclude_must_extend_to_cardinality_greater_than_3(void) {
+    TEST_IGNORE();
+    const uint64_t factors[] = {2, 3, 5, 7, 11};
+    TEST_ASSERT_EQUAL_UINT64(39614537, sum(10000, factors, ARRAY_SIZE(factors)));
+}
+
+int main(void) {
+    UNITY_BEGIN();
+    RUN_TEST(test_no_multiples_within_limit);
+    RUN_TEST(test_one_factor_has_multiples_within_limit);
+    RUN_TEST(test_more_than_one_multiple_within_limit);
+    RUN_TEST(test_more_than_one_factor_with_multiples_within_limit);
+    RUN_TEST(test_each_multiple_is_only_counted_once);
+    RUN_TEST(test_a_much_larger_limit);
+    RUN_TEST(test_three_factors);
+    RUN_TEST(test_factors_not_relatively_prime);
+    RUN_TEST(test_some_pairs_of_factors_relatively_prime_and_some_not);
+    RUN_TEST(test_one_factor_is_a_multiple_of_another);
+    RUN_TEST(test_much_larger_factors);
+    RUN_TEST(test_all_numbers_are_multiples_of_1);
+    RUN_TEST(test_no_factors_means_an_empty_sum);
+    RUN_TEST(test_the_only_multiple_of_0_is_0);
+    RUN_TEST(test_the_factor_0_does_not_affect_the_sum_of_multiples_of_other_factors);
+    RUN_TEST(test_solutions_using_includeexclude_must_extend_to_cardinality_greater_than_3);
+    return UNITY_END();
+}
diff --git a/exercises/practice/sum-of-multiples/vendor/unity.c b/exercises/practice/sum-of-multiples/vendor/unity.c
diff --git a/exercises/practice/sum-of-multiples/vendor/unity.h b/exercises/practice/sum-of-multiples/vendor/unity.h
diff --git a/exercises/practice/sum-of-multiples/vendor/unity_internals.h b/exercises/practice/sum-of-multiples/vendor/unity_internals.h
diff --git a/generators/exercises/sum_of_multiples.py b/generators/exercises/sum_of_multiples.py
