fix merge conflict

Author: varada610

src/main/java/com/thealgorithms/maths/GoldbachConjecture.java

@@ -1,6 +1,6 @@
 package com.thealgorithms.maths;
 
-import static com.thealgorithms.maths.PrimeCheck.isPrime;
+import static com.thealgorithms.maths.Prime.PrimeCheck.isPrime;
 
 /**
  * This is a representation of the unsolved problem of Goldbach's Projection, according to which every

src/main/java/com/thealgorithms/matrix/MirrorOfMatrix.java

@@ -1,12 +1,9 @@
 package com.thealgorithms.matrix;
 
 // Problem Statement
-<<<<<<< HEAD
 
 import com.thealgorithms.matrix.utils.MatrixUtil;
 
-=======
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
 /*
 We have given an array of m x n (where m is the number of rows and n is the number of columns).
 Print the new matrix in such a way that the new matrix is the mirror image of the original matrix.
@@ -23,56 +20,17 @@ public final class MirrorOfMatrix {
     private MirrorOfMatrix() {
     }
 
-<<<<<<< HEAD
     public static double[][] mirrorMatrix(final double[][] originalMatrix) {       
         MatrixUtil.validateInputMatrix(originalMatrix);
-=======
-    public static int[][] mirrorMatrix(final int[][] originalMatrix) {
-        if (originalMatrix == null) {
-            // Handle invalid input
-            return null;
-        }
-        if (originalMatrix.length == 0) {
-            return new int[0][0];
-        }
-
-        checkInput(originalMatrix);
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
 
         int numRows = originalMatrix.length;
         int numCols = originalMatrix[0].length;
 
-<<<<<<< HEAD
         double[][] mirroredMatrix = new double[numRows][numCols];
 
         for (int i = 0; i < numRows; i++) {
             mirroredMatrix[i] = MatrixUtil.reverseRow(originalMatrix[i]);
         }
         return mirroredMatrix;
     }  
-=======
-        int[][] mirroredMatrix = new int[numRows][numCols];
-
-        for (int i = 0; i < numRows; i++) {
-            mirroredMatrix[i] = reverseRow(originalMatrix[i]);
-        }
-        return mirroredMatrix;
-    }
-    private static int[] reverseRow(final int[] inRow) {
-        int[] res = new int[inRow.length];
-        for (int i = 0; i < inRow.length; ++i) {
-            res[i] = inRow[inRow.length - 1 - i];
-        }
-        return res;
-    }
-
-    private static void checkInput(final int[][] matrix) {
-        // Check if all rows have the same number of columns
-        for (int i = 1; i < matrix.length; i++) {
-            if (matrix[i].length != matrix[0].length) {
-                throw new IllegalArgumentException("The input is not a matrix.");
-            }
-        }
-    }
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
 }

src/main/java/com/thealgorithms/matrix/matrixexponentiation/Fibonacci.java

@@ -1,15 +1,10 @@
 package com.thealgorithms.matrix.matrixexponentiation;
 
-<<<<<<< HEAD
 import java.math.BigDecimal;
 import java.util.Scanner;
 
 import com.thealgorithms.matrix.utils.MatrixUtil;
 
-=======
-import java.util.Scanner;
-
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
 /**
  * @author Anirudh Buvanesh (https://github.com/anirudhb11) For more information
  * see https://www.geeksforgeeks.org/matrix-exponentiation/
@@ -20,49 +15,13 @@ private Fibonacci() {
     }
 
     // Exponentiation matrix for Fibonacci sequence
-<<<<<<< HEAD
     private static final BigDecimal ONE = BigDecimal.valueOf(1);
     private static final BigDecimal ZERO = BigDecimal.valueOf(0);
 
     private static final BigDecimal[][] FIB_MATRIX = {{ONE, ONE}, {ONE, ZERO}};
     private static final BigDecimal[][] IDENTITY_MATRIX = {{ONE, ZERO}, {ZERO, ONE}};
     // First 2 fibonacci numbers
     private static final BigDecimal[][] BASE_FIB_NUMBERS = {{ONE}, {ZERO}};
-=======
-    private static final int[][] FIB_MATRIX = {{1, 1}, {1, 0}};
-    private static final int[][] IDENTITY_MATRIX = {{1, 0}, {0, 1}};
-    // First 2 fibonacci numbers
-    private static final int[][] BASE_FIB_NUMBERS = {{1}, {0}};
-
-    /**
-     * Performs multiplication of 2 matrices
-     *
-     * @param matrix1
-     * @param matrix2
-     * @return The product of matrix1 and matrix2
-     */
-    private static int[][] matrixMultiplication(int[][] matrix1, int[][] matrix2) {
-        // Check if matrices passed can be multiplied
-        int rowsInMatrix1 = matrix1.length;
-        int columnsInMatrix1 = matrix1[0].length;
-
-        int rowsInMatrix2 = matrix2.length;
-        int columnsInMatrix2 = matrix2[0].length;
-
-        assert columnsInMatrix1 == rowsInMatrix2;
-        int[][] product = new int[rowsInMatrix1][columnsInMatrix2];
-        for (int rowIndex = 0; rowIndex < rowsInMatrix1; rowIndex++) {
-            for (int colIndex = 0; colIndex < columnsInMatrix2; colIndex++) {
-                int matrixEntry = 0;
-                for (int intermediateIndex = 0; intermediateIndex < columnsInMatrix1; intermediateIndex++) {
-                    matrixEntry += matrix1[rowIndex][intermediateIndex] * matrix2[intermediateIndex][colIndex];
-                }
-                product[rowIndex][colIndex] = matrixEntry;
-            }
-        }
-        return product;
-    }
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
 
     /**
      * Calculates the fibonacci number using matrix exponentiaition technique
@@ -71,7 +30,6 @@ private static int[][] matrixMultiplication(int[][] matrix1, int[][] matrix2) {
      * Outputs the nth * fibonacci number
      * @return a 2 X 1 array as { {F_n+1}, {F_n} }
      */
