# Kotlin Operator inspired from Python

Since last week, I am practicing *HackerRank* problems in *Python* to learn it. While solving probelms, yesterday I found an interesting operator in Python. I still don’t know what it is called though.

In this post, we are going to see how I used Kotlin’s operator overloading feature to mimic this Python operator.

## Question: Highest Hourglass Value (2D Array - DS)

The question, I was solving can be found in the mentioned URL: https://www.hackerrank.com/challenges/2d-array/problem?h_l=interview&playlist_slugs%5B%5D=interview-preparation-kit&playlist_slugs%5B%5D=arrays

### Answer: Highest Hourglass Value

My answer to the above question was this:

```
fun hourglassSum(arr: Array<Array<Int>>): Int {
var result = -63
for (row in 0 until 4) {
for (col in 0 until 4) {
val temp = arr[row][col] +
arr[row][col + 1] +
arr[row][col + 2] +
arr[row + 1][col + 1] +
arr[row + 2][col] +
arr[row + 2][col + 1] +
arr[row + 2][col + 2]
if (temp > result) result = temp
}
}
return result
}
```

As I already said that I solve these problems to learn Python. So I tried the solution with Python too. And here is my Python equivalent code.

```
def hourglass_sum(arr):
result = -63
for row in range(4):
for col in range(4):
temp = arr[row][col] +\
arr[row][col + 1] +\
arr[row][col + 2] +\
arr[row + 1][col + 1] +\
arr[row + 2][col] +\
arr[row + 2][col + 1] +\
arr[row + 2][col + 2]
if temp > result:
result = temp
return result
```

### Improvement

After digging a bit more into variou Python syntax, I found a better way to write the above answer. Here it is:

```
def hourglass_sum(arr):
result = -63
for row in range(4):
for col in range(4):
temp = sum(arr[row][col:col + 3]) +\
arr[row + 1][col + 1] +\
sum(arr[row + 2][col:col + 3])
if temp > result:
result = temp
return result
```

### Inspiration

The above code in Python looks more readable. This inspired me to look into my Kotlin code and refactor it into something similar in readability.

#### Problem Statement

I have to find two below things:

- An operator in Kotlin, which looks similar to
`a:b`

. - An equivalent method to
`sum(\*args)`

#### Solutions

- As Kotlin has reserved
`:`

operator to be used while variable declaration`val x: Int = 0`

, I had to find some other operator as a replacement. Guess what!!! Kotlin alrady has thought about it and has given us an operator`..`

by rotating`:`

to 90°. - We already have a
`sum()`

extension function in Kotlin.

Now let’s modify our Kotlin code to make it better.

```
fun hourglassSum(arr: Array<Array<Int>>): Int {
var result = -63
for (row in 0 until 4) {
for (col in 0 until 4) {
val temp = arr[row][col..col + 2].sum() +
arr[row + 1][col + 1] +
arr[row + 2][col..col + 2].sum()
if (temp > result) result = temp
}
}
return result
}
```

The above code looks similar to our Python equivalent. but unfortunately the code doesn’t compile. []

And to solve this, we need to overload the corresponding operator we just created. Here it is,

```
operator fun <T> Array<T>.get(range: IntRange) = sliceArray(range)
```

Now the code compiles and works as expected with better readability.

## Contribution:

Please feel free to discuss if you have any further improvements on my answer. I would love to discuss about more optimized answer.