Agent Work: Prime Factors

Claude Opus 4.6 · COMP 321: Introduction to Computer Systems

COMP 321: Introduction to Computer Systems

Project 1: Factors

Overview

You will write C code to count the prime factors of a number. The goals of this project are as follows:

Write a small amount of C code.
Become familiar with compiling C code.
Understand the perils of writing a deeply recursive program.

Summary

You will write three versions of code to count the prime factors of a positive integer greater than one (Please remember, "1" is NOT a prime number):

Count all of the prime factors recursively. For example, 12 has 3 prime factors: 2, 2, and 3.
Count all of the prime factors iteratively.
Count the distinct prime factors iteratively. For example, 12 has 2 distinct prime factors: 2 and 3.

You will write a different procedure to handle each version. You do not need to write a particularly efficient program, although it should complete in sixty seconds on any input. In particular, a truly efficient version would use some data structure to store previously discovered primes, but you have not yet learned about data structures in C.

You will not write an entire program. We provide a basic main function to handle the I/O. First, you will write a recursive solution, but this solution might not work for certain large inputs, for example, 2,000,000,001. Second, you will write an iterative solution that is guaranteed to work for all valid inputs.

Deeply Recursive Programs

When a function is called from a C program, it is allocated memory to store its parameters and local variables. This allocation typically occurs on a region called the *program stack*. You will learn more about program stacks later in the semester.

A recursive function is one that calls itself repeatedly until some condition is satisfied. Depending on how deep the recursion is, the program stack may consume a lot of memory. Eventually the program will run out of memory and crash. For example, a very simple recursive solution to count all prime factors is likely to crash with certain large inputs, for example, 2,000,000,001. You should learn to write programs which efficiently use their stack. This is especially important if the program will be executed on a platform with limited memory, such as embedded systems or mobile phones. In this assignment, you have to write both a recursive solution (that does not have to work on all inputs) and an iterative solution that uses the stack efficiently and works for all valid inputs. A valid input is any number that can be represented by an unsigned int.

The limit command can be used to check and change the maximum stack size which can be allocated by your program. The default maximum stack size per program is 8 MB and your solution will be graded using only that default size.

Notes

The compiler generates warnings for a reason. You should fix any code that generates a warning to minimize the chances of bugs. Experienced C programmers may understand what they are doing well enough to decide that a warning is unimportant. However, code that causes warnings can be an indication of actual program errors, so it is a good idea to fix any code that causes a warning regardless of your experience level. Your code should compile without any warnings. (We will use the -Wall and -Wextra flags to cc.)

Testing is critical in all programming. You need to be sure to comprehensively test the procedures that you write.

We provide a main function that you must not change. However, when -t is specified on the command line, the function test_factors will be called with no arguments instead of running the program normally. You may put whatever testing code you would like in this function. We will not use the -t argument when grading your program, so this is solely for you to use in your testing as you see fit.

When -r is specified on the command line, the function count_factors_recursive will be called. This function should have a recursive implementation. You must not use for or while loops in its implementation. You may write helper functions, as needed, but they too must not use any loops. As previously discussed, this function does not need to handle all inputs without crashing due to stack overflow. (That said, it is fine if you are able to design an implementation that does handle all inputs without crashing).

You may also find it helpful to use some simple printf statements within your procedures to see intermediate values during the execution of your program as you are testing and debugging your code. The printf statement in C has a format string followed by a list of zero or more additional arguments. The "%" characters in the format string specify the locations in the output where the additional arguments must be printed, and the character following each "%" must match the type of the corresponding argument to printf. For example, a single unsigned integer can be printed in C using printf as follows:

``c printf("Print an unsigned int, %u, between the commas.\n", number);``

You can also learn from the other printf statements in the code given to you. Using printf statements is an effective method of debugging simple programs and for narrowing down errors in more complex programs. However, make sure that you comment out all such printf statements when you are done, as the final program should only perform the input and output that is provided in the main function.

