Problem Statement:

Take an integer as input that indicates the size of a dynamically allocated integer array $($one

dimensional $($ID$)).$ The array contains positive integers $(>0)$ and $-1.$ Take all the elements of the

array as input. You have to split the elements of the array based on $-1.$ Keep the splitted elements

as the rows of a dynamically allocated two$-$dimensional $(2$D$)$ array and print the elements of the

$2D$ array. Finally sort each row of the $2$D array and print the elements of the $2$D array again.

Procedure: $[$The rightmost values inside third lhracket indicate marks for implementing functions$)$

For solving the problem, you have to implement the functions prototyped below:

int" two$\_$dimensional$($int "ara, int $n,$ int "total$\_$rows, int "sizes$\_$of$\_$each$\_$row$)[10]$

ara: ID integer array that contains positive integers $(>0)$ and $-1$

$n$ : the size of the ara

total$\_$rows: the reference to the number of rows of the newly generated $2$D array

sizes$\_$of$\_$each$\_$row: integer array $(1$D$)$ that stores the sizes of the $1$D arrays

indicating the rows of the generated $2D$ array

This function will return the generated $2D$ array.

void Printing$2$D$($int $*"$ara$2$d$,$ int "sizes$\_$of$\_$each$\_$row, int rows$)$

ara$2$d: $2D$ integer array

sizes$\_$of$\_$each$\_$row: integer array $(1$D$)$ that stores the sizes of the $1$D arrays

indicating the rows of ara$2$d

rows: The number of rows of ara$2$d

This function is for printing the contents of ara$2$d

void sorting$2$D$($int $"*$ara$2$d$,$ int "sizes$\_$of$\_$each$\_$row, int rows$)$

ara$2$d: $2D$ integer array

sizes$\_$of$\_$each$\_$row: integer array $($ID$)$ that stores the sizes of the ID arrays

indicating the rows of ara $2d$

rows: The number of rows of ara$2$d

This function will sort each row elements of ara $2d$ separately

Restrictions:

To access an element or to define array size, you can't use array indexing$/$defining with $[]$

operator. In other words, your code mustn't contain any third bracket $[].$

You have to use dynamic memory allocation for each array you use and free them when

they are no longer needed. While allocating memory, be careful to efficiently allocate the

memory.

Please first calculate the amount of memory required and then allocate just the needed

amount. Allocation of a constant big amount of memory will result in a penalty.

You are not allowed to change the function prototypes.

$-1$ cannot be the $1$ st or last element of the input $1$D array. Also $-1$ cannot occur side by

side inside the input $1$D array.

Sample Inputs$/$Outputs:

Explanation:

Consider the second test case.

The first line denotes the size of the $1$D array and the second line indicates all the elements of the

array. There is only one $-1$ in the array that splits the $1D$ array into a $2D$ array with $2$ rows $($i$.$e$.,$

row No$.0=>\{32,45,12\}$ and row No$.1=>\{22,12,78,49,33\}.$ After sorting each row

separately, the rows will be $\{12,32,45\}$ and $\{12,22,33,49,78\}.$