Generating All Permutations of a Set

Given a set of distinct elements, your task is to find all possible orderings (permutations) of those elements. This is a fundamental problem in combinatorics and has applications in areas like password cracking, scheduling, and generating test cases.

Problem Description

You need to implement a function that takes a collection of distinct elements and returns a collection containing all possible unique permutations of these elements.

Key Requirements:

• The output should include every distinct arrangement of the input elements.
• The order of the permutations in the output collection does not matter, but each individual permutation must represent a unique ordering.
• The input collection will contain distinct elements, meaning no element will appear more than once.

Expected Behavior:

For an input collection of n distinct elements, the output should be a collection of n! (n factorial) permutations, where each permutation is a list or array of the same elements as the input.

Edge Cases to Consider:

• An empty input collection.
• An input collection with a single element.

Examples

Example 1:

Input: [1, 2, 3]
Output: [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
Explanation: These are all possible ways to arrange the numbers 1, 2, and 3.

Example 2:

Input: ["a", "b"]
Output: [["a", "b"], ["b", "a"]]
Explanation: The two distinct orderings of the characters 'a' and 'b'.

Example 3:

Input: []
Output: [[]]
Explanation: The only permutation of an empty set is an empty set itself.

Example 4:

Input: [5]
Output: [[5]]
Explanation: A single element has only one permutation.

Constraints

• The input collection will contain between 0 and 10 distinct elements, inclusive.
• The input collection will contain elements of a single, consistent data type (e.g., all integers, all strings).
• The time complexity to generate all permutations should be roughly proportional to the number of permutations multiplied by the size of each permutation.

Notes

This problem is often solved using recursion or backtracking. Consider how you might build up permutations by adding one element at a time, or by swapping elements to generate new arrangements. Think about how to avoid duplicate permutations if the input elements were not guaranteed to be distinct (though for this challenge, they are).