Use requires/effects comments for each procedure, as in the provided code. These procedure comments should be about *what* the procedure does, not *how* it does it. In other words, a procedure sum might have the following effects: *Returns the sum of the elements in the array.* An inappropriate comment would be: *loops over the elements in the array using a for loop, adds each element to a running sum, and then returns the running sum after the for loop completes.* Comments inside the procedure can be used to document what the procedure is doing when the code is not relatively obvious. However, commenting the statement i += 1; with "Add one to i." is pointless. It is only adding clutter to your program.

When you are modifying an existing program, *the first and foremost rule of good coding style* is that the style of your code, e.g., its indentation, should match the style of the surrounding code. In effect, it should not be obvious to a reader where different people have edited the code. Also, keep in mind that if you consistently indent your code, it will make it easier for someone else to understand your code.

Files

You should see the following files in your workspace:

factors.c - provided code (implement your solution here)
Makefile - specification for building factors using make
writeup.md - a skeleton writeup file
instructions.md - this file

Compiling and Running Your Code

To compile your code, use the Unix command:

make

This will compile your code producing an executable file named factors. This file can then be run to determine the number of prime factors of 12 as follows:

./factors
Enter number:
12
12 has 3 prime factors, 2 of them distinct.

Since a prime number's only prime factor is the number itself, inputting a prime number, such as 13, should produce output like:

13 has 1 prime factors, 1 of them distinct.

Make sure that the iterative version of your program works for all valid inputs. However, the recursive version of your program may crash with large inputs. For example, on executing the recursive solution to count all prime factors with input 2,000,000,001, the following will likely occur:

./factors -r
Enter number:
2000000001
Segmentation fault (core dumped)

Your program must only handle valid inputs. If an invalid input is given to your program, it is acceptable for your program to output nonsense. In addition, it is acceptable for the recursive version of your program to crash due to stack overflow on large valid inputs.

Testing

Use the grade tool to run the automated test suite:

# From the workspace directory
bin/grade .

# Or specify the workspace path
bin/grade ./workspaces/agent_factors

The grade tool will compile your code and run all tests, showing which pass and fail. Focus on getting all tests to pass.

--- *COMP 321: Introduction to Computer Systems, Rice University, Spring 2024*

factors.c3.8 KB

/*
 * COMP 321 Project 1: Factors
 *
 * This program computes the number of prime factors, and optionally the number
 * of distinct prime factors, for an unsigned integer input.
 * 
 * <Put your name and NetID here>
 */

#include <assert.h>
#include <math.h>     // Included in case you use the standard math library.
#include <stdbool.h>
#include <stdio.h>
#include <unistd.h>

static unsigned int	count_distinct_factors(unsigned int n);
static unsigned int	count_factors(unsigned int n);
static unsigned int	count_factors_recursive(unsigned int n);
static void		test_factors(void);

// Replace this comment with any global variable declarations.

// Replace this comment with any helper functions.
  
/* 
 * Requires:  
 *   The input "n" must be greater than 1.
 *
 * Effects: 
 *   Returns the number of factors of the input "n".
 */
static unsigned int
count_factors_recursive(unsigned int n)
{
	// Replace this comment with your local variable declarations.
    
	assert(n > 1);
	/*
	 * Replace this comment with your code.
	 */
	return (0);
}

/* 
 * Requires:  
 *   The input "n" must be greater than 1.
 *
 * Effects: 
 *   Returns the number of factors of the input "n".
 */
static unsigned int
count_factors(unsigned int n)
{
	// Replace this comment with your local variable declarations.
    
	assert(n > 1);
	/*
	 * Replace this comment with your code. 
	 */
	return (0);
}

/* 
 * Requires:  
 *   The input "n" must be greater than 1.
 *
 * Effects: 
 *   Returns the number of distinct factors of the input "n".
 */
static unsigned int
count_distinct_factors(unsigned int n)
{
	// Replace this comment with your local variable declarations.

	assert(n > 1);
	/*
	 * Replace this comment with your code.  Also, don't forget to modify
	 * the following statement to return the actual number of distinct
	 * factors.
	 */
	return (0);
}

