Decode the Slanted Ciphertext - Practice Coding Problems

Decode the Slanted Ciphertext - Problem

String Simulation Medium

Decode the Slanted Ciphertext is a fascinating string manipulation problem that simulates a unique transposition cipher technique.

You're given an encoded string that was created using a slanted transposition cipher. The original text was encoded by placing characters diagonally in a matrix (from top-left to bottom-right), then reading the matrix row by row to create the encoded string.

Your mission: Reverse this process to recover the original text!

Here's how the encoding works:
1. Create a matrix with a fixed number of rows
2. Fill characters diagonally (slanted pattern) from the original text
3. Empty cells are filled with spaces
4. Read the matrix row by row to create the encoded text

For example, if originalText = "cipher" and rows = 3:

c . . i . . 
. h . . p . 
. . e . . r

Reading row by row gives: "c i h p e r" (spaces preserved)

Input & Output

example_1.py — Basic Example

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

› Output: "cipher"

💡 Note: The matrix is filled row by row, then diagonals are extracted. First diagonal: c→h→e (positions 0,5,10), second diagonal: i→p (positions 3,7), third diagonal: r (position 11).

example_2.py — Single Row

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

› Output: "i love leetcode"

💡 Note: With 4 rows and longer text, multiple diagonals are extracted. Each diagonal starts from a different column in row 0 and moves diagonally down-right.

example_3.py — Edge Case

$ Input: encodedText = " b ac", rows = 2

› Output: " abc"

💡 Note: Even with spaces at the beginning, the diagonal extraction works correctly. The space is part of the first diagonal.

Visualization

Tap to expand

Understanding the Visualization

Understand the Matrix

The encoded string represents a matrix read row by row

Calculate Dimensions

cols = length ÷ rows gives us the matrix dimensions

Extract Diagonals

Follow diagonal paths from each column in row 0

Build Result

Concatenate all diagonal sequences to get original text

Key Takeaway

🎯 Key Insight: The slanted cipher places characters diagonally but reads row-wise. To decode, we reverse this by extracting diagonal sequences using calculated positions, achieving optimal O(n) time and O(1) space complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the encoded string, visiting each character exactly once

✓ Linear Growth

Space Complexity

O(1)

Only uses variables for calculations, no additional data structures

✓ Linear Space

Constraints

1 ≤ rows ≤ 1000
1 ≤ encodedText.length ≤ 10⁴
encodedText consists of lowercase English letters and spaces
encodedText.length is divisible by rows
The original text does not have trailing spaces

Asked in

G Google 28 a Amazon 22 f Meta 15 ⊞ Microsoft 12

The optimal approach uses direct index calculation to extract diagonal sequences without building a matrix. We calculate the position of each character as pos = row × cols + col and follow diagonal paths by incrementing both row and column. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Matrix Reconstruction Approach	O(n)	O(rows × cols)	Build the full matrix, place characters diagonally, then extract the result
Direct Index Calculation (Optimal)	O(n)	O(1)	Calculate diagonal positions directly without building a matrix

Matrix Reconstruction Approach — Algorithm Steps

Calculate the number of columns needed based on encoded text length and rows
Create a 2D matrix and fill it row by row from the encoded string
Extract characters by following diagonal paths (starting from each position in row 0)
Concatenate all diagonal sequences to form the original text
Remove trailing spaces from the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Fill Matrix Row-wise

Place encoded characters into matrix by reading row by row

Extract Diagonals

Follow diagonal paths starting from each column in row 0

Build Result

Concatenate all diagonal sequences to get original text

Code -

solution.c — C

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

char* decodeCiphertext(char* encodedText, int rows) {
    if (!encodedText || rows <= 0) return strdup("");
    
    int n = strlen(encodedText);
    int cols = n / rows;
    
    // Create matrix and fill row by row
    char** matrix = (char**)malloc(rows * sizeof(char*));
    for (int i = 0; i < rows; i++) {
        matrix[i] = (char*)malloc(cols * sizeof(char));
        for (int j = 0; j < cols; j++) {
            int idx = i * cols + j;
            if (idx < n) {
                matrix[i][j] = encodedText[idx];
            } else {
                matrix[i][j] = ' ';
            }
        }
    }
    
    char* result = (char*)malloc((n + 1) * sizeof(char));
    int pos = 0;
    
    // Extract diagonals starting from row 0
    for (int startCol = 0; startCol < cols; startCol++) {
        int r = 0, c = startCol;
        while (r < rows && c < cols) {
            result[pos++] = matrix[r][c];
            r++;
            c++;
        }
    }
    
    result[pos] = '\0';
    
    // Remove trailing spaces
    while (pos > 0 && result[pos - 1] == ' ') {
        result[--pos] = '\0';
    }
    
    // Free matrix
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);
    
    return result;
}

int main() {
    char encodedText[1000];
    int rows;
    
    fgets(encodedText, sizeof(encodedText), stdin);
    // Remove newline and quotes
    encodedText[strcspn(encodedText, "\n")] = '\0';
    if (encodedText[0] == '"') {
        memmove(encodedText, encodedText + 1, strlen(encodedText));
        encodedText[strlen(encodedText) - 1] = '\0';
    }
    
    scanf("%d", &rows);
    
    char* result = decodeCiphertext(encodedText, rows);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We traverse the encoded string once to fill matrix and once to extract diagonals

✓ Linear Growth

Space Complexity

O(rows × cols)

We store the entire matrix which has rows × cols cells

✓ Linear Space

Constraints

1 ≤ rows ≤ 1000
1 ≤ encodedText.length ≤ 10⁴
encodedText consists of lowercase English letters and spaces
encodedText.length is divisible by rows
The original text does not have trailing spaces

24.8K Views

Medium Frequency

~15 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Matrix Reconstruction Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler