ZigZag Conversion

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)

P   A   H   N
A P L S I I G
Y   I   R

And then read line by line: "PAHNAPLSIIGYIR"

 

Write the code that will take a string and make this conversion given a number of rows:

string convert(string text, int nRows);

convert("PAYPALISHIRING", 3) should return "PAHNAPLSIIGYIR".

Solution：：

The key here is to figure out the index pattern, just draw several concrete example could hele:

nRow = 2:

0 2 4 6 8 10 12
1 3 5 7 9 11 13

nRow = 3: 

0     4      8     12 
1  3  5   7  9  11
2     6     10

nRow = 4:
0      6       12
1   5  7    11 13
2 4    8  10
3      9

So inorder to get the final string, we need to scan from the left to right row by row, for the first and last row, the difference
between every two is 2 * nRow – 2, and for the middle say i-th rows, the difference between every two is either 2 * nRow – 2 – 2 * i
or 2 * i in turn. Following this, a linear scan of the original string could give us the final result string by pushing the corresponding character  at specific index into the final resulted string.

第0, len-1行各个字符之间的间隔为2×nRows - 2

第1~len-2行之间会有两个固定间隔之间会有其他字符插入

规律：index + 2 * nRows - 2 * i - 2, 这里i是指行号

 

public class Solution {
    public static String convert(String s, int nRows) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if (s == null || s.length() == 0 || nRows <= 1) {
            return s;
        }
        int len = s.length();
        StringBuffer buffer = new StringBuffer();
        int diff = 2 * nRows - 2;
        for (int i = 0; i < nRows && i < len; i++) {
            if (i == 0 || i == nRows - 1) {
                buffer.append(s.charAt(i));
                int index = i;
                while (index + diff < len) {
                    buffer.append(s.charAt(index + diff));
                    index = index + diff;
                }
            } 
            else{
                buffer.append(s.charAt(i));
                int index = i;
                while (2 * nRows - 2 * i - 2 + index < len
                        || index + diff < len) {
                    if(2 * nRows - 2 * i - 2 + index < len){
                        buffer.append(s.charAt(2 * nRows - 2 * i - 2 + index));
                    }
                    if (index + diff < len) {
                        buffer.append(s.charAt(index + diff));
                    }
                    index += diff;
                }
            }
        }
        return buffer.toString();
    }
}

 第二遍：

public class Solution {
    public String convert(String s, int nRows) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        StringBuffer sb = new StringBuffer();
        for(int i = 0; i < nRows; i ++){
            int j = i;
            int k = 0;
            while(j < s.length()){
                sb.append(s.charAt(j));
                if ( nRows == 1 ){
                    j ++;
                }
                if(i == 0 || i == nRows - 1){
                    j += (nRows - 1) * 2;
                }else{
                    j += (k % 2 == 1) ? ((nRows - 1) * 2- nRows * 2 + (i + 1) * 2) : (nRows * 2-(i + 1) * 2);
                }
                k ++;
            }
        }
        return sb.toString();
    }
}

 第三遍：

public class Solution {
    public String convert(String s, int nRows) {
        if(s == null || s.length() == 0) return "";
        if(nRows == 1) return s;
        StringBuilder sb = new StringBuilder();
        for(int i = 0; 2*(nRows - 1) * i < s.length(); i ++){//first row
            sb.append(s.charAt(2*(nRows - 1) * i));
        }

        for(int j = 1; j < nRows - 1; j ++){
            for(int i = 0; (j + 2 * i * (nRows - 1)) < s.length(); i ++){
                sb.append(s.charAt((j + 2 * i * (nRows - 1))));
                if((2 * (nRows - 1) * (i + 1) - j) < s.length())
                    sb.append(s.charAt(2 * (nRows - 1) * (i + 1) - j));
            }
        }
        
        for(int i = 0; (nRows - 1) * (2 * i + 1) < s.length(); i ++){//last row
            sb.append(s.charAt((nRows - 1) * (2 * i + 1)));
        }
        return sb.toString();
    }
}