6. Z 字形变换
将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。
比如输入字符串为 "LEETCODEISHIRING" 行数为 3 时，排列如下：
L C I R
E T O E S I I G
E D H N
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："LCIRETOESIIGEDHN"。
请你实现这个将字符串进行指定行数变换的函数：
string convert(string s, int numRows);
示例 1:
输入: s = "LEETCODEISHIRING", numRows = 3
输出: "LCIRETOESIIGEDHN"
示例 2:
输入: s = "LEETCODEISHIRING", numRows = 4
输出: "LDREOEIIECIHNTSG"
解释:
L D R
E O E I I
E C I H N
T S G
- 解题
fun _0006_convert() {
println("--------_006_convert-------")
println(convert("LEETCODEISHIRING", 3))
println(convert("LEETCODEISHIRING", 4))
}
fun convert(s: String, numRows: Int): String {
var convert = ""
val len = s.length
if (numRows <= 1) return s
val door = 2 * numRows - 2
for (i in 0 until numRows) {
for (j in i until len step door) {
val k = j + door - 2 * i
convert += s[j]
if (i != 0 && i != numRows - 1 && k < len) {
convert += s[k]
}
}
}
return convert
}
7. 整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
- 解题
fun _0007_reverse() {
println("--------_007_reverse-------")
println(reverse(123))
println(reverse(-123))
println(reverse(120))
println(reverse(980))
println(reverse(Int.MAX_VALUE))
println(reverse(Int.MIN_VALUE))
println(Math.pow(2.0, 31.0))
println(Int.MIN_VALUE)
}
fun reverse(x: Int): Int {
var x = x
var res: Int = 0
while (x != 0) {
if (abs(res) > Int.MAX_VALUE / 10) return 0
res = res * 10 + x % 10
x /= 10
}
return res
}
8. 字符串转换整数 (atoi)
请你来实现一个 atoi 函数，使其能将字符串转换成整数。 首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。接下来的转化规则如下： 如果第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字字符组合起来，形成一个有符号整数。 假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成一个整数。 该字符串在有效的整数部分之后也可能会存在多余的字符，那么这些字符可以被忽略，它们对函数不应该造成影响。 注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换，即无法进行有效转换。 在任何情况下，若函数不能进行有效的转换时，请返回 0 。
提示：
本题中的空白字符只包括空格字符 ' ' 。
假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231, 231 − 1]。如果数值超过这个范围，请返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。
示例 1:
输入: "42"
输出: 42
示例 2:
输入: " -42"
输出: -42
解释: 第一个非空白字符为 '-', 它是一个负号。
我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。
示例 3:
输入: "4193 with words"
输出: 4193
解释: 转换截止于数字 '3' ，因为它的下一个字符不为数字。
示例 4:
输入: "words and 987"
输出: 0
解释: 第一个非空字符是 'w', 但它不是数字或正、负号。
因此无法执行有效的转换。
示例 5:
输入: "-91283472332"
输出: -2147483648
解释: 数字 "-91283472332" 超过 32 位有符号整数范围。
因此返回 INT_MIN (−231) 。
- 解题
fun _0008_myAtoi() {
println("--------_008_myAtoi-------")
println(myAtoi("42"))
println(myAtoi(" -42"))
println(myAtoi("4193 with words"))
println(myAtoi("words and 987"))
println(myAtoi("-91283472332"))
}
fun myAtoi(s: String): Int {
if (s.isEmpty()) return 0
var sign = 1
var base = 0
var i = 0
val n = s.length
while (i < n && s[i] == ' ') ++i
if (i < n && (s[i] == '+' || s[i] == '-')) {
sign = if (s[i++] == '+') 1 else -1
}
while (i < n && s[i] >= '0' && s[i] <= '9') {
if (base > Int.MAX_VALUE / 10 || (base == Int.MAX_VALUE / 10 && s[i] - '0' > 7)) {
return if (sign == 1) Int.MAX_VALUE else Int.MIN_VALUE
}
base = 10 * base + (s[i++] - '0')
}
return base * sign
}
9. 回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。
- 解题： 首先判断x是否为负数，这里可以用一个小 trick，因为整数的最高位不能是0，所以回文数的最低位也不能为0，数字0除外，所以如果发现某个正数的末尾是0了，也直接返回 false 即可。
下面来看具体解法，要验证回文数，那么就需要看前后半段是否对称，如果把后半段翻转一下，就看和前半段是否相等就行了。所以做法就是取出后半段数字，进行翻转，具体做法是，每次通过对 10 取余，取出最低位的数字，然后加到取出数的末尾，就是将 revertNum 乘以 10，再加上这个余数，这样翻转也就同时完成了，每取一个最低位数字，x都要自除以 10。这样当 revertNum 大于等于x的时候循环停止。由于回文数的位数可奇可偶，如果是偶数的话，那么 revertNum 就应该和x相等了； 如果是奇数的话，那么最中间的数字就在 revertNum 的最低位上了，除以 10 以后应该和x是相等的
fun _0009_isPalindrome() {
println("--------_009_isPalindrome-------")
println(isPalindrome(121))
println(isPalindrome(-121))
println(isPalindrome(10))
println(isPalindrome(222))
println(isPalindrome(10101))
}
fun isPalindrome(x: Int): Boolean {
if (x < 0 || (x % 10 == 0 && x != 0)) return false
var x = x
var revertNum = 0
while (x > revertNum) {
revertNum = revertNum * 10 + x % 10
x /= 10
}
return x == revertNum || x == revertNum / 10
}
10. 正则表达式匹配
给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '' 的正则表达式匹配。 '.' 匹配任意单个字符 '' 匹配零个或多个前面的那一个元素 所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。
示例 1：
输入：s = "aa" p = "a"
输出：false
解释："a" 无法匹配 "aa" 整个字符串。
示例 2:
输入：s = "aa" p = "a*"
输出：true
解释：因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
示例 3：
输入：s = "ab" p = ".*"
输出：true
解释：".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
示例 4：
输入：s = "aab" p = "c*a*b"
输出：true
解释：因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
示例 5：
输入：s = "mississippi" p = "mis*is*p*."
输出：false
提示：
0 <= s.length <= 20
0 <= p.length <= 30
s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。
保证每次出现字符 * 时，前面都匹配到有效的字符
- 解题 先来判断p是否为空，若为空则根据s的为空的情况返回结果。 当p的第二个字符为号时，由于号前面的字符的个数可以任意，可以为0，那么我们先用递归来调用为0的情况，就是直接把这两个字符去掉再比较，或者当s不为空，且第一个字符和p的第一个字符相同时，再对去掉首字符的s和p调用递归，注意p不能去掉首字符，因为号前面的字符可以有无限个；如果第二个字符不为号，那么就老老实实的比较第一个字符，然后对后面的字符串调用递归
fun _0010_isMatch() {
println("--------_010_isMatch-------")
println(isMatch("aa", "a"))
println(isMatch("aa", "a*"))
println(isMatch("ab", ".*"))
println(isMatch("aab", "c*a*b"))
println(isMatch("mississippi", "mis*is*p*."))
}
fun isMatch(s: String, p: String): Boolean {
if (p.isEmpty()) return s.isEmpty()
return if (p.length > 1 && p[1] == '*') {
isMatch(s, p.substring(2)) || (s.isNotEmpty() && (s[0] == p[0] || p[0] == '.') && isMatch(s.substring(1), p))
} else {
s.isNotEmpty() && (s[0] == p[0] || p[0] == '.') && isMatch(s.substring(1), p.substring(1))
}
}