/* 
 * Requires:
 *   Nothing.
 *
 * Effects:
 *   Runs testing procedures.  Currently only prints a message.
 */
static void
test_factors(void)
{

	printf("Test Factors\n");
}

/* 
 * Requires:
 *   Nothing.
 *
 * Effects:
 *   If the "-t" option is specified on the command line, then test code is
 *   executed and the program exits.
 *   
 *   Otherwise, requests a number from standard input.  If the "-r" option is
 *   specified on the command line, then prints the number of prime factors
 *   that the input number has, calculated using a recursive function.
 *   Otherwise, prints the number of prime factors that the input number has
 *   and the number of those factors that are distinct using iterative
 *   functions.
 *
 *   Upon completion, the program always returns 0.
 *
 *   If the number that is input is not between 2 and the largest unsigned
 *   integer, the output of the program is undefined, but it will not crash.
 */
int
main(int argc, char **argv)
{
	unsigned int n;
	int c;
	bool recursive = false;
	bool runtests = false;

	// Parse the command line.
	while ((c = getopt(argc, argv, "rt")) != -1) {
		switch (c) {
		case 'r':             // Use recursive version.
			recursive = true;
			break;
		case 't':             // Run test procedure and exit.
			runtests = true;
			break;
		default:
			break;
		}
	}

	// If "-t" is specified, run test procedure and exit program.
	if (runtests) {
		test_factors();
		return (0);
	}

	// Get input.
	printf("Enter number:\n");
	if (scanf("%u", &n) != 1) {
		fprintf(stderr, "Input error\n");
		return (1);
	}

	// Validate the input.
	if (n < 2) {
		fprintf(stderr, "Invalid input: %u\n", n);
		return (1);
	}

	// Print results.
	if (recursive) {
		// Use recursive version.
		printf("%u has %u prime factors.\n",
		    n, count_factors_recursive(n));
	} else {
		// Use iterative versions.
		printf("%u has %u prime factors, %u of them distinct.\n",
		    n, count_factors(n), count_distinct_factors(n));
	}

	// Report no errors.
	return (0);
}

factors.c3.8 KB

/*
 * COMP 321 Project 1: Factors
 *
 * This program computes the number of prime factors, and optionally the number
 * of distinct prime factors, for an unsigned integer input.
 * 
 * <Put your name and NetID here>
 */

#include <assert.h>
#include <math.h>     // Included in case you use the standard math library.
#include <stdbool.h>
#include <stdio.h>
#include <unistd.h>

static unsigned int	count_distinct_factors(unsigned int n);
static unsigned int	count_factors(unsigned int n);
static unsigned int	count_factors_recursive(unsigned int n);
static void		test_factors(void);

// Replace this comment with any global variable declarations.

// Replace this comment with any helper functions.
  
/* 
 * Requires:  
 *   The input "n" must be greater than 1.
 *
 * Effects: 
 *   Returns the number of factors of the input "n".
 */
static unsigned int
count_factors_recursive(unsigned int n)
{
	// Replace this comment with your local variable declarations.
    
	assert(n > 1);
	/*
	 * Replace this comment with your code.
	 */
	return (0);
}

/* 
 * Requires:  
 *   The input "n" must be greater than 1.
 *
 * Effects: 
 *   Returns the number of factors of the input "n".
 */
static unsigned int
count_factors(unsigned int n)
{
	// Replace this comment with your local variable declarations.
    
	assert(n > 1);
	/*
	 * Replace this comment with your code. 
	 */
	return (0);
}

/* 
 * Requires:  
 *   The input "n" must be greater than 1.
 *
 * Effects: 
 *   Returns the number of distinct factors of the input "n".
 */
static unsigned int
count_distinct_factors(unsigned int n)
{
	// Replace this comment with your local variable declarations.

	assert(n > 1);
	/*
	 * Replace this comment with your code.  Also, don't forget to modify
	 * the following statement to return the actual number of distinct
	 * factors.
	 */
	return (0);
}

