6. ZigZag Conversion [Medium]

这道题自己第一次写出来的就是solution中的普遍做法：

以Z字形的每个竖提为重复单元（不包括下一个竖提的开头）来找每行的规律，利用该规律将s中的字母逐行append到stringbuilder。

答案之间不同之处在于以下两个特殊情况的处理：

1. 是否将首尾两行（尖角）单独处理，这样会多两个循环，但省去了双层循环中的特殊情况判断；

2. 是否将最后一个不完整单元单独处理，这样会在每行的循环（外层循环）中多一段单独处理最后单元的代码，但省去了双层循环中的特殊情况判断。

/**
 * 自己的代码
 * 首尾行不单独处理，不完整单元单独处理
 */
class Solution {
    public String convert(String s, int numRows) {
        int size = s.length();
        if (numRows == 1 || numRows >= size)
            return s;
        int part = numRows * 2 - 2; // 每个重复单元包含的字母个数（以竖提为重复单元，不包括下一个竖提的开头）
        int num = size / part; // 有多少个完整的重复单元
        StringBuilder sb = new StringBuilder(size);

        for (int i = 0; i < numRows; i++) { // 逐行append到stringbuilder中
            for (int j = 0; j < num; j++) { // 处理所有完整的重复单元
                sb.append(s.charAt(part * j + i)); // 每行从每个重复单元都至少append一个字母
                if (i % (part / 2) != 0) // 对于不是尖角上的字母，每行从每个重复单元append两个字母，在第一个字母后append它在重复单元中的对称位字母
                    sb.append(s.charAt(part * (j + 1) - i));
            }
            int first = part * num + i; // 处理不完整重复单元
            if (first >= size)
                continue;
            sb.append(s.charAt(first));
            int second = part * (num + 1) - i;
            if (second == first || second >= size)
                continue;
            sb.append(s.charAt(second));
        }
        return sb.toString();
    }
}

/**
 * 总结出来的最压缩代码
 * 首尾行和不完整单元都不单独处理
 * 把是否为尖角、是否为最后的不完整单元的判断都放在双层的循环里
 * 这样代码最短，时间复杂度也低，但每个双层循环里面要执行的判断较多
 */
class Solution {
    public String convert(String s, int numRows) {
        int size = s.length();
        if (numRows == 1 || size <= numRows)
            return s;
        int part = numRows * 2 - 2;
        int group = size % part == 0 ? size / part : size / part + 1;
        StringBuilder sb = new StringBuilder(size);
        
        for (int i = 0; i < numRows; i++) {
            for (int j = 0; j < group; j++) {
                int first = j * part + i;
                if (first >= size)
                    break;
                sb.append(s.charAt(first));
                int second = (j + 1) * part - i;
                if (i % (part / 2) != 0 && second < size)
                    sb.append(s.charAt(second));
            }
        }
        return sb.toString();
    }
}

/**
 * 双层循环中不处理特殊情况的代码
 * 首尾行和不完整单元都不单独处理
 * 这样代码量最大，也有不少重复逻辑，但双层循环中判断少
 */
class Solution {
    public String convert(String s, int numRows) {
        int size = s.length();
        if (numRows == 1 || size <= numRows)
            return s;
        int part = numRows * 2 - 2;
        int group = size / part;
        StringBuilder sb = new StringBuilder(size);
        
        // 处理首行
        for (int i = 0; i < size; i += part)
            sb.append(s.charAt(i));
        // 处理中间
        for (int i = 1; i < numRows - 1; i++) {
            // 处理完整的重复单元
            for (int j = 0; j < group; j++)
                sb.append(s.charAt(j * part + i)).append(s.charAt((j + 1) * part - i));
            // 处理不完整的重复单元
            int first = group * part + i;
            if (first >= size)
                continue;
            sb.append(s.charAt(first));
            int second = (group + 1) * part - i;
            if (second < size)
                sb.append(s.charAt(second));
        }
        // 处理尾行
        for (int i = part / 2; i < size; i += part)
            sb.append(s.charAt(i));
        return sb.toString();
    }
}