17_prime_factors.lua

@@ -1,50 +0,0 @@
--- Write a function which determines the prime factors of a given
--- number, returning them in a list.  You may assume that none of the
--- prime factors are above 10000
---
--- Solution --------------------------------------------------------------------
-function prime_factors(n)
-	-- Your implementation here
-end
-
--- Tests -----------------------------------------------------------------------
-
-local luaunit = require("luaunit.luaunit")
-
-function test_prime_factors_of_42()
-	luaunit.assertItemsEquals(prime_factors(42), {2, 3, 7})
-end
-
-function test_prime_factors_of_70()
-	luaunit.assertItemsEquals(prime_factors(70), {2, 5, 7})
-end
-
-function test_prime_factors_of_253()
-	luaunit.assertItemsEquals(prime_factors(253), {11, 23})
-end
-
-function test_prime_factors_of_245()
-	luaunit.assertItemsEquals(prime_factors(245), {5, 7, 7})
-end
-
-function test_prime_factors_of_36()
-	luaunit.assertItemsEquals(prime_factors(36), {2, 2, 3, 3})
-end
-
-function test_prime_factors_of_1337()
-	luaunit.assertItemsEquals(prime_factors(1337), {7, 191})
-end
-
-function test_prime_factors_of_4321()
-	luaunit.assertItemsEquals(prime_factors(4321), {29, 149})
-end
-
-function test_prime_factors_of_57812834()
-	luaunit.assertItemsEquals(prime_factors(57812834), {2, 29, 113, 8821})
-end
-
-function test_prime_factors_of_8894220()
-	luaunit.assertItemsEquals(prime_factors(8894220), {2, 2, 3, 5, 271, 547})
-end
-
-os.exit(luaunit.LuaUnit.run())

19_dependencies.lua

@@ -1,105 +0,0 @@
--- Write a function to generate a valid order for a number of jobs
--- that depend upon each other.  Your input is a jobs table; each key
--- is a job number, with its the values being a list jobs it depends
--- on.  You may assume that there are no circular dependencies.
---
--- Return a list of job numbers, so that performing the jobs in that
--- order ensures that all jobs are exactly once, and all dependencies
--- of a job are done before prior to it.
---
--- Solution --------------------------------------------------------------------
-function schedule(jobs)
-	-- Your implementation here
-end
-
--- Tests -----------------------------------------------------------------------
-
-local luaunit = require("luaunit.luaunit")
-
-local function keys(t)
-	local results = {}
-	for key, _ in pairs(t) do table.insert(results, key) end
-	return results
-end
-
-local function contains(list, target)
-	for _, item in ipairs(list) do if item == target then return true end end
-	return false
-end
-
-local function deep_copy(original)
-	local copy = {}
-	if type(original) == "table" then
-		for key, value in pairs(original) do
-			local key_copy = deep_copy(key)
-			local value_copy = deep_copy(value)
-			copy[key_copy] = value_copy
-		end
-	else
-		copy = original
-	end
-	return copy
-end
-
-local function assert_valid(order, jobs)
-	local done = {}
-	for _, job in ipairs(order) do
-		for _, dependency in ipairs(jobs[job]) do
-			luaunit.assertTrue(contains(done, dependency))
-		end
-		table.insert(done, job)
-	end
-end
-
-local function test_case(jobs)
-	local order = schedule(deep_copy(jobs))
-	luaunit.assertItemsEquals(order, keys(jobs))
-	assert_valid(order, jobs)
-end
-
-function test_sequential_dependencies()
-	local jobs = {[1] = {2}, [2] = {3}, [3] = {}}
-	test_case(jobs)
-end
-
-function test_converging_dependencies()
-	local jobs = {
-		[1] = {5},
-		[2] = {5},
-		[3] = {6},
-		[4] = {6},
-		[5] = {7},
-		[6] = {7},
-		[7] = {},
-	}
-	test_case(jobs)
-end
-
-function test_diverging_dependencies()
-	local jobs = {
-		[1] = {2, 3},
-		[2] = {4, 5},
-		[3] = {6, 7},
-		[4] = {},
-		[5] = {},
-		[6] = {},
-		[7] = {}
-	}
-	test_case(jobs)
-end
-
-function test_compound_dependencies()
-	local jobs = {
-		[1] = {2, 3, 4},
-		[2] = {5, 6},
-		[3] = {7},
-		[4] = {7},
-		[5] = {},
-		[6] = {8},
-		[7] = {8},
-		[8] = {}
-	}
-	test_case(jobs)
-end
-
-os.exit(luaunit.LuaUnit.run())