Kickstart 2021 - Round A

GoodnessString.java

import java.util.Scanner;

public class GoodnessString {
    public static void main(String[] args) {
        var scanner = new Scanner(System.in);

        var test_cases = scanner.nextInt();

        for (int i = 0; i < test_cases; i++) {
            var string_length = scanner.nextInt();
            var target_goodness_score = scanner.nextInt();
            var string = scanner.next();
            var min_operations = solve(string_length, target_goodness_score, string);

            System.out.println("Case #" + (i + 1) + ": " + min_operations);
        }

        scanner.close();
    }

    public static int solve(int length, int target_goodness_score, String string) {
        var chars = string.toCharArray();
        var actual_goodness_score = 0;

        for (int i = 0; i < length / 2; i++) {
            if (chars[i] != chars[length - 1 - i]) {
                actual_goodness_score++;
            }
        }

        return Math.abs(target_goodness_score - actual_goodness_score);
    }
}

LShapedPlots.java

import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.Scanner;

public class LShapedPlots {
    int[] tiles;
    int rows, columns;

    public LShapedPlots(int rows, int columns) {
        this.tiles = new int[rows * columns];
        this.rows = rows;
        this.columns = columns;
    }

    public static void main(String[] args) {
        var scanner = new Scanner(System.in);

        var test_cases = scanner.nextInt();

        for (int i = 0; i < test_cases; i++) {
            var r = scanner.nextInt();
            var c = scanner.nextInt();
            var obj = new LShapedPlots(r, c);
            obj.fill(scanner);
//            obj.printTiles();
            System.out.println("Case #" + (i + 1) + ": " + obj.solve());
        }

        scanner.close();
    }

    public void fill(Scanner scanner) {
        for (int j = 0; j < rows; j++) {
            for (int k = 0; k < columns; k++) {
                tiles[(j * columns) + k] = (char) scanner.nextInt();
            }
        }
    }

    private int getLocation(int x, int y) {
        if (x < columns && x >= 0 && y < rows && y >= 0) {
            return tiles[(y * columns) + x];
        } else {
            return -1;
        }
    }

    public void printTiles() {
        System.out.println("-------");
        System.out.println(columns + " x " + rows);
        System.out.println("-------");

        for (int j = 0; j < rows; j++) {
            for (int k = 0; k < columns; k++) {
                System.out.print(tiles[(j * columns) + k] + " ");
            }
            System.out.println();
        }

        System.out.println("-------");
    }

    public int solve() {

        var Ls = 0;

        var corners = findCorners();

        for (Point2D corner : corners) {
            Ls += cornerCheck(corner);
        }

        return Ls;
    }

    private ArrayList<Point2D> findCorners() {
        ArrayList<Point2D> corners = new ArrayList<>();

        for (int y = 0; y < rows; y++) {
            for (int x = 0; x < columns; x++) {
                if (getLocation(x, y) == 1) {
                    var x_line = getLocation(x - 1, y) == 1 || getLocation(x + 1, y) == 1;
                    var y_line = getLocation(x, y - 1) == 1 || getLocation(x, y + 1) == 1;

                    if (x_line && y_line) {
                        corners.add(new Point2D.Float(x, y));
                    }
                }
            }
        }

        return corners;
    }

    private int cornerCheck(Point2D corner) {
        var count = 0;

        var length_left = findLeftLength(corner);
        var length_right = findRightLength(corner);
        var length_up = findUpLength(corner);
        var length_down = findDownLength(corner);

        var Ls = new int[4];
        Ls[0] = containsNLs(length_left, length_up);
        Ls[1] = containsNLs(length_left, length_down);
        Ls[2] = containsNLs(length_right, length_down);
        Ls[3] = containsNLs(length_right, length_up);

        for (int num_ls : Ls) {
//            System.out.print(num_ls + ", ");
            count += num_ls;
        }

        return count;
    }

    private int containsNLs(int length_a, int length_b) {
        var ls = 0;

        int i = length_a;
        do {
            int j = length_b;
            do {
                if (is_l(i, j)) {
                    ls++;
                }
                j--;
            } while (j >= 2);

            i--;
        } while (i >= 2);

        return ls;
    }

    private boolean is_l(int length_a, int length_b) {
        var greater = Math.max(length_a, length_b);
        var lesser = Math.min(length_a, length_b);

        return greater % 2 == 0 && lesser == (greater / 2) && lesser > 1;
    }

    private int findLeftLength(Point2D starting_point) {
        int length = 0;

        for (int i = (int) starting_point.getX(); i >= 0; i--) {
            if (getLocation(i, (int) starting_point.getY()) == 0) {
                return length;
            }
            length++;
        }

        return length;
    }

    private int findRightLength(Point2D starting_point) {
        int length = 0;

        for (int i = (int) starting_point.getX(); i < columns; i++) {
            if (getLocation(i, (int) starting_point.getY()) == 0) {
                return length;
            }
            length++;
        }

        return length;
    }

    private int findUpLength(Point2D starting_point) {
        int length = 0;

        for (int i = (int) starting_point.getY(); i >= 0; i--) {
            if (getLocation((int) starting_point.getX(), i) == 0) {
                return length;
            }
            length++;
        }

        return length;
    }

    private int findDownLength(Point2D starting_point) {
        int length = 0;

        for (int i = (int) starting_point.getY(); i < rows; i++) {
            if (getLocation((int) starting_point.getX(), i) == 0) {
                return length;
            }
            length++;
        }

        return length;
    }
}

I figured out the answer to LShapedPlots after the competition was over. Unfortuenly, it doesn't pass the time requirements on the second test.

Here's the link to my submissions in the competition.
https://codingcompetitions.withgoogle.com/kickstart/submissions/0000000000436140/cXVpbm56aXBzZQ