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

string convert(string text, int nRows);

 1 /*
 2  * 
 3  * 0A     8I     16Q     24Y
 4  * 1B  7H 9J  15P17R  23X25Z
 5  * 2C 6G 10K 14O 18S 22W 
 6  * 3D5F  11L13N  19T21V
 7  * 4E    12M     20U
 8  */
 9 public class ZigZagConversion {
10     public String convert(String s,int numRows){
11         if(s.length()<=numRows||numRows==1)
12             return s;
13         StringBuilder []res=new StringBuilder[numRows];
14         for(int i=0;i<numRows;i++)
15             res[i]=new StringBuilder();
16         int loop=2*numRows-2;
17         int mid=numRows-1;
18         for(int i=0;i<s.length();i++){
19             res[mid-Math.abs(i%loop-mid)].append(s.charAt(i));
20         }
21         for(int i=1;i<numRows;i++)
22             res[0].append(res[i]);
23         return res[0].toString();
24         
25     }
26 
27 }

 1 /**
 2  * A thread-safe, mutable sequence of characters. 
 3  * A string buffer is like a {@link String}, but can be modified. At any 
 4  * point in time it contains some particular sequence of characters, but 
 5  * the length and content of the sequence can be changed through certain 
 6  * method calls.
 7  * <p>
 8  * String buffers are safe for use by multiple threads. The methods 
 9  * are synchronized where necessary so that all the operations on any 
10  * particular instance behave as if they occur in some serial order 
11  * that is consistent with the order of the method calls made by each of 
12  * the individual threads involved.
13  * <p>
14  * The principal operations on a <code>StringBuffer</code> are the 
15  * <code>append</code> and <code>insert</code> methods, which are 
16  * overloaded so as to accept data of any type. Each effectively 
17  * converts a given datum to a string and then appends or inserts the 
18  * characters of that string to the string buffer. The 
19  * <code>append</code> method always adds these characters at the end 
20  * of the buffer; the <code>insert</code> method adds the characters at 
21  * a specified point. 
22  * <p>
23  * For example, if <code>z</code> refers to a string buffer object 
24  * whose current contents are "<code>start</code>", then 
25  * the method call <code>z.append("le")</code> would cause the string 
26  * buffer to contain "<code>startle</code>", whereas 
27  * <code>z.insert(4, "le")</code> would alter the string buffer to 
28  * contain "<code>starlet</code>". 
29  * <p>
30  * In general, if sb refers to an instance of a <code>StringBuffer</code>, 
31  * then <code>sb.append(x)</code> has the same effect as 
32  * <code>sb.insert(sb.length(),&nbsp;x)</code>.
33  * <p>
34  * Whenever an operation occurs involving a source sequence (such as
35  * appending or inserting from a source sequence) this class synchronizes
36  * only on the string buffer performing the operation, not on the source.
37  * <p>
38  * Every string buffer has a capacity. As long as the length of the 
39  * character sequence contained in the string buffer does not exceed 
40  * the capacity, it is not necessary to allocate a new internal 
41  * buffer array. If the internal buffer overflows, it is 
42  * automatically made larger. 
43  *
44  * As of  release JDK 5, this class has been supplemented with an equivalent 
45  * class designed for use by a single thread, {@link StringBuilder}.  The 
46  * <tt>StringBuilder</tt> class should generally be used in preference to 
47  * this one, as it supports all of the same operations but it is faster, as 
48  * it performs no synchronization.
49  *
50  * @author    Arthur van Hoff
51  * @version     %I%, %G%
52  * @see     java.lang.StringBuilder
53  * @see     java.lang.String
54  * @since   JDK1.0
55  */

 1 /**
 2  * A mutable sequence of characters.  This class provides an API compatible
 3  * with <code>StringBuffer</code>, but with no guarantee of synchronization.
 4  * This class is designed for use as a drop-in replacement for
 5  * <code>StringBuffer</code> in places where the string buffer was being
 6  * used by a single thread (as is generally the case).   Where possible,
 7  * it is recommended that this class be used in preference to
 8  * <code>StringBuffer</code> as it will be faster under most implementations.
 9  * 
10  * <p>The principal operations on a <code>StringBuilder</code> are the 
11  * <code>append</code> and <code>insert</code> methods, which are 
12  * overloaded so as to accept data of any type. Each effectively 
13  * converts a given datum to a string and then appends or inserts the 
14  * characters of that string to the string builder. The 
15  * <code>append</code> method always adds these characters at the end 
16  * of the builder; the <code>insert</code> method adds the characters at 
17  * a specified point. 
18  * <p>
19  * For example, if <code>z</code> refers to a string builder object 
20  * whose current contents are "<code>start</code>", then 
21  * the method call <code>z.append("le")</code> would cause the string 
22  * builder to contain "<code>startle</code>", whereas 
23  * <code>z.insert(4, "le")</code> would alter the string builder to 
24  * contain "<code>starlet</code>". 
25  * <p>
26  * In general, if sb refers to an instance of a <code>StringBuilder</code>, 
27  * then <code>sb.append(x)</code> has the same effect as 
28  * <code>sb.insert(sb.length(),&nbsp;x)</code>.
29  *
30  * Every string builder has a capacity. As long as the length of the 
31  * character sequence contained in the string builder does not exceed 
32  * the capacity, it is not necessary to allocate a new internal 
33  * buffer. If the internal buffer overflows, it is automatically made larger.
34  *
35  * <p>Instances of <code>StringBuilder</code> are not safe for
36  * use by multiple threads. If such synchronization is required then it is
37  * recommended that {@link java.lang.StringBuffer} be used. 
38  *
39  * @author    Michael McCloskey
40  * @version     %I%, %G%
41  * @see         java.lang.StringBuffer
42  * @see         java.lang.String
43  * @since    1.5
44  */