how can I translate this to Kotlin? ```class Solu...

# getting-started

[oday]

how can I translate this to Kotlin?

class Solution(object):
  def _isValidBSTHelper(self, n, low, high):
    if not n:
      return True
    val = n.val
    if ((val > low and val < high) and
        self._isValidBSTHelper(n.left, low, n.val) and
        self._isValidBSTHelper(n.right, n.val, high)):
        return True
    return False

  def isValidBST(self, n):
    return self._isValidBSTHelper(n, float('-inf'), float('inf'))

my attempt produced this

fun isValidChecker(
    node: Node<Int>?, low: Int, high: Int
): Boolean {
    if (node == null)
        return true

    val value = node.value

    if (value in (low + 1) until high
        && isValidChecker(node.left, low, value)
        && isValidChecker(node.right, value, high)
    )
        return true

    return false
}

fun isValidBST(node: Node<Int>?): Boolean {
    return isValidChecker(
        node, Int.MIN_VALUE, Int.MAX_VALUE
    )
}

[Ruckus]

Looks reasonable to me. If you really wanted you could shrink it down to something like:

fun Node<Int>?.isValidBST(
    low: Int = Int.MIN_VALUE,
    hight: Int = Int.MAX_VALUE,
): Boolean = return this == null ||
    value in (low + 1) until high &&
    left.isValidBST(low, value) &&
    right.isValidBST(value, high)

[oday]

issue is what to feed isValidBST

[oday]

I want negative infinity and positive infinity with the current way that the code looks

[Ruckus]

You don't need +/- infinity. An int can never be outside the range of MIN_VALUE..MAX_VALUE, so that is effectively infinite bounds.

[Ruckus]

The only issue is the fact that MIN_VALUE will never be valid, so you may need to change the logic a bit.

[oday]

I’m with you logically, but running the above Python variation of it makes this LeetCode question pass, running our Kotlin version fails on 7 cases

[oday]

so something is off

[oday]

https://leetcode.com/problems/validate-binary-search-tree/

[Ruckus]

Maybe something like

fun Node<Int>?.isValidBST(
    low: Int = Int.MIN_VALUE,
    hight: Int = Int.MAX_VALUE,
): Boolean = this == null ||
    value <= low &&
    value >= high &&
    left.isValidBST(low, value - 1) &&
    right.isValidBST(value + 1, high)

[oday]

can’t we use an operator that is exclusive?

[oday]

instead of the +1 and -1 ?

[oday]

dont get that part

[Ruckus]

Not if you use finite bounds. You can either use ints and modify the logic accordingly or use floating point values and keep the logic the same.

[Ruckus]

If you want to use floating point values, it would be as simple as changing the line in your original code to

val value = node.value.toDouble()

And accepting Doubles for the low / high params, using Double.NEGATIVE_INFINITY and Double.POSITIVE_INFINITY as the initial bounds.

[Ruckus]

(You could of course use `Float`s as well.)

[oday]

think I broke it

class Solution {
    fun TreeNode?.isValidBST(
        low: Double = Double.NEGATIVE_INFINITY, high: Double = Double.POSITIVE_INFINITY
    ): Boolean = this == null || 
    (`val`.toDouble() > low && `val`.toDouble() < high)
    && left.isValidBST(low, `val`.toDouble())
    && right.isValidBST(`val`.toDouble(), high)

    fun isValidBST(root: TreeNode?): Boolean {
        return root.isValidBST()
    }
}

[oday]

this works on Leetcode

[oday]

i insisted on having it as an extension lol