-<<<<<<< HEAD
     public static BigDecimal[][] fib(int n) {
         if (n == 0) {
             return IDENTITY_MATRIX;
@@ -82,18 +40,6 @@ public static BigDecimal[][] fib(int n) {
                 return matrixExpResult;
             } else {
                 return MatrixUtil.multiply(FIB_MATRIX, matrixExpResult).get();
-=======
-    public static int[][] fib(int n) {
-        if (n == 0) {
-            return IDENTITY_MATRIX;
-        } else {
-            int[][] cachedResult = fib(n / 2);
-            int[][] matrixExpResult = matrixMultiplication(cachedResult, cachedResult);
-            if (n % 2 == 0) {
-                return matrixExpResult;
-            } else {
-                return matrixMultiplication(FIB_MATRIX, matrixExpResult);
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
             }
         }
     }
@@ -102,12 +48,7 @@ public static void main(String[] args) {
         // Returns [0, 1, 1, 2, 3, 5 ..] for n = [0, 1, 2, 3, 4, 5.. ]
         Scanner sc = new Scanner(System.in);
         int n = sc.nextInt();
-<<<<<<< HEAD
         BigDecimal[][] result = MatrixUtil.multiply(fib(n), BASE_FIB_NUMBERS).get();
-=======
-        int[][] result = matrixMultiplication(fib(n), BASE_FIB_NUMBERS);
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
-        System.out.println("Fib(" + n + ") = " + result[1][0]);
         sc.close();
     }
 }

src/test/java/com/thealgorithms/matrix/MirrorOfMatrixTest.java

@@ -1,92 +1,51 @@
 package com.thealgorithms.matrix;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
-<<<<<<< HEAD
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-=======
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
 import org.junit.jupiter.api.Test;
 
 class MirrorOfMatrixTest {
 
     @Test
     void testMirrorMatrixRegularMatrix() {
-<<<<<<< HEAD
         double[][] originalMatrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
         double[][] expectedMirrorMatrix = {{3, 2, 1}, {6, 5, 4}, {9, 8, 7}};
         double[][] mirroredMatrix = MirrorOfMatrix.mirrorMatrix(originalMatrix);
-=======
-        int[][] originalMatrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
-        int[][] expectedMirrorMatrix = {{3, 2, 1}, {6, 5, 4}, {9, 8, 7}};
-        int[][] mirroredMatrix = MirrorOfMatrix.mirrorMatrix(originalMatrix);
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
         assertArrayEquals(expectedMirrorMatrix, mirroredMatrix);
     }
 
     @Test
     void testMirrorMatrixEmptyMatrix() {
-<<<<<<< HEAD
         double[][] originalMatrix = {};
         Exception e = assertThrows(IllegalArgumentException.class, () -> MirrorOfMatrix.mirrorMatrix(originalMatrix));
         assertEquals("The input matrix cannot be empty", e.getMessage());
-=======
-        int[][] originalMatrix = {};
-        int[][] expectedMirrorMatrix = {};
-        int[][] mirroredMatrix = MirrorOfMatrix.mirrorMatrix(originalMatrix);
-        assertArrayEquals(expectedMirrorMatrix, mirroredMatrix);
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
     }
 
     @Test
     void testMirrorMatrixSingleElementMatrix() {
-<<<<<<< HEAD
         double[][] originalMatrix = {{42}};
         double[][] expectedMirrorMatrix = {{42}};
         double[][] mirroredMatrix = MirrorOfMatrix.mirrorMatrix(originalMatrix);
-=======
-        int[][] originalMatrix = {{42}};
-        int[][] expectedMirrorMatrix = {{42}};
-        int[][] mirroredMatrix = MirrorOfMatrix.mirrorMatrix(originalMatrix);
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
         assertArrayEquals(expectedMirrorMatrix, mirroredMatrix);
     }
 
     @Test
     void testMirrorMatrixMultipleRowsOneColumnMatrix() {
-<<<<<<< HEAD
         double[][] originalMatrix = {{1}, {2}, {3}, {4}};
         double[][] expectedMirrorMatrix = {{1}, {2}, {3}, {4}};
         double[][] mirroredMatrix = MirrorOfMatrix.mirrorMatrix(originalMatrix);
-=======
-        int[][] originalMatrix = {{1}, {2}, {3}, {4}};
-        int[][] expectedMirrorMatrix = {{1}, {2}, {3}, {4}};
-        int[][] mirroredMatrix = MirrorOfMatrix.mirrorMatrix(originalMatrix);
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
         assertArrayEquals(expectedMirrorMatrix, mirroredMatrix);
     }
 
     @Test
     void testMirrorMatrixNullInput() {
-<<<<<<< HEAD
         double[][] originalMatrix = null;
         Exception e = assertThrows(IllegalArgumentException.class, () -> MirrorOfMatrix.mirrorMatrix(originalMatrix));
         assertEquals("The input matrix cannot be null", e.getMessage());    }
 
     @Test
     void testMirrorMatrixThrows() {
         assertThrows(IllegalArgumentException.class, () -> MirrorOfMatrix.mirrorMatrix(new double[][] {{1}, {2, 3}}));
-=======
-        int[][] originalMatrix = null;
-        assertNull(MirrorOfMatrix.mirrorMatrix(originalMatrix));
-    }
-
-    @Test
-    void testMirrotMarixThrows() {
-        assertThrows(IllegalArgumentException.class, () -> MirrorOfMatrix.mirrorMatrix(new int[][] {{1}, {2, 3}}));
->>>>>>> 754bf6c5f8f55b758bdee2667f6cadf4f0ab659f
     }
 }