package daily

fun main() {
    // 777. 在LR字符串中交换相邻字符
    // https://leetcode.cn/problems/swap-adjacent-in-lr-string/
    println(canTransform1("LXXLXRLXXL", "XLLXRXLXLX"))
}

fun canTransform(start: String, end: String): Boolean {
    // 满足题意的 start 和 end，需要具备以下条件
    // 1、start 和 end 长度相同
    // 2、start 和 end 中，L 的数量要一致，R 的数量也要一致，且 L 和 R 在 start 和 end 中的相对顺序要一致
    // 3、因为是一个 LX 替换一个 XL，即 L 会越换越靠前，所以 end 中的 L 下标，要小于等于 start 中的
    // 4、因为是一个 XR 替换一个 RX，即 R 会越换越考后，所以 end 中的 R 下标，要大于等于 start 中的
    if (start.length != end.length) {
        return false
    }
    var startIndex = 0
    var endIndex = 0
    while (startIndex < start.length && endIndex < end.length) {
        while (startIndex < start.length && start[startIndex] == 'X') {
            // 跳过 x
            startIndex++
        }
        while (endIndex < end.length && end[endIndex] == 'X') {
            // 跳过 x
            endIndex++
        }
        if (startIndex < start.length && endIndex < end.length) {
            if (start[startIndex] != end[endIndex]) {
                // 相对顺序不一致，一个出现了 L，一个出现了 R
                return false
            }
            if (start[startIndex] == 'L' && end[endIndex] == 'L') {
                // end 的 L 下标，要小于等于 start 的 L 下标
                if (endIndex > startIndex) {
                    // 不满足
                    return false
                }
            }
            if (start[startIndex] == 'R' && end[endIndex] == 'R') {
                // end 的 R 的下标，要大于等于 start 的 R 的下标
                if (endIndex < startIndex) {
                    // 不满足
                    return false
                }
            }
            startIndex++
            endIndex++
        }
    }
    // startIndex 或者 endIndex 走到最后了
    while (startIndex < start.length) {
        // endIndex 走到最后了，start 剩下的应该都是 X
        if (start[startIndex++] != 'X') {
            return false
        }
    }
    while (endIndex < end.length) {
        // startIndex 走到最后了，end 剩下的应该都是 X
        if (end[endIndex++] != 'X') {
            return false
        }
    }
    return true
}

fun canTransform1(start: String, end: String): Boolean {
    if (start.length != end.length) {
        return false
    }
    var startIndex = 0
    var endIndex = 0
    while (startIndex < start.length && endIndex < end.length) {
        // 跳过 X
        while (startIndex < start.length && start[startIndex] == 'X') {
            startIndex++
        }
        while (endIndex < end.length && end[endIndex] == 'X') {
            endIndex++
        }
        if (startIndex < start.length && endIndex < end.length) {
            if (start[startIndex] != end[endIndex]) {
                // 一个是 L，一个是 R
                // 跳过 X 后，start 和 end 中，L R 出现的相对顺序不一致
                return false
            }
            // start[startIndex] == end[endIndex]，都是 L，或者都是 R
            // 判断下标
            if (start[startIndex] == 'L') {
                // start 中 L 的下标要大于等于 end 中 L 的下标
                if (startIndex < endIndex) {
                    return false
                }
            }else if (start[startIndex] == 'R') {
                // start 中 L 的下标要小于等于 end 中 R 的下标
                if (startIndex > endIndex) {
                    return false
                }
            }
            startIndex++
            endIndex++
        }
    }
    // start 或者 end 其中一个先遍历到终点
    // start 先遍历到终点
    if (startIndex == start.length) {
        // 那么剩下的 end 中，只能都是 X
        while (endIndex < end.length) {
            if (end[endIndex] != 'X') {
                return false
            }
            endIndex++
        }
    }
    // end 先遍历到终点
    if (endIndex == end.length) {
        // 那么剩下的 start 中，只能都是 X
        while (startIndex < start.length) {
            if (start[startIndex] != 'X') {
                return false
            }
            startIndex++
        }
    }
    return true
}