1

I've got two algorithms converting random 2d arrays (m х n or m х m) to 1d array. I'm wondering if there is a way to make them work als in the opposite direction and convert the result to 1d array saving the order of numbers. Here is the full code of my program and a picture to see how both of my algorithms work.enter image description here Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using static System.Math;


namespace MyProgram
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Console.Write("Enter number of rows:");
            int n = int.Parse(Console.ReadLine());
            Console.Write("Enter number of columns:");
            int m = int.Parse(Console.ReadLine());
            int[] arr1 = new int[n * m];
            int[,] arr2 = new int[n, m];
            int choice; 
            do
            {
                Console.WriteLine("Select option:");
                Console.WriteLine("\t1: Diagonal");
                Console.WriteLine("\t2: Spiral");
                Console.WriteLine("\t3: Exit");
                Console.Write("Your selection: ");
                choice = int.Parse(Console.ReadLine());
                switch (choice)
                {
                    case 1:
                        {
                            SetArray(arr2);
                            PrintArray(arr2);
                            Diagonal(arr2, arr1); 
                            PrintArray(arr1);
                            break;
                        }
                    case 2:
                        {
                            SetArray(arr2);
                            PrintArray(arr2);
                            Spiral(arr2, arr1);
                            PrintArray(arr1);
                            break;
                        }
                }
                Console.WriteLine();
                Console.WriteLine();
            } while (choice != 5);
        }
           static void Diagonal(int[,] array2, int[] array1)
        {
            int k = 0;
            int row = 0;
            int col = 0;
            while (k < array1.Length)
            {

                array1[k] = array2[row, col];
                if ((row + col) % 2 == 0)
                {
                    if ((row == 0) && (col != array2.GetLength(1) - 1)) { col++; }
                    else
                    {
                        if (col == array2.GetLength(1) - 1) { row++; }
                        else { row--; col++; }
                    }
                }
                else
                {
                    if ((col == 0) && (row != array2.GetLength(0) - 1)) { row++; }
                    else
                    {
                        if (row == array2.GetLength(0) - 1) { col++; }
                        else { row++; col--; }
                    }

                }
                k += 1;
            }
        }

        private static void Spiral(int[,] array2, int[] array1)
        {
            int lengthX = array2.GetLength(0);
            int lengthY = array2.GetLength(1);
            int Product = lengthX * lengthY;
            int CorrectY = 0;
            int CorrectX = 0;
            int Count = 0;
            while (lengthX > 0 && lengthY > 0)
            {
                for (int j = CorrectY; j < lengthY && Count < Product; j++)
                {
                    array1[Count] = array2[CorrectX, j];
                    Count++ ;
                }
                CorrectX++;
                for (int i = CorrectX; i < lengthX && Count < Product; i++)
                {
                    array1[Count] = array2[i, lengthY - 1];
                    Count++ ;
                }
                if (lengthY > 0 && lengthX > 0) lengthY-- ;
                else break;
                for (int j = lengthY - 1; j >= CorrectY && Count < Product; j--)
                {
                    array1[Count] = array2[lengthX - 1, j];
                    Count++ ;
                }
                if (lengthY > 0 && lengthX > 0) lengthX-- ;
                else break;
                for (int i = lengthX - 1; i >= CorrectX && Count < Product; i--)
                {
                    array1[Count] = array2[i, CorrectY];
                    Count++ ;
                }

                CorrectY++;
            }

        }

        public static void SetArray(int[,] arr)
        {
            Random r = new Random();
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    arr[i, j] = r.Next(11, 99);
                }
            }
        }

        public static void SetArray(int[] arr)
        {
            Random r = new Random();
            for (int i = 0; i < arr.Length; i++)
            {

                arr[i] = r.Next(11, 99);

            }
        }

        public static void PrintArray(int[] arr)
        {
            Console.Write("print 1d array:");
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i] + " ");
            }
            Console.WriteLine();
        }

       public static void PrintArray(int[,] arr)
        {
            Console.WriteLine("print 2d array:");
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    Console.Write(arr[i, j] + " ");
                }
                Console.WriteLine();
            }
        } 
    }
}
4
  • By "make them work in the opposite direction" do you mean take a 1d array and turn it into a two dimensional array via diagonal, spiral, etc. methods? Commented Dec 8, 2016 at 18:27
  • @Alessandro Scarlatti Yes, take the result (1D array) and convert it back into 2D array (in my picture arrays for both method are the same).
    – user7269046
    Commented Dec 8, 2016 at 18:30
  • You should be able to pretty simply reverse the logic of the spiral and diagonal methods. Are you wanting to see specifically how to do this, or are you asking something else? Commented Dec 8, 2016 at 18:32
  • @Alessandro Scarlatti i just don't get how to apply that logic for 1D array. I know number of cols and rows but I don't understand how to fill them correctly.
    – user7269046
    Commented Dec 8, 2016 at 18:38

2 Answers 2

1

Actually what you are asking is quite easy. Just change your algorithm methods to receive int rows, int cols and delegate like this

delegate void Apply(int row, int col, int index);

Then replace arr2.GetLength(0) with rows, arr2.GetLength(1) with cols, and array element assignments with delegate call.

Here is the updated Diagonal method (you can do the same with the other):

static void Diagonal(int rows, int cols, Apply action)
{
    int k = 0;
    int row = 0;
    int col = 0;
    int length = rows * cols;
    while (k < length)
    {
        action(row, col, k);
        if ((row + col) % 2 == 0)
        {
            if ((row == 0) && (col != cols - 1)) { col++; }
            else
            {
                if (col == cols - 1) { row++; }
                else { row--; col++; }
            }
        }
        else
        {
            if ((col == 0) && (row != rows - 1)) { row++; }
            else
            {
                if (row == rows - 1) { col++; }
                else { row++; col--; }
            }
        }
        k += 1;
    }
}

and the usage:

SetArray(arr2);
PrintArray(arr2);
Diagonal(n, m, (r, c, i) => arr1[i] = arr2[r, c]);
PrintArray(arr1);
// Inverse
var arr3 = new int[n, m];
Diagonal(n, m, (r, c, i) => arr3[r, c] = arr1[i]);
PrintArray(arr3);
1
1

This seems to be working for me for backward Diagonal:

static void BackwardDiagonal(int[,] array2, int[] array1) {

    int k = 0;
    int row = 0;
    int col = 0;
    while (k < array1.Length) {
        array2[row, col] = array1[k];  // just swap sides of the assignment...
        if ((row + col) % 2 == 0) {
            if ((row == 0) && (col != array2.GetLength(1) - 1)) { col++; } else {
                if (col == array2.GetLength(1) - 1) { row++; } else { row--; col++; }
            }
        } else {
            if ((col == 0) && (row != array2.GetLength(0) - 1)) { row++; } else {
                if (row == array2.GetLength(0) - 1) { col++; } else { row++; col--; }
            }
        }
        k += 1;
    }
}

For backward Spiral:

private static void BackwardSpiral(int[,] array2, int[] array1)
{
    int lengthX = array2.GetLength(0);
    int lengthY = array2.GetLength(1);
    int Product = lengthX * lengthY;
    int CorrectY = 0;
    int CorrectX = 0;
    int Count = 0;
    while (lengthX > 0 && lengthY > 0)
    {
        for (int j = CorrectY; j < lengthY && Count < Product; j++)
        {
            array2[CorrectX, j] = array1[Count];  // just swap sides of the assignment...
            Count++ ;
        }
        CorrectX++;
        for (int i = CorrectX; i < lengthX && Count < Product; i++)
        {
            array2[i, lengthY - 1] = array1[Count];
            Count++ ;
        }
        if (lengthY > 0 && lengthX > 0) lengthY-- ;
        else break;
        for (int j = lengthY - 1; j >= CorrectY && Count < Product; j--)
        {
            array2[lengthX - 1, j] = array1[Count];
            Count++ ;
        }
        if (lengthY > 0 && lengthX > 0) lengthX-- ;
        else break;
        for (int i = lengthX - 1; i >= CorrectX && Count < Product; i--)
        {
            array2[i, CorrectY] = array1[Count];
            Count++ ;
        }

        CorrectY++;
    }
}

I also added this to the switch statement to implement it:

case 4: 
    {
        SetArray(arr2);
        PrintArray(arr2);
        Diagonal(arr2, arr1);
        PrintArray(arr1);
        int[,] arr3 = new int[n, m];  // new blank array to fill with arr1
        BackwardDiagonal(arr3, arr1);  // fill arr3 from backward Diagonal algorithm
        PrintArray(arr3);
        break;
    }
case 5: 
    {
        SetArray(arr2);
        PrintArray(arr2);
        Spiral(arr2, arr1);
        PrintArray(arr1);
        int[,] arr3 = new int[n, m];  // new blank array to fill with arr1
        BackwardSpiral(arr3, arr1);  // fill arr3 from backward Spiral algorithm
        PrintArray(arr3);
        break;
    }

While you're at it, also make sure to have } while (choice != 3); at the end of your do loop so that you can exit the program!

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.