Question

public class Permutations

{

    // Helper method for outputting an array.

    private static void PrintArray(string[] array)

    {

        foreach (string element in array)

        {

            Console.Write($"{element} ");

        }

        Console.WriteLine();

    }

    // Helper method for invoking Generate.

    private static void Generate(string[] array)

    {

        Generate(array.Length, array);

    }

    public static void Main(string[] args)

    {

    }

}

procedure generate(k : integer, A : array of any):

    if k = 1 then

          output(A)

    else

        // Generate permutations with kth unaltered

        // Initially k == length(A)

        generate(k - 1, A)

        // Generate permutations for kth swapped with each k-1 initial

        for i := 0; i < k-1; i += 1 do

            // Swap choice dependent on parity of k (even or odd)

            if k is even then

                swap(A[i], A[k-1]) // zero-indexed, the kth is at k-1

            else

                swap(A[0], A[k-1])

            end if

            generate(k - 1, A)

        end for

    end if

Your task is to write a program that will print out all the permutations of the command line arguments to a program. For example, given the arguments qaz, wsx, and 'edc', your program should output: wsx qaz edc wsx edc qaz edc wsx qaz Your implementation is expected to use Heap's algorithm according to the following pseudocode: procedure generate(k integer, Aarray of any): if k-1 then output CA) // Generate permutations with kth unaltered generate(k 1, A) // Generate permutations for kth swapped with each k-1 initial else // Initially k1ength(A) // Swap choice dependent on parity of k (even or odd) if k is even then swap (ATİ], A[k-1]) // zero-indexed, the kth is k-1 at else swap(ALO], A[k-1]) end if generate(k1, A) end for end if This algorithm uses recursion, which is when a procedure (e.g. method or function) calls itself from within its own code For the output procedure called in the pseudocode, you should use the PrintArray method provided in the below skeleton (which you will use as a basis for your program). Because the algorithm involves recursion, it is necessary for the recursive procedure generate to receive an initial k value equal to the length of the provided array. Therefore, an optional helper method Generate has been provided to wrap your implementation. For the output procedure called in the pseudocode, you should use the PrintArray method provided in the below skeleton (which you will use as a basis for your program). Because the algorithm involves recursion, it is necessary for the recursive procedure generate to receive an initial k value equal to the length of the provided array. Therefore, an optional helper method Generate has been provided to wrap your implementation. public class Permutations // Helper method for outputting an array. private static void PrintArray(string] array) foreach (string element in array) Console.write(S"element" Console.WritelineO; // Helper method for invoking Generate private static void Generate(string] array) Generate(array. Length, array): public static void Main(stringl args) To complete the implementation, you will need to Optionally, but strongly recommended, impement an additional helper method that swaps two elements of an array. You will find this to be useful for your implementation of Heap's algorithm. Implement the generate procedure described in the above pseudocode (calling PrintArray in place of output) via a method with the following signature Generate(int, stringt] Connect Main with your Generate implementation.

Answer 1

using System.IO;
using System;

public class Permutations
{
// Helper method for outputting an array.
private static void PrintArray(string[] array)
{
foreach(string element in array)
{
Console.Write($"{element} ");
}
  
Console.WriteLine();
  
}
  
// Helper method for invoking Generate.
private static void Generate(string[] array)
{
Generate(array.Length,array);
}
  
private static void Generate(int k, string[] array)
{
if(k==1)
       PrintArray(array);
   else
   {
   // Generate permutations for kth unaltered
   // Initially k == length(array)
  
   Generate(k-1,array);
  
   // Generate permutations for kth swapped with each k-1 initial
   for(int i=0;i<k-1;i++)
{
   // Swap choice dependent on parity of k(even or odd)
if(k%2 == 0)
{
swap(array,i,k-1); // zero indexed , the kth is at k-1
}else
{
swap(array,0,k-1);
}
Generate(k-1,array);
}
   }
}
  
private static void swap(string[] array, int i, int j)
{
   string temp = array[i];
   array[i] = array[j];
   array[j] = temp;
}
  
public static void Main(string[] args)
{

       Generate(args);
}
}

Output:

Input

Command Line arguments : qax wsx edc

Output:

qaz wsx edc wsx qaz edc edc qaz wsx qaz edc wsx wsx edc qaz edc wsx qaz