/* 
 * Requires:
 *   Nothing.
 *
 * Effects:
 *   Runs testing procedures.  Currently only prints a message.
 */
static void
test_factors(void)
{

	printf("Test Factors\n");
}

/* 
 * Requires:
 *   Nothing.
 *
 * Effects:
 *   If the "-t" option is specified on the command line, then test code is
 *   executed and the program exits.
 *   
 *   Otherwise, requests a number from standard input.  If the "-r" option is
 *   specified on the command line, then prints the number of prime factors
 *   that the input number has, calculated using a recursive function.
 *   Otherwise, prints the number of prime factors that the input number has
 *   and the number of those factors that are distinct using iterative
 *   functions.
 *
 *   Upon completion, the program always returns 0.
 *
 *   If the number that is input is not between 2 and the largest unsigned
 *   integer, the output of the program is undefined, but it will not crash.
 */
int
main(int argc, char **argv)
{
	unsigned int n;
	int c;
	bool recursive = false;
	bool runtests = false;

	// Parse the command line.
	while ((c = getopt(argc, argv, "rt")) != -1) {
		switch (c) {
		case 'r':             // Use recursive version.
			recursive = true;
			break;
		case 't':             // Run test procedure and exit.
			runtests = true;
			break;
		default:
			break;
		}
	}

	// If "-t" is specified, run test procedure and exit program.
	if (runtests) {
		test_factors();
		return (0);
	}

	// Get input.
	printf("Enter number:\n");
	if (scanf("%u", &n) != 1) {
		fprintf(stderr, "Input error\n");
		return (1);
	}

	// Validate the input.
	if (n < 2) {
		fprintf(stderr, "Invalid input: %u\n", n);
		return (1);
	}

	// Print results.
	if (recursive) {
		// Use recursive version.
		printf("%u has %u prime factors.\n",
		    n, count_factors_recursive(n));
	} else {
		// Use iterative versions.
		printf("%u has %u prime factors, %u of them distinct.\n",
		    n, count_factors(n), count_distinct_factors(n));
	}

	// Report no errors.
	return (0);
}

factors.c4.2 KB

/*
 * COMP 321 Project 1: Factors
 *
 * This program computes the number of prime factors, and optionally the number
 * of distinct prime factors, for an unsigned integer input.
 * 
 * <Put your name and NetID here>
 */

#include <assert.h>
#include <math.h>     // Included in case you use the standard math library.
#include <stdbool.h>
#include <stdio.h>
#include <unistd.h>

static unsigned int	count_distinct_factors(unsigned int n);
static unsigned int	count_factors(unsigned int n);
static unsigned int	count_factors_recursive(unsigned int n);
static void		test_factors(void);

// Replace this comment with any global variable declarations.

/*
 * Requires:
 *   The input "n" must be greater than or equal to 1, and "d" must be
 *   greater than or equal to 2.
 *
 * Effects:
 *   Returns the number of prime factors of "n", considering only
 *   candidate divisors starting from "d".
 */
static unsigned int
count_factors_recursive_helper(unsigned int n, unsigned int d)
{

	if (n == 1)
		return (0);
	if ((unsigned long long)d * d > n)
		return (1);
	if (n % d == 0)
		return (1 + count_factors_recursive_helper(n / d, d));
	return (count_factors_recursive_helper(n, d + 1));
}
  
/* 
 * Requires:  
 *   The input "n" must be greater than 1.
 *
 * Effects: 
 *   Returns the number of factors of the input "n".
 */
static unsigned int
count_factors_recursive(unsigned int n)
{
	assert(n > 1);

	return (count_factors_recursive_helper(n, 2));
}

/*
 * Requires:
 *   The input "n" must be greater than 1.
 *
 * Effects:
 *   Returns the number of factors of the input "n".
 */
static unsigned int
count_factors(unsigned int n)
{
	unsigned int count = 0;
	unsigned int d;

	assert(n > 1);

	for (d = 2; (unsigned long long)d * d <= n; d++) {
		while (n % d == 0) {
			count++;
			n /= d;
		}
	}
	if (n > 1)
		count++;

	return (count);
}

/*
 * Requires:
 *   The input "n" must be greater than 1.
 *
 * Effects:
 *   Returns the number of distinct factors of the input "n".
 */
static unsigned int
count_distinct_factors(unsigned int n)
{
	unsigned int count = 0;
	unsigned int d;

	assert(n > 1);

	for (d = 2; (unsigned long long)d * d <= n; d++) {
		if (n % d == 0) {
			count++;
			while (n % d == 0)
				n /= d;
		}
	}
	if (n > 1)
		count++;

	return (count);
}

/* 
 * Requires:
 *   Nothing.
 *
 * Effects:
 *   Runs testing procedures.  Currently only prints a message.
 */
static void
test_factors(void)
{

	printf("Test Factors\n");
}

/* 
 * Requires:
 *   Nothing.
 *
 * Effects:
 *   If the "-t" option is specified on the command line, then test code is
 *   executed and the program exits.
 *   
 *   Otherwise, requests a number from standard input.  If the "-r" option is
 *   specified on the command line, then prints the number of prime factors
 *   that the input number has, calculated using a recursive function.
 *   Otherwise, prints the number of prime factors that the input number has
 *   and the number of those factors that are distinct using iterative
 *   functions.
 *
 *   Upon completion, the program always returns 0.
 *
 *   If the number that is input is not between 2 and the largest unsigned
 *   integer, the output of the program is undefined, but it will not crash.
 */
int
main(int argc, char **argv)
{
	unsigned int n;
	int c;
	bool recursive = false;
	bool runtests = false;

	// Parse the command line.
	while ((c = getopt(argc, argv, "rt")) != -1) {
		switch (c) {
		case 'r':             // Use recursive version.
			recursive = true;
			break;
		case 't':             // Run test procedure and exit.
			runtests = true;
			break;
		default:
			break;
		}
	}

	// If "-t" is specified, run test procedure and exit program.
	if (runtests) {
		test_factors();
		return (0);
	}

	// Get input.
	printf("Enter number:\n");
	if (scanf("%u", &n) != 1) {
		fprintf(stderr, "Input error\n");
		return (1);
	}

	// Validate the input.
	if (n < 2) {
		fprintf(stderr, "Invalid input: %u\n", n);
		return (1);
	}

	// Print results.
	if (recursive) {
		// Use recursive version.
		printf("%u has %u prime factors.\n",
		    n, count_factors_recursive(n));
	} else {
		// Use iterative versions.
		printf("%u has %u prime factors, %u of them distinct.\n",
		    n, count_factors(n), count_distinct_factors(n));
	}

	// Report no errors.
	return (0);
}

COMP 321 Project 1: Factors

Student Information

Student, abc123

Testing Strategy

I tested each function individually using a range of inputs:

Small primes (2, 3, 5, 7, 11, 13, 17) to verify that each returns exactly 1 factor and 1 distinct factor.
Small composites (4, 6, 8, 9, 10, 12, 14, 16) to verify correct total and distinct counts. For example, 12 = 2 * 2 * 3 has 3 total factors and 2 distinct, while 16 = 2^4 has 4 total factors and 1 distinct.
Numbers with many distinct prime factors like 510510 = 2 * 3 * 5 * 7 * 11 * 13 * 17 (7 total, 7 distinct) and 223092870 = 2 * 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23 (9 total, 9 distinct).
Large values near the unsigned int boundary: 2147483647 (a Mersenne prime), 2147483648 = 2^31, 4294967291 (the largest 32-bit prime), and 4294967295 = 3 * 5 * 17 * 257 * 65537.
I compared the recursive version against the iterative version on all inputs where the recursive version does not overflow the stack, confirming they produce identical results.
I verified that the recursive version does not use any loops, relying solely on a helper function that recurses on both candidate divisor increments and factor extraction.

Something I Learned

