Enter a square matrix using diagonals. That is, first the main diagonal is introduced, then the diagonal is one longer below and the last element of this string (which does not enter the matrix range must be transferred to the upper right angle), etc. Please in solving the task not to use the Faction vector.

Example (numbers are simply presented for visualing the work of diagonals, the matrix can be of any size):

```
1 *** 1 ** 2 1 * 32
* 1 ** 21 ** 21 * 3
** 1 * * 21 * 321 *
*** 1 ** 21 * 321
```

My code but without transferring items not included in the matrix range:

```
# include & lt; iostream & gt;
INT MAIN ()
{
int n;
CIN & GT; & gt; n;
INT MAT [N] [N];
for (int i = 0; i & lt; (n); i ++)
for (int j = 0; j & lt; (n); j ++)
{
if (j + i & gt; j + j) {i = 0;} // this part does not work
CIN & GT; & GT; MAT [j + i] [j];
}
}
```

## Answer 1

It is possible without the functions of zeroing the array and its output.

```
# include & lt; iostream & gt;
Using Namespace STD;
// Control of the exit index for the size of the array
INT ControlIndex (Int MatrixIndex, Uint Sizematrix)
{
if (MatrixIndex & GT; = SizeMatrix)
{
Return 0;
}
ELSE.
{
// that is, do nothing with the index
RETURN MATRIXINDEX;
}
}
// show the matrix
Void ShowMatrix (Int ** Matrix, Int SizeMatrix)
{
for (int i = 0; i & lt; sizematrix; i ++)
{
for (int j = 0; j & lt; sizematrix; j ++)
{
COUT & LT; & LT; Matrix [i] [J];
}
COUT & LT; & LT; Endl;
}
}
// Fill the matrix by zeros
Void Fillmatrix (Int ** Matrix, Int SizeMatrix)
{
for (int i = 0; i & lt; sizematrix; i ++)
{
for (int j = 0; j & lt; sizematrix; j ++)
{
Matrix [i] [j] = 0;
}
}
}
INT MAIN ()
{
// variable corrective row transition, in case of an array size
int rowcorrection = 0;
UINT SIZE;
COUT & LT; & LT; "Size:";
CIN & GT; & GT; Size;
// Select the memory of the array of two-dimensional
int ** matrix = new int * [size];
// Select the memory to each one-dimensional array of two-dimensional array
for (int i = 0; i & lt; size; i ++)
{
Matrix [i] = New int [Size];
}
// immediately fill the matrix with zeros and show its initial state
Fillmatrix (Matrix, Size);
ShowMatrix (Matrix, Size);
for (int i = 0; i & lt; size; i ++)
{
For (int j = 0; j & lt; Size; j ++)
{
// Input of the number diagonally
// If the index & gt; = Size, then the string becomes 0 and each
// Iteration increases by 1
// and the columns independently continue to increase
CIN & GT; & GT; Matrix [ControlIndex (J + I, Size) + RowCorrection] [J];
if (J + I & GT; = Size)
{
// Due to this, our lines index continues to increase
// Even after it is zeroing after the size of the array
RowCorrection ++;
}
// remove the matrix every time after entering the number
ShowMatrix (Matrix, Size);
COUT & LT; & LT; Endl;
}
// After entering the diagonal, reset the correction
rowcorrection = 0;
}
ShowMatrix (Matrix, Size);
getchar ();
Return 0;
}
```