Zigzag Conversion

                                            
class Solution {
public:
    string convert(string s, int numRows) {
        if (numRows == 1) {
            return s;
        }
        
        vector<string> rows(min(numRows, (int)s.size()));
        int curRow = 0;
        bool goingDown = false;
        
        for (char c : s) {
            rows[curRow] += c;
            if (curRow == 0 || curRow == numRows - 1) {
                goingDown = !goingDown;
            }
            curRow += goingDown ? 1 : -1;
        }
        
        string result;
        for (string row : rows) {
            result += row;
        }
        
        return result;
    }
};

                                            
class Solution {
    public String convert(String s, int numRows) {
        if (numRows == 1 || s.length() <= numRows) {
            return s;
        }
        
        StringBuilder[] rows = new StringBuilder[numRows];
        for (int i = 0; i < numRows; i++) {
            rows[i] = new StringBuilder();
        }
        
        int direction = 1;
        int row = 0;
        for (char c : s.toCharArray()) {
            rows[row].append(c);
            row += direction;
            if (row == 0 || row == numRows - 1) {
                direction *= -1;
            }
        }
        
        StringBuilder result = new StringBuilder();
        for (StringBuilder rowString : rows) {
            result.append(rowString);
        }
        
        return result.toString();
    }
}

                                            
char* convert(char* s, int numRows){
    if (numRows == 1) {
        return s;
    }
    
    int len = strlen(s);
    char* result = (char*)malloc(len + 1);
    int step = 2 * (numRows - 1);
    int index = 0;
    
    for (int i = 0; i < numRows; i++) {
        for (int j = i; j < len; j += step) {
            result[index++] = s[j];
            if (i > 0 && i < numRows - 1 && j + step - 2 * i < len) {
                result[index++] = s[j + step - 2 * i];
            }
        }
    }
    
    result[len] = '\0';
    
    return result;
}

                                            
public class Solution {
    public string Convert(string s, int numRows) {
        if (numRows == 1 || s.Length <= numRows) {
            return s;
        }
        
        StringBuilder[] rows = new StringBuilder[numRows];
        for (int i = 0; i < numRows; i++) {
            rows[i] = new StringBuilder();
        }
        
        int currentRow = 0;
        bool goingDown = false;
        
        foreach (char c in s) {
            rows[currentRow].Append(c);
            if (currentRow == 0 || currentRow == numRows - 1) {
                goingDown = !goingDown;
            }
            currentRow += goingDown ? 1 : -1;
        }
        
        StringBuilder result = new StringBuilder();
        foreach (StringBuilder row in rows) {
            result.Append(row);
        }
        
        return result.ToString();
    }
}

                                            
var convert = function(s, numRows) {
    if (numRows === 1) return s;
    
    const rows = new Array(Math.min(numRows, s.length)).fill('');
    let curRow = 0;
    let goingDown = false;
    
    for (const char of s) {
        rows[curRow] += char;
        if (curRow === 0 || curRow === numRows - 1) goingDown = !goingDown;
        curRow += goingDown ? 1 : -1;
    }
    
    return rows.join('');
};

                                            
function convert(s: string, numRows: number): string {
    if (numRows === 1) return s;

    const rows: string[] = Array.from({ length: Math.min(numRows, s.length) }, () => "");
    let currentRow = 0;
    let goingDown = false;

    for (let i = 0; i < s.length; i++) {
        rows[currentRow] += s[i];
        if (currentRow === 0 || currentRow === numRows - 1) {
            goingDown = !goingDown;
        }
        currentRow += goingDown ? 1 : -1;
    }

    return rows.join("");
};

                                            
class Solution {
    func convert(_ s: String, _ numRows: Int) -> String {
        if numRows == 1 {
            return s
        }
        
        var rows = Array(repeating: "", count: min(numRows, s.count))
        var currentRow = 0
        var goingDown = false
        
        for char in s {
            rows[currentRow] += String(char)
            if currentRow == 0 || currentRow == numRows - 1 {
                goingDown = !goingDown
            }
            currentRow += goingDown ? 1 : -1
        }
        
        return rows.joined()
    }
}

                                            
func convert(s string, numRows int) string {
    if numRows == 1 {
        return s
    }
    
    rows := make([]string, min(numRows, len(s)))
    curRow := 0
    goingDown := false
    
    for i := 0; i < len(s); i++ {
        rows[curRow] += string(s[i])
        if curRow == 0 || curRow == numRows-1 {
            goingDown = !goingDown
        }
        if goingDown {
            curRow++
        } else {
            curRow--
        }
    }
    
    result := ""
    for _, row := range rows {
        result += row
    }
    
    return result
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

                                            
def convert(s, num_rows)
    return s if num_rows == 1
    rows = Array.new([s.length, num_rows].min) { "" }
    current_row = 0
    direction = 1
    s.each_char do |char|
        rows[current_row] += char
        current_row += direction
        if current_row == num_rows - 1 || current_row == 0
            direction *= -1
        end
    end
    rows.join
end

                                            
object Solution {
    def convert(s: String, numRows: Int): String = {
        if (numRows == 1 || s.length <= numRows) return s
        val result = new StringBuilder
        val step = 2 * numRows - 2
        for (i <- 0 until numRows) {
            var j = i
            while (j < s.length) {
                result.append(s(j))
                if (i != 0 && i != numRows - 1) {
                    val k = j + step - 2 * i
                    if (k < s.length) result.append(s(k))
                }
                j += step
            }
        }
        result.toString
    }
}

                                            
impl Solution {
    pub fn convert(s: String, num_rows: i32) -> String {
        if num_rows == 1 {
            return s;
        }
        
        let mut rows: Vec<String> = vec![String::new(); num_rows as usize];
        let mut index = 0;
        let mut increment = 1;
        
        for c in s.chars() {
            rows[index as usize].push(c);
            if index == 0 {
                increment = 1;
            } else if index == num_rows - 1 {
                increment = -1;
            }
            index += increment;
        }
        
        let result: String = rows.join("");
        return result;
    }
}

To solve this coding challenge, we need to convert a given string

s

into a zigzag pattern based on the number of rows

numRows

and then read the string line by line. Let's break down the approach and provide the pseudocode for clarity.

Explanation

The zigzag pattern involves writing the string in a diagonal fashion across multiple rows and then switching direction to move upwards to the top row. Once this pattern is complete, we concatenate the characters row by row to obtain the final output string.

Special Case Handling :

If
numRows

is 1, the string remains unchanged as there is no zigzag pattern with just one row.
If the string length is less than the number of rows, the output is the string itself since it can't form a zigzag pattern with insufficient characters.

Initialize Data Structures :

Create a list of strings (one for each row).
Use a variable to track the current row and another to determine the direction (downwards or upwards).

Iteration Through Characters :

Iterate through each character in the string.
Append the character to the current row.
Adjust the current row based on the direction (increment or decrement).
Change the direction when reaching the topmost or bottommost row.

Join Rows :

Concatenate all strings from the rows to form the final result.

Step-by-Step Explanation/Detailed Steps in Pseudocode

Check Special Case :

If
numRows

is 1, return the input string
s

.

Initialize Rows :

Create an array
rows

of size
min(numRows, length of s)

filled with empty strings.

Initialize Helper Variables :

Set
currentRow

to 0.
Set
goingDown

to False.

Iterate Through Characters :

For each character in the string
s

:

Add the character to
rows[currentRow]

.
If
currentRow

is 0 or
currentRow

is
numRows - 1

, toggle
goingDown

.
Update
currentRow

(increment if
goingDown

is True, else decrement).

Concatenate Rows :

Join all strings in
rows

to form the final output string.

Pseudocode

                                            
# Convert string s into a zigzag pattern with numRows

# Special case: if numRows is 1, simply return s
if numRows equals 1:
    return s

# Create an array for rows, with minimum size of either numRows or length of s
rows <- create array of empty strings of size min(numRows, length of s)

# Initialize current row and direction flag
currentRow <- 0
goingDown <- False

# Iterate through characters in the string
for each character in s:
    # Append character to the current row
    rows[currentRow] <- rows[currentRow] + character
    
    # Check direction change
    if currentRow equals 0 or currentRow equals numRows - 1:
        goingDown <- not goingDown
    
    # Update current row based on direction
    if goingDown:
        currentRow <- currentRow + 1
    else:
        currentRow <- currentRow - 1

# Join all rows to form the final zigzag string
result <- join all strings in rows

return result

This detailed process ensures that we handle edge cases and manage the zigzag conversion accurately. The pseudocode provides a structured approach to solving the problem, ensuring readability and clarity.