I learned that unsigned integer arithmetic in C can silently overflow without any warning or error. Specifically, when computing d * d to check whether a candidate divisor exceeds the square root of n, the multiplication can overflow if d is large enough (e.g., around 65536 for a 32-bit unsigned int). The result wraps around modulo 2^32, which could cause the loop to run far longer than intended or produce incorrect results. To avoid this, I cast one operand to unsigned long long before multiplying, ensuring the computation is performed in 64-bit arithmetic. This silent overflow behavior differs from languages like Java or Python that either throw exceptions or use arbitrary-precision integers, and it highlighted the importance of being aware of type widths when writing C code.

Section: Testing Strategy

Score: 3/3 points

Assessment:

What was provided: The student describes a thorough, systematic testing strategy with multiple categories of inputs and specific concrete examples with expected outputs.

Strengths:

Excellent specificity: every category includes concrete numbers with their full prime factorizations and expected total/distinct counts (e.g., 12 = 2 × 2 × 3 → 3 total, 2 distinct; 16 = 2⁴ → 4 total, 1 distinct).
Strong coverage of normal cases: small primes, small composites, and numbers with many distinct factors (510510, 223092870).
Thorough boundary testing: tests values near the unsigned int maximum including 2147483647 (Mersenne prime), 2^31, 4294967291 (largest 32-bit prime), and 4294967295 = UINT_MAX.
Includes comparison testing between recursive and iterative implementations.
Verifies structural correctness of the recursive version (no loops).

Errors/Gaps:

Does not explicitly mention testing n = 1 (though the assignment states valid inputs are > 1, so this is a very minor point).
Powers of 2 are implicitly covered (16 = 2⁴, 2^31) but not called out as a distinct category.

Detailed Feedback: This is an exemplary testing strategy. The student demonstrates a systematic approach organized by input category (primes, composites, many-factor numbers, boundary values). Each category includes specific test values with expected results, making the strategy concrete and reproducible. The inclusion of boundary values near UINT_MAX shows awareness of the unsigned int domain, and the comparison testing between recursive and iterative versions is exactly what the rubric calls for. The level of detail and specificity far exceeds the threshold for full credit.

Rubric Breakdown:

Normal cases with specific examples: 1/1 — Excellent coverage of primes, composites, and multi-factor numbers
Edge/boundary cases: 1/1 — Strong coverage of unsigned int boundaries and large primes
Comparison/cross-implementation testing: 1/1 — Explicitly compares recursive and iterative versions

---

Section: Something I Learned

Score: 2/2 points

Assessment:

What was provided: The student describes unsigned integer overflow behavior in C, specifically how d * d can silently wrap around modulo 2^32, and their solution of casting to unsigned long long.

Strengths:

Identifies a specific, relevant C feature: silent unsigned integer overflow (wraparound).
Provides a concrete scenario from the assignment where this matters (checking d * d against n for divisor bounds).
Explains the practical consequence (loop running too long or producing incorrect results).
Describes their solution (casting to unsigned long long for 64-bit arithmetic).
Demonstrates genuine understanding by contrasting with Java and Python behavior.
Shows depth of understanding about type widths and implicit arithmetic rules.

Errors/Gaps:

None. This is a thorough and technically accurate response.

Detailed Feedback: This is an outstanding answer. The student identifies a subtle and practically important C feature — that unsigned arithmetic wraps around silently without any runtime error — and ties it directly to a real problem encountered in the assignment. The explanation of the overflow threshold (~65536 for 32-bit multiplication), the modular wraparound behavior, and the fix using wider types demonstrates genuine systems-level understanding. The comparison with Java and Python further shows the student appreciates how C's low-level nature differs from higher-level languages. This clearly represents learning beyond what was taught in lecture.

Rubric Breakdown:

Identifies specific C feature: 1/1 — Unsigned integer overflow/wraparound is a valid and important C feature
Demonstrates understanding and genuine learning: 1/1 — Deep explanation with concrete example, solution, and cross-language comparison

---

Overall Summary

Section	Score	Notes
Testing Strategy	3/3	Systematic, specific examples across all categories, includes comparison testing
Something I Learned	2/2	Excellent explanation of unsigned overflow with concrete scenario and fix
Total	5/5

