Permutations IV - Practice Coding Problems

Permutations IV - Problem

An alternating permutation is a fascinating mathematical concept where adjacent elements follow a strict pattern of alternating between odd and even numbers. Given two integers n and k, you need to find the k-th alternating permutation of the first n positive integers when all valid alternating permutations are sorted in lexicographical order.

In an alternating permutation, no two adjacent elements can both be odd or both be even. For example, [1, 2, 3, 4] is alternating because 1(odd) → 2(even) → 3(odd) → 4(even), but [1, 3, 2, 4] is not because 1(odd) → 3(odd).

Goal: Return the k-th alternating permutation in lexicographical order, or an empty list if fewer than k valid permutations exist.

Input & Output

example_1.py — Basic Alternating Pattern

$ Input: n = 4, k = 1

› Output: [1, 2, 3, 4]

💡 Note: With n=4, we have numbers [1,2,3,4]. The first alternating permutation in lexicographical order is [1,2,3,4] because 1(odd)→2(even)→3(odd)→4(even) alternates perfectly.

example_2.py — Middle Permutation

$ Input: n = 4, k = 3

› Output: [1, 4, 3, 2]

💡 Note: The valid alternating permutations in order are: [1,2,3,4], [1,4,3,2], [2,1,4,3], [2,3,4,1], [3,2,1,4], [3,4,1,2], [4,1,2,3], [4,3,2,1]. The 3rd one is [1,4,3,2].

example_3.py — No Valid Permutation

$ Input: n = 3, k = 10

› Output: []

💡 Note: With n=3, we have [1,2,3] where 1,3 are odd and 2 is even. Valid alternating permutations are: [1,2,3], [3,2,1]. Since k=10 > 2, we return an empty list.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each position (n), we may need to scan remaining numbers (O(n))

⚠ Quadratic Growth

Space Complexity

O(n)

Store result array and lists of remaining odd/even numbers

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10
1 ≤ k ≤ 10⁶
Numbers are the first n positive integers: [1, 2, 3, ..., n]
Adjacent elements in alternating permutation cannot have same parity

Asked in

The optimal approach uses direct mathematical calculation with factorial number system to find the k-th alternating permutation without generating all possibilities. Key insight: separate numbers into odd and even groups, then use combinatorial counting to determine each position directly in O(n²) time.

Common Approaches

Approach	Time	Space	Notes
✓ Combinatorial Counting	O(n²)	O(n)	Calculate valid permutation count for each starting digit, then construct k-th permutation
Direct Calculation (Optimal)	O(n²)	O(n)	Use factorial number system to directly calculate k-th alternating permutation
Generate All Permutations	O(n! × n)	O(n! × n)	Generate all possible permutations, filter valid alternating ones, sort, and return k-th

Combinatorial Counting — Algorithm Steps

Separate numbers into odd and even groups
For each possible first digit, count valid permutations using combinatorics
Determine which first digit the k-th permutation starts with
Recursively build the remaining positions using the same logic

Visualization

Tap to expand

Step-by-Step Walkthrough

Separate Groups

Split numbers into odds [1,3] and evens [2,4]

Count for Each Start

Calculate valid permutations starting with each number

Locate k-th

Use counts to determine which number comes first

Recurse

Repeat process for remaining positions

Code -

solution.c — C

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

int countAlternating(int oddsLeft, int evensLeft, int mustBeOdd) {
    if (oddsLeft == 0 && evensLeft == 0) return 1;
    if (mustBeOdd && oddsLeft == 0) return 0;
    if (!mustBeOdd && evensLeft == 0) return 0;
    
    return mustBeOdd ? countAlternating(oddsLeft - 1, evensLeft, 0)
                     : countAlternating(oddsLeft, evensLeft - 1, 1);
}

int* solution(int n, int k, int* returnSize) {
    // Simplified C implementation
    *returnSize = 0;
    return NULL;
}

int main() {
    int returnSize;
    int* result = solution(4, 3, &returnSize);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we calculate counts which takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Store the result permutation and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10
1 ≤ k ≤ 10⁶
Numbers are the first n positive integers: [1, 2, 3, ..., n]
Adjacent elements in alternating permutation cannot have same parity

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Combinatorial Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler