No partner specified You have used the 'Check All Submitted Files' feature 1 times (max allowed: 10) You have 9 checks remaining. The following files were submitted: ---------------------------------- 4.5K Sep 16 06:57 Percolation.java 3.4K Sep 16 06:57 PercolationStats.java 6.6K Sep 16 06:57 readme.txt ******************************************************************************** * COMPILING ******************************************************************************** % javac Percolation.java *----------------------------------------------------------- % javac PercolationStats.java *----------------------------------------------------------- ================================================================ Checking the APIs of your programs. *----------------------------------------------------------- Percolation: PercolationStats: ================================================================ ******************************************************************************** * CHECKING STYLE AND COMMON BUG PATTERNS ******************************************************************************** % spotbugs *.class *----------------------------------------------------------- ================================================================ % pmd . *----------------------------------------------------------- ================================================================ % checkstyle *.java *----------------------------------------------------------- % custom checkstyle checks for Percolation.java *----------------------------------------------------------- % custom checkstyle checks for PercolationStats.java *----------------------------------------------------------- % custom checkstyle checks for readme.txt *----------------------------------------------------------- ================================================================ ******************************************************************************** * TESTING CORRECTNESS ******************************************************************************** Testing correctness of Percolation *----------------------------------------------------------- Running 12 total tests. Tests 1 through 8 create a Percolation object using your code, then repeatedly open sites by calling open(). After each call to open(), it checks the return values of isOpen(), percolates(), numberOfOpenSites(), and isFull() in that order. Except as noted, a site is opened at most once. Tests 13 through 15 test backwash. Test 1: open predetermined list of sites using file inputs * filename = input6.txt * filename = input8.txt * filename = input8-no.txt * filename = input10-no.txt * filename = greeting57.txt * filename = heart25.txt ==> passed Test 2: open random sites until just before system percolates * n = 3 * n = 5 * n = 10 * n = 10 * n = 20 * n = 20 * n = 50 * n = 50 ==> passed Test 3: open predetermined sites for n = 1 and n = 2 (corner case test) * filename = input1.txt * filename = input1-no.txt * filename = input2.txt * filename = input2-no.txt ==> passed Test 4: check predetermined sites with long percolating path * filename = snake13.txt * filename = snake101.txt ==> passed Test 5: open every site * filename = input5.txt ==> passed Test 6: open random sites until just before system percolates, allowing open() to be called on a site more than once * n = 3 * n = 5 * n = 10 * n = 10 * n = 20 * n = 20 * n = 50 * n = 50 ==> passed Test 7: call methods with invalid arguments * n = 10, (row, col) = (-1, 5) * n = 10, (row, col) = (11, 5) * n = 10, (row, col) = (10, 5) * n = 10, (row, col) = (5, -1) * n = 10, (row, col) = (5, 11) * n = 10, (row, col) = (5, 10) * n = 10, (row, col) = (-2147483648, -2147483648) * n = 10, (row, col) = (2147483647, 2147483647) ==> passed Test 8: call constructor with invalid argument * n = -10 * n = -1 * n = 0 ==> passed Test 9: create multiple Percolation objects at the same time (to make sure you didn't store data in static variables) ==> passed Test 10: open predetermined list of sites using file inputs, but permute the order in which methods are called * filename = input8.txt; order = isFull(), isOpen(), percolates() * filename = input8.txt; order = isFull(), percolates(), isOpen() * filename = input8.txt; order = isOpen(), isFull(), percolates() * filename = input8.txt; order = isOpen(), percolates(), isFull() * filename = input8.txt; order = percolates(), isOpen(), isFull() * filename = input8.txt; order = percolates(), isFull(), isOpen() ==> passed Test 11: call all methods in random order until just before system percolates * n = 3 * n = 5 * n = 7 * n = 10 * n = 20 * n = 50 ==> passed Test 12: call all methods in random order until almost all sites are open, but with inputs not prone to backwash * n = 3 * n = 5 * n = 7 * n = 10 * n = 20 * n = 50 ==> passed Test 13: check for backwash with predetermined sites * filename = input20.txt * filename = input10.txt * filename = input50.txt * filename = jerry47.txt * filename = sedgewick60.txt * filename = wayne98.txt ==> passed Test 14: check for backwash with predetermined sites that have multiple percolating paths * filename = input3.txt * filename = input4.txt * filename = input7.txt ==> passed Test 15: call all methods in random order until all sites are open, allowing isOpen() to be called on a site more than once (these inputs are prone to backwash) * n = 3 * n = 5 * n = 7 * n = 10 * n = 20 * n = 50 ==> passed Total: 15/12 tests passed! ================================================================ ******************************************************************************** * TESTING CORRECTNESS (substituting reference Percolation) ******************************************************************************** Testing correctness of PercolationStats *----------------------------------------------------------- Running 16 total tests. Test 1: check formatting of output of main() % java-algs4 PercolationStats 20 10 mean() = 0.635 stddev() = 0.028939592256975556 confidenceLow() = 0.6170630548866314 confidenceHigh() = 0.6529369451133686 elapsed time = 0.003 % java-algs4 PercolationStats 200 100 mean() = 0.5909880000000001 stddev() = 0.009088013445403699 confidenceLow() = 0.589206749364701 confidenceHigh() = 0.5927692506352992 elapsed time = 0.374 ==> passed Test 2: check that methods in PercolationStats do not print to standard output * n = 20, trials = 10 * n = 50, trials = 20 * n = 100, trials = 50 * n = 64, trials = 150 ==> passed Test 3: check that mean() returns value in expected range * n = 2, trials = 10000 * n = 5, trials = 10000 * n = 10, trials = 10000 * n = 25, trials = 10000 ==> passed Test 4: check that stddev() returns value in expected range * n = 2, trials = 10000 * n = 5, trials = 10000 * n = 10, trials = 10000 * n = 25, trials = 10000 ==> passed Test 5: check that PercolationStats creates trials Percolation objects, each of size n-by-n * n = 20, trials = 10 * n = 50, trials = 20 * n = 100, trials = 50 * n = 64, trials = 150 ==> passed Test 6: check that PercolationStats calls open() until system percolates * n = 20, trials = 10 * n = 50, trials = 20 * n = 100, trials = 50 * n = 64, trials = 150 ==> passed Test 7: check that PercolationStats does not call open() after system percolates * n = 20, trials = 10 * n = 50, trials = 20 * n = 100, trials = 50 * n = 64, trials = 150 ==> passed Test 8: check that mean() is consistent with the number of intercepted calls to open() on blocked sites * n = 20, trials = 10 * n = 50, trials = 20 * n = 100, trials = 50 * n = 64, trials = 150 ==> passed Test 9: check that stddev() is consistent with the number of intercepted calls to open() on blocked sites * n = 20, trials = 10 * n = 50, trials = 20 * n = 100, trials = 50 * n = 64, trials = 150 ==> passed Test 10: check that confidenceLow() and confidenceHigh() are consistent with mean() and stddev() * n = 20, trials = 10 * n = 50, trials = 20 * n = 100, trials = 50 * n = 64, trials = 150 ==> passed Test 11: check that exception is thrown if either n or trials is out of bounds * n = -23, trials = 42 * n = 23, trials = 0 * n = -42, trials = 0 * n = 42, trials = -1 * n = -2147483648, trials = -2147483648 ==> passed Test 12: create two PercolationStats objects at the same time and check mean() (to make sure you didn't store data in static variables) * n1 = 50, trials1 = 10, n2 = 50, trials2 = 5 * n1 = 50, trials1 = 5, n2 = 50, trials2 = 10 * n1 = 50, trials1 = 10, n2 = 25, trials2 = 10 * n1 = 25, trials1 = 10, n2 = 50, trials2 = 10 * n1 = 50, trials1 = 10, n2 = 15, trials2 = 100 * n1 = 15, trials1 = 100, n2 = 50, trials2 = 10 ==> passed Test 13: check that the methods return the same value regardless of the order in which they are called * n = 20, trials = 10 * n = 50, trials = 20 * n = 100, trials = 50 * n = 64, trials = 150 ==> passed Test 14: check that no calls to StdRandom.setSeed() * n = 20, trials = 10 * n = 20, trials = 10 * n = 40, trials = 10 * n = 80, trials = 10 ==> passed Test 15: check distribution of total number of sites opened until percolation * n = 2, trials = 100000 * n = 3, trials = 100000 * n = 4, trials = 100000 ==> passed Test 16: check that each site is opened the expected number of times * n = 2, trials = 100000 * n = 3, trials = 100000 * n = 4, trials = 100000 ==> passed Total: 16/16 tests passed! ================================================================ ******************************************************************************** * MEMORY (substituting reference Percolation) ******************************************************************************** Analyzing memory of PercolationStats *----------------------------------------------------------- Running 4 total tests. Test 1a-1d: check memory usage as a function of T trials for n = 100 (max allowed: 8*T + 128 bytes) T bytes -------------------------------------------- => passed 16 40 => passed 32 40 => passed 64 40 => passed 128 40 ==> 4/4 tests passed Estimated student memory = 40.00 (R^2 = 1.000) Total: 4/4 tests passed! ================================================================ ******************************************************************************** * TIMING (substituting reference Percolation) ******************************************************************************** Timing PercolationStats *----------------------------------------------------------- Running 3 total tests. Test 1: count calls to StdStats.mean() and StdStats.stddev() * n = 20, trials = 10 * n = 50, trials = 20 * n = 100, trials = 50 * n = 64, trials = 150 ==> passed Test 2: count calls to methods in StdRandom * n = 20, trials = 10 * n = 20, trials = 10 * n = 40, trials = 10 * n = 80, trials = 10 ==> passed Test 3: count calls to methods in Percolation * n = 20, trials = 10 * n = 50, trials = 20 * n = 100, trials = 50 * n = 64, trials = 150 ==> passed Total: 3/3 tests passed! ================================================================ ******************************************************************************** * MEMORY ******************************************************************************** Analyzing memory of Percolation *----------------------------------------------------------- Running 4 total tests. Test 1a-1d: check that total memory <= 17 n^2 + 128 n + 1024 bytes n bytes -------------------------------------------- => passed 64 71928 => passed 256 1122552 => passed 512 4473080 => passed 1024 17858808 ==> 4/4 tests passed Estimated student memory = 17.00 n^2 + 32.00 n + 248.00 (R^2 = 1.000) Test 2 (bonus): check that total memory <= 11 n^2 + 128 n + 1024 bytes - failed memory test for n = 64 ==> FAILED Total: 4/4 tests passed! ================================================================ ******************************************************************************** * TIMING ******************************************************************************** Timing Percolation *----------------------------------------------------------- Test 1a-1e: Creates an n-by-n percolation system; open sites at random until the system percolates, interleaving calls to percolates() and open(). Count calls to connected(), union() and find(). 2 * connected() n union() + find() constructor ----------------------------------------------------------------------------------- => passed 16 373 302 2 => passed 32 1267 1102 2 => passed 64 6325 5064 2 => passed 128 21927 18842 2 => passed 256 90843 77018 2 => passed 512 366237 309558 2 => passed 1024 1482329 1246374 2 ==> 7/7 tests passed If one of the values in the table violates the performance limits the factor by which you failed the test appears in parentheses. For example, (9.6x) in the union() column indicates that it uses 9.6x too many calls. Tests 2a-2f: Check whether the number of calls to union(), connected(), and find() is a constant per call to open(), isOpen(), isFull(), and percolates(). The table shows the maximum number of union(), connected(), and find() calls made during a single call to open(), isOpen(), isFull(), and percolates(). n per open() per isOpen() per isFull() per percolates() --------------------------------------------------------------------------------------------- => passed 16 8 0 1 1 => passed 32 8 0 1 1 => passed 64 8 0 1 1 => passed 128 8 0 1 1 => passed 256 8 0 1 1 => passed 512 8 0 1 1 => passed 1024 8 0 1 1 ==> 7/7 tests passed ================================================================