How to create different unique combinations from a string?

We'll need to add a bit more code to deal with that. Here's the full program for convenience:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
       Console.Clear();
       string input;
       do
       {
          Console.Write("Please enter a 4 character string : ");
          input = Console.ReadLine();
       }
       while (input.Length != 4);
       List perms = new List();      
       char[] ca = new char[4];

       // generate all 24 permutations
 
       for (int i = 0; i < 4; i++)
       {
           ca[0] = input[i];
           for (int j = 0 ; j < 4; j++)
           {
              if (j == i) continue;
              ca[1] = input[j];
              for (int k = 0; k < 4; k++)
              {
                 if (k == i || k == j) continue;
                 ca[2] = input[k];
                 for (int l = 0; l < 4; l++)
                 {
                     if (l == i || l == j || l == k) continue;
                     ca[3] = input[l];
                     perms.Add(new string(ca));                    
                 }
              }
           }
        }

       // sort them so that duplicates are adjacent to each other
       perms.Sort();
    
       // remove duplicates
       string current = perms[perms.Count -1];

       for (int i = perms.Count - 2; i >= 0; i--)
       {
           if (perms[i] == current)
           {
              perms.RemoveAt(i);
           }
           else
           {
              current = perms[i];
           }

       } 

       // print out unique permutations
       Console.WriteLine("\nThe {0} unique permutation(s) is/are :\n", perms.Count);

       foreach (string perm in perms)
       {
           Console.WriteLine(perm);
       }

       // count how many characters there are of each type
       List chars = new List();
       List totals = new List();
       int index;
       chars.Add(input[0]);
       totals.Add(1);
       for (int i = 1; i < 4; i++)
       {
           index = chars.IndexOf(input[i]);  
           if (index == -1)
           {
               chars.Add(input[i]);
               totals.Add(1); 
           }
           else
           {
               totals[index]++;
           }
       }

       // work out prize winning category
       string[] prizeCats = {"4 Different","2 Same", "2 Pairs", "3 Same", "4 Same"};
       int prizeCatId = 0; // 4 different
       switch(totals.Count)
       {
          case 3: // 2 same
            prizeCatId = 1;
            break;
          case 2:  // 2 pairs or 3 same
            prizeCatId = (totals[0] == 2) ? 2 : 3;
            break;
          case 1: // 4 same
            prizeCatId = 4;
            break;
       } 
      
       // print out analysis
       Console.WriteLine("\nThe character analysis is :\n");

       for(int i = 0; i < chars.Count ; i++)
       {
           Console.WriteLine("{0} occurs {1} time(s)", chars[i], totals[i]);
       }

       Console.WriteLine("\nThe prize category is '{0}'", prizeCats[prizeCatId]);
       Console.ReadKey(); // pause to view console before exit      
   }
  
}

Sure I can.

What we're doing there is generating all possible combinations of the four characters in the string (input) ignoring for the moment that some of them might be the same.

So, we define a character array (ca) to hold each permutation which can then be converted to a string and added to the 'perms' list.

The first element in the array can be any one of the four characters.

The second element can be any one of the three remaining characters.

The third element can be any one of the two remaining characters.

The fourth (and final) element must then be the remaining character, making 4 x 3 x 2 x 1  = 24 permutations in all.

So we define 4 nested for loops each of which range over all 4 characters in the string but, if we've already used a character in a previous loop, we pass on to the next character in the loop (using the 'continue' keyword).

The characters in the string can, of course, be obtained using the indexer i.e. input[0] is the first character and so on.

Incidentally, looking at the code again we could in fact eliminate the step where we mark the duplicates for deletion and just delete them immediately provided we look backwards through the permutations. We can't do this going forwards because when we delete an element, the indices of the following elements all move down one which upsets the logic:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
       Console.Clear();
       string input;
       do
       {
          Console.Write("Please enter a 4 character string : ");
          input = Console.ReadLine();
       }
       while (input.Length != 4);
       List perms = new List();      
       char[] ca = new char[4];

       // generate all 24 permutations
 
       for (int i = 0; i < 4; i++)
       {
           ca[0] = input[i];
           for (int j = 0 ; j < 4; j++)
           {
              if (j == i) continue;
              ca[1] = input[j];
              for (int k = 0; k < 4; k++)
              {
                 if (k == i || k == j) continue;
                 ca[2] = input[k];
                 for (int l = 0; l < 4; l++)
                 {
                     if (l == i || l == j || l == k) continue;
                     ca[3] = input[l];
                     perms.Add(new string(ca));                    
                 }
              }
           }
        }

       // sort them so that duplicates are adjacent to each other
       perms.Sort();
    
       // remove duplicates
       string current = perms[perms.Count -1];

       for (int i = perms.Count - 2; i >= 0; i--)
       {
           if (perms[i] == current)
           {
              perms.RemoveAt(i);
           }
           else
           {
              current = perms[i];
           }

       } 

       // print out unique permutations
       Console.WriteLine("\nThe {0} unique permutation(s) is/are :\n",

perms.Count);

       foreach (string perm in perms)
       {
           Console.WriteLine(perm);
       }
    }
  
}   

There are more sophisticated ways of generating combinations and permutations of a given number of characters using recursion. However, when you only have a small number of characters, the above approach is easier to understand and reasonably efficient. 

Thank you so much, this solution works! Thumbs Up!

Do you mind explaining what this set of code does:

 

for ( int i = 0; i < 4; i++ )
{

   ca [ 0 ] = input [ i ];
   for ( int j = 0; j < 4; j++ )
   {
      if ( j == i ) 
         continue;
      ca [ 1 ] = input [ j ];

      for ( int k = 0; k < 4; k++ )
      {
         if ( k == i || k == j ) 
            continue;
         ca [ 2 ] = input [ k ];

         for ( int l = 0; l < 4; l++ )
         {
            if ( l == i || l == j || l == k ) 
               continue;
            ca [ 3 ] = input [ l ];

            perms.Add ( new string ( ca ) );
         }
      }
   }
}

Try this:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
       Console.Clear();
       string input;
       do
       {
          Console.Write("Please enter a 4 character string : ");
          input = Console.ReadLine();
       }
       while (input.Length != 4);
       List perms = new List();      
       char[] ca = new char[4];

       // generate all 24 permuations
 
       for (int i = 0; i < 4; i++)
       {
           ca[0] = input[i];
           for (int j = 0 ; j < 4; j++)
           {
              if (j == i) continue;
              ca[1] = input[j];
              for (int k = 0; k < 4; k++)
              {
                 if (k == i || k == j) continue;
                 ca[2] = input[k];
                 for (int l = 0; l < 4; l++)
                 {
                     if (l == i || l == j || l == k) continue;
                     ca[3] = input[l];
                     perms.Add(new string(ca));                    
                 }
              }
           }
        }

       // sort them so that duplicates are adjacent to each other
       perms.Sort();
    
       // mark duplicates as null
       string current = perms[0];
       for (int i = 1; i < perms.Count; i++)
       {
           if (perms[i] == current)
           {
              perms[i] = null;
           }
           else
           {
              current = perms[i];
           }
       }

       // remove duplicates
       for (int i = perms.Count - 1; i >= 0; i--)
       {
           if (perms[i] == null) perms.RemoveAt(i);
       } 

       // print out unique permutations
       Console.WriteLine("\nThe {0} unique permutation(s) is/are :\n", perms.Count);

       foreach (string perm in perms)
       {
           Console.WriteLine(perm);
       }
    }
  
}