added Score After Flipping Matrix (Medium)

Author: minhyeong-joe

Medium/ScoreAfterFlippingMatrix/Driver.java

@@ -0,0 +1,9 @@
+package Medium.ScoreAfterFlippingMatrix;
+
+public class Driver {
+ public static void main(String[] args) {
+ Solution sol = new Solution();
+ int[][] input = { { 0, 0, 1, 1 }, { 1, 0, 1, 0 }, { 1, 1, 0, 0 } };
+ System.out.println(sol.matrixScore(input));
+ }
+}

Medium/ScoreAfterFlippingMatrix/README.md

@@ -0,0 +1,29 @@
+# Score After Flipping Matrix
+
+[Leetcode Link](https://leetcode.com/problems/score-after-flipping-matrix/)
+
+## Problem:
+
+We have a two dimensional matrix `A` where each value is `0` or `1`.
+
+A move consists of choosing any row or column, and toggling each value in that row or column: changing all `0`s to `1`s, and all `1`s to `0`s.
+
+After making any number of moves, every row of this matrix is interpreted as a binary number, and the score of the matrix is the sum of these numbers.
+
+Return the highest possible score.
+
+## Example:
+
+```
+Input: [[0,0,1,1],[1,0,1,0],[1,1,0,0]]
+Output: 39
+Explanation:
+Toggled to [[1,1,1,1],[1,0,0,1],[1,1,1,1]].
+0b1111 + 0b1001 + 0b1111 = 15 + 9 + 15 = 39
+```
+
+## Note:
+
+- 1 <= A.length <= 20
+- 1 <= A[0].length <= 20
+- A[i][j] is 0 or 1.

Medium/ScoreAfterFlippingMatrix/Solution.java

@@ -0,0 +1,64 @@
+package Medium.ScoreAfterFlippingMatrix;
+
+import java.util.Arrays;
+
+public class Solution {
+ public int matrixScore(int[][] A) {
+ int rowLength = A.length;
+ int colLength = A[0].length;
+ int sum = 0;
+ // 1. flip to higher value per row (highest value is binary that begins with
+ // '1')
+ for (int[] row : A) {
+ if (row[0] == 0) {
+ flipRow(row);
+ }
+ }
+ System.out.println("After row flipping: " + Arrays.deepToString(A));
+ // 2. check by columns, flip to max the number of 1's
+ // basically, if there are more zeros in the column, flip to make more 1's, if
+ // equal number of zeros and ones, then no effect at all (as bit-wise, it's like
+ // subtract 4 and add 4)
+ for (int j = 0; j < colLength; j++) {
+ int numZero = 0;
+ for (int[] row : A) {
+ if (row[j] == 0)
+ numZero++;
+ }
+ if (numZero > rowLength / 2) {
+ flipCol(A, j);
+ }
+ }
+ System.out.println("After col flipping: " + Arrays.deepToString(A));
+ // 3. Lastly convert final array into binary and return sum
+ for (int[] row : A) {
+ sum += binaryArray(row);
+ }
+ return sum;
+ }
+
+ // helper function to flip row
+ private void flipRow(int[] row) {
+ for (int i = 0; i < row.length; i++) {
+ row[i] = row[i] == 0 ? 1 : 0;
+ }
+ }
+
+ // helper function to flip col
+ private void flipCol(int[][] A, int colIndex) {
+ for (int[] row : A) {
+ row[colIndex] = row[colIndex] == 0 ? 1 : 0;
+ }
+ }
+
+ // helper function to convert 1-d array to binary then to a decimal number
+ private int binaryArray(int[] arr) {
+ int decimal = 0;
+ int power = 0;
+ for (int i = arr.length - 1; i >= 0; i--) {
+ decimal += arr[i] * Math.pow(2, power);
+ power++;
+ }
+ return decimal;
+ }
+}

README.md

@@ -82,6 +82,7 @@ Languages used: Java and Python
  - [Count Square Submatrices with All Ones](Medium/CountSquareWithOnes)
  - [Divide Array is Sets of K Consecutive Numbers](Medium/DivideArrayInKConsecNums)
  - [Perfect Squares](Medium/PerfectSquares)
+ - [Score After Flipping Matrix](Medium/ScoreAfterFlippingMatrix)
 - Hard
  - [Maximum Score Words Formed by Letters](Hard/MaximumScoreWords)
  - [Reducing Dishes](Hard/ReducingDishes)