Difference between sums of two diagonals of a square matrix

Antony — Mon, 18 May 2020 07:54:13 +0000

Given a square matrix, calculate the absolute difference between the sums of its diagonals.

The most efficient way is to approach this is to implement a solution running linearly achieving the 0(n).

We will create a method sumOfDiagonals which takes in a parameter arr: Array<IntArray>. This allows us to create a 2D array. Create variables leftToRight, rightToLeft which will be equal to 0 representing the diagonal lines. Variable rows equal to the size of the array arr.size and columns equal to the size of the positions arr[0].size.

Create the counters for the positions and assert them to 0. var i = 0, var j = 0, var k = 0, var l = arr.size - 1 this a right to left column counter.

Create a while loop that checks the rows and column counters and if the value is satisfied it should increment the counters and add the leftToRight, rightToLeft values together.

To make it work return the absolute difference return Math.abs(leftToRight - rightToLeft).

Easy Peasy, Lemon Squeezy 😄 😄.

Let's look at the code

fun sumOfDiagonals(arr: Array<IntArray>): Int {

    var leftToRight = 0
    var rightToLeft = 0
    val rows = arr.size
    val columns = arr[0].size

    var i = 0
    var j = 0
    var k = 0
    var l = arr.size - 1 //right to left column counter

    while (rows >= 0 && columns >= 0 && rows >= 0 && l >= 0) {

        leftToRight += arr[i][j] //add the values at the position
        rightToLeft += arr[k][l] //add the values at the position

        i += 1
        j += 1
        k += 1
        l -= 1

    }

    return abs(leftToRight - rightToLeft) ///return the difference

}

Github Repo

Thank you for reading, please share if you found it helpful 💯.

Asante Sana

Sum of Array the Maximum Consecutive Subarray

Antony — Thu, 12 Mar 2020 10:07:53 +0000

In the past few weeks, I have been learning a lot of algorithms and data structures. Finding Kotlin written algorithms has proven challenging. So let us fix that by with writing our own. if you can't beat them, look for a way to beat them 😅.

The problem.

Given an array of integers, find the maximum possible sum you can get from one of its contiguous subarrays. The subarray from which this sum comes must contain at least 1 element.

One of the methods to solve this will be through using a nested for loop, the first will loop through all the elements and calculating the sum and saving it to a variable var max_sum. This solution would be correct although it would not be efficient as it runs at 0(n²).

There are many dynamic algorithms that can be used to make this program efficient by running linearly. In this instance, we will use the popular Kadane's Algorithm.

We will create a method ArrayMaxConsecutiveSum which takes in a parameter inputArray: IntArray. Then a variable max_sum which will be equal to the first element of the array var max_sum = inputArray[0], variable current_sum which will be equal to our maximum sum, var current_sum = max_sum, a for loop, given the size of the array we will make the current_sum equal to the result of the element input position of the array plus the current_sumcompared to the next element input position. Update the max_sum with the current_sum.

To make it work we will return the max_sum.

Now that wasn't hard 😄 😄.