LeetCode Utils

LeetcodeUtils.kt

fun String.toArrayOfIntArray(): Array<IntArray> = split("],[")
    .map { it.split(",").map { it.filter { it.isDigit() }.toInt() } }
    .map { it.toIntArray() }
    .toTypedArray()

fun String.toArrayOfCharArray(): Array<CharArray> = split("],[")
    .map { it.split(",").map { it.filter { it.isLetterOrDigit() }[0] } }
    .map { it.toCharArray() }
    .toTypedArray()

fun String.toArrayOfString(): Array<String> = split(",")
    .map { it.filter { it.isLetterOrDigit() } }
    .toTypedArray()

fun String.toIntArray(): IntArray = split(",")
    .mapNotNull { it.filter { it.isDigit() || it == '-' }.toIntOrNull() }
    .toIntArray()

fun String.toListNode(): ListNode? {
    val list = split(",").map { it.filter { it.isDigit() }.toInt() }
    val nodes = list.firstOrNull()?.let { ListNode(it) }
    var cur = nodes
    (1 until list.size).forEach { i ->
        cur?.next = ListNode(list[i])
        cur = cur?.next
    }
    return nodes
}

fun String.toTreeNode(): TreeNode? {
    val list = split(",").map { it.filter { it.isDigit() }.toIntOrNull() }
    val nodes = list.map { if (it != null) TreeNode(it) else null }
    nodes.drop(1).forEachIndexed { index, node ->
        if (node != null) {
            val oldNode = nodes[index / 2]
            if (index % 2 == 0) {
                oldNode!!.left = node
            } else {
                oldNode!!.right = node
            }
        }
    }
    return nodes.firstOrNull()
}

inline fun <reified T> String.parse(): T {
    return when (T::class) {
        String::class -> this
        Int::class -> toInt()
        Long::class -> toLong()
        Array<IntArray>::class -> toArrayOfIntArray()
        Array<CharArray>::class -> toArrayOfCharArray()
        Array<String>::class -> toArrayOfString()
        IntArray::class -> toIntArray()
        ListNode::class -> toListNode()
        TreeNode::class -> toTreeNode()
        else -> error("Unknown type ${T::class}")
    } as T
}

fun printlnReadable(any: Any?) {
    println("S: ${makePrintable(any)}")
}

fun makePrintable(any: Any?): Any? {
    return when (any) {
        is List<*> -> any.map { makePrintable(it) }
        is Array<*> -> makePrintable(any.toList())
        is IntArray -> makePrintable(any.toList())
        is CharArray -> makePrintable(any.toList())
        is LongArray -> makePrintable(any.toList())
        is FloatArray -> makePrintable(any.toList())
        is DoubleArray -> makePrintable(any.toList())
        else -> any
    }
}

class ListNode(var `val`: Int) {
    var next: ListNode? = null
}

class TreeNode(var `val`: Int) {
    var left: TreeNode? = null
    var right: TreeNode? = null
}