General Comments:

This is an excellent submission. The testing strategy is thorough and well-organized with concrete examples that demonstrate the student thought carefully about input coverage, including boundary values near UINT_MAX. The "Something I Learned" response shows genuine systems-level understanding of C's unsigned arithmetic semantics, going well beyond a surface-level observation to explain the problem, its consequences, and the solution. Both answers demonstrate strong technical understanding appropriate for an introductory systems course.

Total: 5/5

.mcp.json

diff --git a/.mcp.json b/.mcp.json
deleted file mode 100644
index b169d5a..0000000
--- a/.mcp.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "mcpServers": {
-    "bscs-bench": {
-      "command": "/Users/bebe/Code/bscs-bench/bin/bscs-mcp",
-      "args": [
-        "--workspace",
-        "./lib b/lib
index af4ebc4..7620d8e 120000
--- a/lib
+++ b/lib
@@ -1 +1 @@
-/Users/bebe/Code/bscs-bench/comp321/lib
\ No newline at end of file
+/opt/csapp
\ No newline at end of file

writeup.md

diff --git a/writeup.md b/writeup.md
index d387eed..47eba92 100644
--- a/writeup.md
+++ b/writeup.md
@@ -1,10 +1,17 @@
 # COMP 321 Project 1: Factors
 
 ## Student Information
-[Replace with your name and NetID.]
+Student, abc123
 
 ## Testing Strategy
-[Replace with a detailed description of your testing strategy.]
+I tested each function individually using a range of inputs:
+
+- Small primes (2, 3, 5, 7, 11, 13, 17) to verify that each returns exactly 1 factor and 1 distinct factor.
+- Small composites (4, 6, 8, 9, 10, 12, 14, 16) to verify correct total and distinct counts. For example, 12 = 2 * 2 * 3 has 3 total factors and 2 distinct, while 16 = 2^4 has 4 total factors and 1 distinct.
+- Numbers with many distinct prime factors like 510510 = 2 * 3 * 5 * 7 * 11 * 13 * 17 (7 total, 7 distinct) and 223092870 = 2 * 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23 (9 total, 9 distinct).
+- Large values near the unsigned int boundary: 2147483647 (a Mersenne prime), 2147483648 = 2^31, 4294967291 (the largest 32-bit prime), and 4294967295 = 3 * 5 * 17 * 257 * 65537.
+- I compared the recursive version against the iterative version on all inputs where the recursive version does not overflow the stack, confirming they produce identical results.
+- I verified that the recursive version does not use any loops, relying solely on a helper function that recurses on both candidate divisor increments and factor extraction.
 
 ## Something I Learned
-[Replace with a description of one feature of C that you learned while completing this assignment that wasn't taught in lecture or lab.]
+I learned that unsigned integer arithmetic in C can silently overflow without any warning or error. Specifically, when computing `d * d` to check whether a candidate divisor exceeds the square root of `n`, the multiplication can overflow if `d` is large enough (e.g., around 65536 for a 32-bit unsigned int). The result wraps around modulo 2^32, which could cause the loop to run far longer than intended or produce incorrect results. To avoid this, I cast one operand to `unsigned long long` before multiplying, ensuring the computation is performed in 64-bit arithmetic. This silent overflow behavior differs from languages like Java or Python that either throw exceptions or use arbitrary-precision integers, and it highlighted the importance of being aware of type widths when writing C code.

Agent Work: Prime Factors

COMP 321: Introduction to Computer Systems

Project 1: Factors

Overview

Summary

Deeply Recursive Programs

Notes

Files

Compiling and Running Your Code

Testing

COMP 321 Project 1: Factors

Student Information

Testing Strategy

Something I Learned

Section: Testing Strategy

Score: 3/3 points

Assessment:

Rubric Breakdown:

Section: Something I Learned

Score: 2/2 points

Assessment:

Rubric Breakdown:

Overall Summary

General Comments:

Sub-Model Usage