On Jun 14, 12:16 pm, csfon...@gmail.com wrote:

Hi,

Maybe:

string s[] = new string[arr1.Length*arr2.Length*arr3.Length];

for( int i=0; i<arr1.Length; ++i )
for( int j=0; j<arr1.Length; ++j )
 for( int k=0; k<arr1.Length; ++k )
  s[i+j+k] = String.Concat(s[i], s[j], s[k]);

Hope this helps.
Moty

  Three nested "for" loops shoud give the result that you want:

string[] arr_result = new string[arr1.Length+arr2.Length+arr3.Length];
int i=0;
foreach (string s1 in arr1)
 foreach (strng s2 in arr2)
   foreach (string s3 in arr3)
     arr_result[i++]=s1+s2+s3;

You want the Cartesian product of the three arrays.  For a solution that
does not depend on nested loops (works for any number of arrays), see
http://www.frontiernet.net/~fredm/dps/chapter02.doc .  The code works with
Lists, but you could convert it to work with arrays (or convert your arrays
to Lists).

The code to take the Cartesian product will take any list of lists and
return each combination via a "foreach" iterator.  So, your calling code
would be something like:

   List<List<string>> myArrays;     //convert your arrays to lists, put
them here

 Cartesian<List<string>>answer =
                    new Cartesian<List<string>>(myArrays);

        foreach (List<string> vector in answer.cartesian())
        {
                 //do something with the vector

        }

The code to make the CP is included in the library mentioned in the book.
It is:

namespace Search
{

   public class Cartesian<T>
   {
       List<List<T>> toCross;
       int[] vector;
       public int totalElements = 1;

       public Cartesian(List<List<T>> list)
       {

           toCross = list;

           vector = new int[toCross.Count];

           foreach (List<T> aList in list)
               totalElements *= aList.Count;
       }

       public IEnumerable<List<T>> cartesian()
       {
           reset();
           while (true)
           {
               yield return makeList();
               int startAt = toCross.Count - 1;
               while (vector[startAt] == toCross[startAt].Count - 1)
               {
                   vector[startAt] = 0;
                   startAt--;
                   if (startAt < 0)
                       break;
               }
               if (startAt < 0)
                   break;

               vector[startAt]++;
           }
       }

       List<T> makeList()
       {
           List<T> ans = new List<T>
               (toCross.Count);

           for (int k = 0; k < vector.Length; k++)
           {
               ans.Add((toCross[k])[vector[k]]);
           }
           return ans;
       }

       public void reset()
       {
           for (int i = 0; i < toCross.Count; i++)
           {
               vector[i] = 0;
           }
       }
   }
}

This  sounds like homework :)