2D Arraylab

Author: axmed-cs

.gitignore

@@ -0,0 +1,2 @@
+# Project exclude paths
+/target/

pom.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.example</groupId>
+    <artifactId>ArraysLab</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.8.1</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>

src/main/java/edu/sdccd/cisc191/ArrayLab.java

@@ -0,0 +1,102 @@
+package edu.sdccd.cisc191;
+
+/**
+ * CISC191 2.3 Multidimensional Arrays - Junior
+ * @author Ahmed Abdullahi
+ */
+
+
+public class ArrayLab {
+    /**
+     * @param args command line parameters
+     */
+    public static void main(String[] args) {
+        int[][] spreadsheet = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+        System.out.println("Max: " + max(spreadsheet));
+        System.out.println("Sum of row 0: " + rowSum(spreadsheet, 0));
+        System.out.println("Sum of col 0: " + columnSum(spreadsheet, 0));
+        int[] rowSums = allRowSums(spreadsheet);
+        for (int row = 0; row < rowSums.length; row++) {
+            System.out.println("Sum of row " + row + ": " + rowSums[row]);
+        }
+
+    }
+
+    /**
+     * @param a 2D array
+     * @return the maximum value in the 2d parameter array a
+     */
+    public static int max(int[][] a) {
+
+        // Setting the max to row 0 column 0
+        int max = a[0][0];
+
+        //if there exists a number greater than the current max a[0][0]
+        // then set it as the new max
+        for (int i = 0; i < a.length; i++) {
+            for (int j = 0; j < a[i].length; j++) {
+                if (a[i][j] > max) max = a[i][j];
+            }
+        }
+
+        return max;
+    }
+
+    /**
+     * @param a 2D array
+     * @param x row index
+     * @return the sum of the elements in Row x of a
+     */
+    public static int rowSum(int[][] a, int x) {
+
+        // totalSum will hold the total sum for row x of a
+        int totalSum = 0;
+
+        //loop that prints out the row sum
+        //a[x].length reads length of the row and the loop reiterates until it reaches the length
+        for (int i = 0; i < a[x].length; i++) {
+            totalSum += a[x][i];
+        }
+        return totalSum;
+    }
+
+    /**
+     * @param a 2D array
+     * @param x column index
+     * @return the sum of the elements in Column x of a (careful with rows of different lengths!)
+     */
+    public static int columnSum(int[][] a, int x) {
+
+        //totalSum will hold the total sum for the column x of a
+        int totalSum = 0;
+
+        //loop that will get the total sum for each column x of a
+        for (int i = 0; i < a.length; i++) {
+            if(a[i].length > x )
+                totalSum += a[i][x];
+
+        }
+
+            return totalSum;
+    }
+
+    /**
+     * @param a 2D array
+     * @return calculates the row sum for every row and returns each of the values in an array. Index i of the return array contains the sum of elements in row i.
+     */
+    public static int[] allRowSums(int[][] a) {
+
+        //array rowSums made to have same length as a
+        int[] rowSums = new int[a.length];
+
+        //for loops to compute the sum of each row
+       for(int i = 0; i < a.length; i++){
+           for(int j = 0; j< a[i].length; j++){
+               rowSums[i] += a[i][j];
+           }
+       }
+        return rowSums;
+
+    }
+    }
+

src/test/java/edu/sdccd/cisc191/ArrayLabTest.java

@@ -0,0 +1,80 @@
+package edu.sdccd.cisc191;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public class ArrayLabTest {
+
+    // example arrays for testing
+    private int[][] basic, allneg, nonsquare;
+
+    /**
+     * Sets up the test fixture with some arrays to test.
+     * This method is called before every test case method.
+     */
+    @BeforeAll
+    public void setUp() {
+        basic = new int[][] { {1,2,3}, {4,5,6}, {7,8,9} };
+        allneg = new int[][] { {-10,-12,-3}, {-4,-5,-6,-8}, {-7,-8} }; //all neg and ragged
+        nonsquare = new int[][] { {1,2,3}, {4,5}, {6,7,8,9} };
+    }
+
+    /**
+     * Test max is found correctly (last element in the search)
+     */
+    @Test
+    public void testMaxNormal() {
+        assertEquals(9,ArrayLab.max(basic));
+    }
+
+    /**
+     * Test max correct when all vals are negative
+     */
+    @Test public void testMaxAllNeg() {
+        assertEquals(-3,ArrayLab.max(allneg));
+    }
+
+    /**
+     * Test row sum calculated correctly including for nonsquare arrays
+     */
+    @Test public void testRowSum() {
+        assertEquals(6, ArrayLab.rowSum(basic, 0));
+        assertEquals(15, ArrayLab.rowSum(basic, 1));
+        assertEquals(24, ArrayLab.rowSum(basic, 2));
+        assertEquals(30, ArrayLab.rowSum(nonsquare, 2));
+    }
+
+    /**
+     * Test column sum calculated correctly for standard cases
+     */
+    @Test public void testColumnSum() {
+        assertEquals(12, ArrayLab.columnSum(basic, 0));
+        assertEquals(15, ArrayLab.columnSum(basic, 1));
+        assertEquals(18, ArrayLab.columnSum(basic, 2));
+    }
+
+
+    /**
+     * Test column sum calculated correctly for nonsquare arrays
+     * This checks for sum of incomplete columns (from ragged arrays)
+     */
+    @Test public void testColumnSumRagged() {
+        assertEquals(11, ArrayLab.columnSum(nonsquare, 2));
+        assertEquals(9, ArrayLab.columnSum(nonsquare, 3));
+    }
+
+    /**
+     * Checks array of row sums correctly calculated
+     */
+    @Test public void testAllRowSums() {
+        int[] expected = new int[] {6,15,24};
+        int[] actual = ArrayLab.allRowSums(basic);
+        assertArrayEquals(expected, actual);
+    }
+
+}