ASP.NET

Getting All Combinations Of An Array Of Elements

In this blog, we will learn, how to get all the combination of the elements in an array.Suppose, we have an integer array "myarrint", as given below.
  1. int[] myarrint = new[] { 1, 2, 3 };    
 We need to get all the combination of elements in an array without repeating it. This will be 1,2,3,12,13,21,23,31,32,123,132,213,231,312,321.

Code:
  1. public int count = 0;    
  2.    protected void Page_Load(object sender, EventArgs e)    
  3.    {    
  4.        int[] myarrint = new[] { 1, 2, 3 };    
  5.        int[] responseint = Getdataint(myarrint);    
  6.        Response.Write(string.Join(",", responseint));    
  7.    }    
  8.     
  9.    public int[] Getdataint(int[] arr)    
  10.    {    
  11.        count = arr.Length;    
  12.        return Combinationint(string.Join("", arr));    
  13.    }    
  14.     
  15.    public int[] Combinationint(string str)    
  16.    {    
  17.        if (string.IsNullOrEmpty(str))    
  18.            throw new ArgumentException("Invalid input");    
  19.        if (str.Length == 1)    
  20.            return new int[] { Convert.ToInt32(str) };    
  21.        char c = str[str.Length - 1];    
  22.        //Recursive process starts here - Since return is an int array, below code will convert it into an string array for further processing    
  23.        string[] returnArray = Array.ConvertAll(Combinationint(str.Substring(0, str.Length - 1)), x => x.ToString());    
  24.        List<string> finalArray = new List<string>();    
  25.        foreach (string s in returnArray)    
  26.            finalArray.Add(s);    
  27.        finalArray.Add(c.ToString());    
  28.        int j = 0;    
  29.        foreach (string s in returnArray)    
  30.        {    
  31.            finalArray.Add(s + c);    
  32.            //If you don't need both 12 and 21 in result comment below line    
  33.            finalArray.Add(c + s);    
  34.        }    
  35.        //If you don't need both 12 and 21 in result comment below region    
  36.        #region sameelements    
  37.        returnArray = finalArray.ToArray();    
  38.        foreach (string s in returnArray)    
  39.        {    
  40.            if (str.Length == count)    
  41.            {    
  42.                if (s.Length < str.Length - 1)    
  43.                {    
  44.                    foreach (char k in str)    
  45.                    {    
  46.                        foreach (char m in str)    
  47.                        {    
  48.                            if (k != m && !s.Contains(k) && !s.Contains(m))    
  49.                            {    
  50.                                finalArray.Add(s + k);    
  51.                                finalArray.Add(s + m + k);    
  52.                                finalArray.Add(m.ToString() + k.ToString());    
  53.                                finalArray.Add(m + s + k);    
  54.                            }    
  55.                        }    
  56.                    }    
  57.                }    
  58.            }    
  59.            j++;    
  60.        }    
  61.        #endregion    
  62.        //Converting the string array to int array    
  63.        int[] retarr = (Array.ConvertAll(finalArray.ToArray(), int.Parse)).Distinct().ToArray();    
  64.        //Sorting array    
  65.        Array.Sort(retarr);    
  66.        return retarr;    
  67.    }    
The response is given below.

Same method can be applied on the string arrays also, with slight changes in the code.
  1. public int count = 0;    
  2.    protected void Page_Load(object sender, EventArgs e)    
  3.    {    
  4.        string[] myarr = new[] { "a", "b", "c" };    
  5.        string[] response = Getdata(myarr);    
  6.        Response.Write(string.Join(",", response));    
  7.    }    
  8.     
  9.    public string[] Getdata(string[] arr)    
  10.    {    
  11.        count = arr.Length;    
  12.        return Combination(string.Join("", arr));    
  13.    }    
  14.     
  15.    public string[] Combination(string str)    
  16.    {    
  17.        if (string.IsNullOrEmpty(str))    
  18.            throw new ArgumentException("Invalid input");    
  19.        if (str.Length == 1)    
  20.            return new string[] { str };    
  21.        char c = str[str.Length - 1];    
  22.        //Recursive process starts here    
  23.        string[] returnArray = Combination(str.Substring(0, str.Length - 1));    
  24.        List<string> finalArray = new List<string>();    
  25.        foreach (string s in returnArray)    
  26.            finalArray.Add(s);    
  27.        finalArray.Add(c.ToString());    
  28.        int j = 0;     
  29.        foreach (string s in returnArray)    
  30.        {    
  31.            finalArray.Add(s + c);    
  32.            //If you don't need both 'ab' and 'ba' in result comment below line    
  33.            finalArray.Add(c + s);    
  34.        }    
  35.        //If you don't need both 'ab' and 'ba' in result comment below region    
  36.        #region sameelements    
  37.        returnArray = finalArray.ToArray();    
  38.        foreach (string s in returnArray)    
  39.        {    
  40.            if (str.Length == count)    
  41.            {    
  42.                if (s.Length < str.Length - 1)    
  43.                {    
  44.                    foreach (char k in str)    
  45.                    {    
  46.                        foreach (char m in str)    
  47.                        {    
  48.                            if (k != m && !s.Contains(k) && !s.Contains(m))    
  49.                            {    
  50.                                finalArray.Add(s + k);    
  51.                                finalArray.Add(s + m + k);    
  52.                                finalArray.Add(m.ToString() + k.ToString());    
  53.                                finalArray.Add(m + s + k);    
  54.                            }    
  55.                        }    
  56.                    }    
  57.                }    
  58.            }    
  59.            j++;    
  60.        }    
  61.        #endregion    
  62.        //Sorting of array    
  63.        Array.Sort(finalArray.ToArray());    
  64.        return finalArray.Distinct().ToArray();    
  65.    }    
The response will is given below.

If we don't need same combination, i.e for 12 and 21, we just need 12 and we can comment out certain codes(marked in red) in the function.
  1. public int[] Combinationint(string str)    
  2.     {    
  3.         if (string.IsNullOrEmpty(str))    
  4.             throw new ArgumentException("Invalid input");    
  5.         if (str.Length == 1)    
  6.             return new int[] { Convert.ToInt32(str) };    
  7.         char c = str[str.Length - 1];    
  8.         //Recursive process starts here - Since return is an int array, below code will convert it into an string array for further processing    
  9.         string[] returnArray = Array.ConvertAll(Combinationint(str.Substring(0, str.Length - 1)), x => x.ToString());    
  10.         List<string> finalArray = new List<string>();    
  11.         foreach (string s in returnArray)    
  12.             finalArray.Add(s);    
  13.         finalArray.Add(c.ToString());    
  14.         int j = 0;    
  15.         foreach (string s in returnArray)    
  16.         {    
  17.             finalArray.Add(s + c);    
  18.             //If you don't need both 12 and 21 in result comment below line    
  19.             //finalArray.Add(c + s);    
  20.         }    
  21.         //If you don't need both 12 and 21 in result comment below region    
  22.         //#region sameelements    
  23.         //returnArray = finalArray.ToArray();    
  24.         //foreach (string s in returnArray)    
  25.         //{    
  26.         //    if (str.Length == count)    
  27.         //    {    
  28.         //        if (s.Length < str.Length - 1)    
  29.         //        {    
  30.         //            foreach (char k in str)    
  31.         //            {    
  32.         //                foreach (char m in str)    
  33.         //                {    
  34.         //                    if (k != m && !s.Contains(k) && !s.Contains(m))    
  35.         //                    {    
  36.         //                        finalArray.Add(s + k);    
  37.         //                        finalArray.Add(s + m + k);    
  38.         //                        finalArray.Add(m.ToString() + k.ToString());    
  39.         //                        finalArray.Add(m + s + k);    
  40.         //                    }    
  41.         //                }    
  42.         //            }    
  43.         //        }    
  44.         //    }    
  45.         //    j++;    
  46.         //}    
  47.         //#endregion    
  48.         //Converting the string array to int array    
  49.         int[] retarr = (Array.ConvertAll(finalArray.ToArray(), int.Parse)).Distinct().ToArray();    
  50.         //Sorting array    
  51.         Array.Sort(retarr);    
  52.         return retarr;    
  53.     }    
The output will be 1,2,3,12,13,23,123

Since this code is using recursion, the performance may be affected for very large arrays. Hope, this will be helpful for someone out there.
 
Ebook Download
View all
Learn
View all
Membership not found