Decode the Slanted Ciphertext

Decode the Slanted Ciphertext - Problem

String Simulation Medium

A string originalText is encoded using a slanted transposition cipher to a string encodedText with the help of a matrix having a fixed number of rows rows.

originalText is placed first in a top-left to bottom-right manner.

The blue cells are filled first, followed by the red cells, then the yellow cells, and so on, until we reach the end of originalText. The arrow indicates the order in which the cells are filled. All empty cells are filled with ' '. The number of columns is chosen such that the rightmost column will not be empty after filling in originalText.

encodedText is then formed by appending all characters of the matrix in a row-wise fashion.

The characters in the blue cells are appended first to encodedText, then the red cells, and so on, and finally the yellow cells. The arrow indicates the order in which the cells are accessed.

For example, if originalText = "cipher" and rows = 3, then we encode it in the following manner:

The blue arrows depict how originalText is placed in the matrix, and the red arrows denote the order in which encodedText is formed. In the above example, encodedText = "ch ie pr".

Given the encoded string encodedText and number of rows rows, return the original string originalText.

Note: originalText does not have any trailing spaces ' '. The test cases are generated such that there is only one possible originalText.

Input & Output

Example 1 — Basic Case

$ Input: encodedText = "ch ie pr", rows = 3

› Output: cipher

💡 Note: The matrix is 3×3. Fill row by row: [[c,h, ],[i,e, ],[p,r, ]]. Read diagonally: c→i→p, h→e, (space) gives "cipher"

Example 2 — Single Row

$ Input: encodedText = "iveo eed l te olc", rows = 4

› Output: i love leetcode

💡 Note: Matrix is 4×6. After filling and reading diagonally: i→v→e→o→(space)→(space), giving the original text with trailing spaces removed

Example 3 — One Row Only

$ Input: encodedText = "coding", rows = 1

› Output: coding

💡 Note: With only 1 row, no transformation occurs. The encoded text is the same as original text

Constraints

1 ≤ rows ≤ 1000
1 ≤ encodedText.length ≤ 2000
encodedText consists of lowercase English letters and spaces
originalText does not have trailing spaces

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 a Amazon 6

The key insight is understanding the slanted transposition cipher pattern: text is filled diagonally but read row-wise. To decode, we reverse this by filling a matrix row-wise and reading diagonally. The optimal approach uses direct position calculation to avoid storing the full matrix. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force Matrix Reconstruction

⏱️ Time: O(n) Space: O(n)

Create a 2D matrix, fill it row by row from the encoded text, then traverse diagonally to reconstruct the original text. This approach directly simulates the encoding process in reverse.

Direct Position Calculation

⏱️ Time: O(n) Space: O(1)

Instead of reconstructing the entire matrix, we calculate where each character in the original text should be placed based on the diagonal filling pattern. This eliminates the need for extra matrix storage.

Brute Force Matrix Reconstruction — Algorithm Steps

Calculate matrix dimensions: cols = ceil(len(encodedText) / rows)
Fill matrix row by row with characters from encodedText
Traverse matrix diagonally (top-left to bottom-right) to get original text
Remove trailing spaces from result

Visualization

Tap to expand

Step-by-Step Walkthrough

Fill Matrix

Place encoded text row by row

Read Diagonals

Traverse diagonally from each column start

Result

Original text with trailing spaces removed

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* solution(char* encodedText, int rows) {
    int n = strlen(encodedText);
    if (rows == 1) {
        char* result = malloc((n + 1) * sizeof(char));
        strcpy(result, encodedText);
        return result;
    }
    
    int cols = (n + rows - 1) / rows;
    
    // Create matrix and fill row by row
    char** matrix = malloc(rows * sizeof(char*));
    for (int i = 0; i < rows; i++) {
        matrix[i] = malloc(cols * sizeof(char));
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = ' ';
        }
    }
    
    int idx = 0;
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) {
            if (idx < n) {
                matrix[r][c] = encodedText[idx++];
            }
        }
    }
    
    // Read diagonally
    char* result = malloc((n + 1) * sizeof(char));
    int resultIdx = 0;
    for (int startCol = 0; startCol < cols; startCol++) {
        int r = 0, c = startCol;
        while (r < rows && c < cols) {
            result[resultIdx++] = matrix[r][c];
            r++;
            c++;
        }
    }
    result[resultIdx] = '\0';
    
    // Remove trailing spaces
    while (resultIdx > 0 && result[resultIdx - 1] == ' ') {
        result[--resultIdx] = '\0';
    }
    
    // Free matrix
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);
    
    return result;
}

int main() {
    char encodedText[1001];
    fgets(encodedText, sizeof(encodedText), stdin);
    encodedText[strcspn(encodedText, "\n")] = 0;
    
    int rows;
    scanf("%d", &rows);
    
    char* result = solution(encodedText, rows);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to fill matrix and single diagonal traversal

✓ Linear Growth

Space Complexity

O(n)

Matrix of size rows × cols stores all characters

⚡ Linearithmic Space

15.2K Views

Medium Frequency

~15 min Avg. Time

342 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Matrix Reconstruction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler