6. Z 字形变换

class Solution(object):
    def convert(self, s, numRows):
        """
        :type s: str
        :type numRows: int
        :rtype: str
        """
        if len(s) == 1 or numRows == 1:
            return s

        s_len = len(s)
        tmp_list = []
        tmp_str = ""
        last_idx = 0
        answer = ""

        for i in range(numRows):
            # last_idx = i
            for j in range(s_len):
                if i != 0 and i != numRows-1:
                    if j % 2 != 0:
                        idx = last_idx + 2 * (numRows - i - 1)
                    else:
                        idx = last_idx + 2 * i
                else:
                    idx = last_idx + 2 * (numRows - 1)

                if j == 0:
                    idx = i

                if (idx >= s_len):

                    tmp_list.append(tmp_str)
                    tmp_str = ""
                    break

                print(idx)
                tmp_str += s[idx]
                last_idx = idx

        for value in tmp_list:
            answer += value


        return answer

if __name__ == '__main__':
    ret = Solution()
    tar_str = "AB"
    print(ret.convert(tar_str, 1))

解题思路如下所示：

通过列出字符串的“Z字形”排列形式我发现了规律，除了第一行和最后一行，中间几行的下标变换之间有上图所示的关系，所以程序里面的实现如下所示：

if j % 2 != 0:
    idx = last_idx + 2 * (numRows - i - 1)
else:
    idx = last_idx + 2 * i

之后再处理第一行和最后一行即可，仔细看这两行的数据在字符串里的坐标是成倍关系的，因此我做了特殊处理：

if i != 0 and i != numRows-1:
     if j % 2 != 0:
         idx = last_idx + 2 * (numRows - i - 1)
     else:
         idx = last_idx + 2 * i
 else:
     idx = last_idx + 2 * (numRows - 1)

 if j == 0:
     idx = i

最后就是单行处理了，就是将输入的字符串排列成一行，那么这个时候我们不用做处理，直接输出字符串即可：

if len(s) == 1 or numRows == 1:
     return s

7. 整数反转

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """

        answer = 0
        num_cnt = 0
        convert = 1

        if x < 0:
            x *= -1
            convert = -1

        tmp_str = str(x)
        num_cnt = len(tmp_str)
        tmp = x % 10

        while 1:
            answer += tmp * pow(10, num_cnt-1)
            num_cnt -= 1
            x = x // 10
            tmp = x % 10
            if (num_cnt == 0):
                break

        answer *= convert

        if (answer >= pow(2, 31) - 1) or (answer <= -1 * pow(2, 31)):
            return 0

        return answer



if __name__ == '__main__':
    ret = Solution()
    para = -123456789
    # print(para)
    print(ret.reverse(para))

这题我直接暴力循环解决，我将输入的数字正数化之后先转成字符串，然后求字符串长度从而求出数字位数，接下来就是普通的循环遍历了。

9. 回文数

class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        x_str = str(x)
        if len(x_str) == 1:
            return True

        start = 0
        end = len(x_str) - 1
        while start <= end:
            start += 1
            end -= 1
            if x_str[start] != x_str[end]:
                return False
        return True

if __name__ == '__main__':
    ret = Solution()
    para = 0
    print(ret.isPalindrome(para))

这题我也是先将数字转换成字符串，然后通过判断字符串回文的方法来判断整数是否回文，示意图如下：