https://kotlinlang.org logo
Channels
Powered by
#getting-started
Title
# getting-started
o

oday

02/01/2021, 2:39 PM
how can I translate this to Kotlin?
Copy code
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
Copy code
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
    )
}
r

Ruckus

02/01/2021, 3:53 PM
Looks reasonable to me. If you really wanted you could shrink it down to something like:
Copy code
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)
o

oday

02/01/2021, 3:53 PM
issue is what to feed isValidBST
I want negative infinity and positive infinity with the current way that the code looks
r

Ruckus

02/01/2021, 3:55 PM
You don't need +/- infinity. An int can never be outside the range of MIN_VALUE..MAX_VALUE, so that is effectively infinite bounds.
The only issue is the fact that MIN_VALUE will never be valid, so you may need to change the logic a bit.
o

oday

02/01/2021, 3:55 PM
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
so something is off
r

Ruckus

02/01/2021, 3:57 PM
Maybe something like
Copy code
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)
o

oday

02/01/2021, 4:02 PM
can’t we use an operator that is exclusive?
instead of the +1 and -1 ?
dont get that part
r

Ruckus

02/01/2021, 4:05 PM
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.
If you want to use floating point values, it would be as simple as changing the line in your original code to
Copy code
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.
(You could of course use `Float`s as well.)
o

oday

02/01/2021, 4:45 PM
think I broke it
Copy code
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()
    }
}
this works on Leetcode
i insisted on having it as an extension lol
4 Views
Powered by