<div>
It looks like you want them with no repetitions, but does order matter? &nbsp;So you want both &quot;BE&quot; and &quot;EB&quot;?
</div>


<div>
One way is to use the libaray here written by Adrian Akison:<br />
<a href="http://www.codeproject.com/KB/recipes/Combinatorics.aspx" rel="ugc">http://www.codeproject.com/KB/recipes/Combinatorics.aspx</a><br />
<br />
You would want &quot;variations without repetition&quot;.<br />
Click on Project --&gt; Add Reference --&gt; Browse --&gt; Facet.Combinatorics.dll<br />
Next, you create instances of Variations, passing in the set of letters, and the number of characters to choose.<br />
<br />
Here is what it could look like: &nbsp;
<pre><code class="code-10 nolinks" id="code-8225611"><span>Public Class Form1</span>
<span></span>
<span>    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click</span>
<span>        ListBox1.DataSource = Variations(TextBox1.Text)</span>
<span>    End Sub</span>
<span></span>
<span>    Private Function Variations(ByVal input As String) As List(Of String)</span>
<span>        Dim values As New List(Of String)</span>
<span>        For i As Integer = 0 To input.Length - 1</span>
<span>            values.Add(input.Substring(i, 1))</span>
<span>        Next</span>
<span></span>
<span>        Dim results As New List(Of String)</span>
<span>        For i As Integer = 1 To input.Length</span>
<span>            Dim vars As New Facet.Combinatorics.Variations(Of String)(values.AsReadOnly(), i)</span>
<span>            For Each variation As IList(Of String) In vars</span>
<span>                results.Add(String.Join(&quot;&quot;, variation))</span>
<span>            Next</span>
<span>        Next</span>
<span>            Return results</span>
<span>    End Function</span>
<span></span>
<span>End Class</span>
</code></pre>
<br />
Example using just &quot;ABCD&quot; (as ABCDEFG is A LOT of variations!!!): &nbsp;<a href="https://filedb.experts-exchange.com/incoming/2011/10_w42/510645/Idle-Mind-510645.flv" target="_blank" class="file-inline" title="Variations with No Repetition (214 KB)"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><path d="M67.508 468.467c-58.005-58.013-58.016-151.92 0-209.943l225.011-225.04c44.643-44.645 117.279-44.645 161.92 0 44.743 44.749 44.753 117.186 0 161.944l-189.465 189.49c-31.41 31.413-82.518 31.412-113.926.001-31.479-31.482-31.49-82.453 0-113.944L311.51 110.491c4.687-4.687 12.286-4.687 16.972 0l16.967 16.971c4.685 4.686 4.685 12.283 0 16.969L184.983 304.917c-12.724 12.724-12.73 33.328 0 46.058 12.696 12.697 33.356 12.699 46.054-.001l189.465-189.489c25.987-25.989 25.994-68.06.001-94.056-25.931-25.934-68.119-25.932-94.049 0l-225.01 225.039c-39.249 39.252-39.258 102.795-.001 142.057 39.285 39.29 102.885 39.287 142.162-.028A739446.174 739446.174 0 0 1 439.497 238.49c4.686-4.687 12.282-4.684 16.969.004l16.967 16.971c4.685 4.686 4.689 12.279.004 16.965a755654.128 755654.128 0 0 0-195.881 195.996c-58.034 58.092-152.004 58.093-210.048.041z"/></svg>Idle-Mind-510645.flv</a>
</div>


Idle-Mind-510645.flv

<div>
If you want to see them sorted then: <br />

<pre><code class="code-10 nolinks" id="code-8225612"><span>Public Class Form1</span>
<span></span>
<span>    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click</span>
<span>        Dim results As List(Of String) = Variations(TextBox1.Text)</span>
<span>        results.Sort(AddressOf VariationComparer)</span>
<span>        ListBox1.DataSource = results</span>
<span>    End Sub</span>
<span></span>
<span>    Private Function VariationComparer(ByVal var1 As String, ByVal var2 As String) As Integer</span>
<span>        Dim result As Integer = var1.Length.CompareTo(var2.Length)</span>
<span>        If result = 0 Then</span>
<span>            result = var1.CompareTo(var2)</span>
<span>        End If</span>
<span>        Return result</span>
<span>    End Function</span>
<span></span>
<span>    Private Function Variations(ByVal input As String) As List(Of String)</span>
<span>        Dim values As New List(Of String)</span>
<span>        For i As Integer = 0 To input.Length - 1</span>
<span>            values.Add(input.Substring(i, 1))</span>
<span>        Next</span>
<span></span>
<span>        Dim results As New List(Of String)</span>
<span>        For i As Integer = 1 To input.Length</span>
<span>            Dim vars As New Facet.Combinatorics.Variations(Of String)(values.AsReadOnly(), i)</span>
<span>            For Each variation As IList(Of String) In vars</span>
<span>                results.Add(String.Join(&quot;&quot;, variation))</span>
<span>            Next</span>
<span>        Next</span>
<span>            Return results</span>
<span>    End Function</span>
<span></span>
<span>End Class</span>
</code></pre>
</div>


<div>
I believe that is something similar to what I am looking for. &nbsp;Basically I need all the combinations because I am looking for valid words that can be compared against a dictionary. &nbsp;
</div>


<div>
That'll produce them all...give it a shot.<br />
<br />
There are other ways to approach the problem if you are looking for words in a dictionary though.<br />
<br />
The brute force approach produces all possible combos and checks every single one to see if it is a valid word.<br />
<br />
...but if you already know that no words start with &quot;zq&quot;, then why produce more combos that start with that? zqa, zqb, zqc, etc...<br />
<br />
A different approach would produce a DAWG (directed acyclic word graph) from the valid words dictionary and then use a recursive graph traversal based on a connected graph of the letters of the input to build the words. &nbsp;By checking the DAWG to see if any valid words begin with the current &quot;prefix&quot; you can cut a large number of permutations that can't possibly make a valid word...thus cutting down the generation time significantly. &nbsp;This approach is often used in &quot;Boggle&quot; type word games.<br />
<br />

</div>


<div>
I was kind of afraid of getting every permutation because that could cause a great deal of processor usage and time to complete the task. &nbsp;<br />
<br />
So using the DAWG method I would take the list of words and create a graph and then search the graph? &nbsp;There are about ~270,000 words in the acceptable words list I am using. &nbsp;This approach seems to have the least overhead. &nbsp;
</div>


<div>
For a DAWG, basically you take your dictionary of valid words and build up a graph that shows which letters connect to other letters in a valid word. *I won't lie, this is a complicated approach!*<br />
<br />
<b>Without optimization, though, a DAWG consumes a huge amount of memory.</b><br />
We trade memory for speed with this approach...<br />
<br />
Simplified, consider this small list of valid words: ace, act, are, art<br />
<br />
Starting with &quot;ace&quot;...<br />
Build a node with &quot;a&quot;.<br />
Connected to that is a node with &quot;c&quot;.<br />
Connected to &quot;c&quot; is a node with &quot;e&quot;:<br />
<br />
&nbsp; &nbsp; a ---&gt; c ---&gt; e<br />
<br />
Next we process &quot;act&quot;.<br />
We already have a node with &quot;a&quot;.<br />
We already have a node with &quot;c&quot; connected to &quot;a&quot;.<br />
Add a node connected to &quot;c&quot; that has &quot;t&quot;:<br />
<br />
&nbsp; &nbsp; a ---&gt; c +--&gt; e<br />
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;|<br />
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;\--&gt; t<br />
<br />
Following the same procedure for &quot;are&quot; and &quot;art&quot;, we end up with a DAWG that looks like this:<br />
<br />
<br />
&nbsp; &nbsp; a +--&gt; c +--&gt; e<br />
&nbsp; &nbsp; &nbsp; &nbsp; | &nbsp; &nbsp; &nbsp; &nbsp; |<br />
&nbsp; &nbsp; &nbsp; &nbsp; | &nbsp; &nbsp; &nbsp; &nbsp; \--&gt; t<br />
&nbsp; &nbsp; &nbsp; &nbsp; |<br />
&nbsp; &nbsp; &nbsp; &nbsp; \--&gt; r +--&gt; e<br />
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; \--&gt; t<br />
<br />
Now, given the input &quot;acert&quot;, we build up another graph that connects every letter to every other letter and start recursively following the paths (starting with each letter as a start point). &nbsp;At each node, we look at the word built up thus far and ask the DAWG if any valid words start with that &quot;prefix&quot;. &nbsp;Since only words beginning with the letter &quot;a&quot; are in the DAWG, everything beginning with any other letter would immediately be rejected and those combinations wouldn't even be generated.<br />
<br />
*Suffixes are a huge source of inefficiency. &nbsp;Consider suffixes such as &quot;ed&quot;, &quot;er&quot; and &quot;ing&quot; which can be attached to a huge number of words! &nbsp;Without optimization, those suffix combinations would be duplicated for every single word that it was valid for. &nbsp;So one optimization is to build common suffixes once and then make a prefix point to the existing suffix so that it isn't duplicated.<br />
<br />
I have a <b>huge</b> personal project that can show valid words in a Boggle type board. &nbsp;Let me know if you would like to see some code...
</div>


<div>
Here's a quick demo of what that app does...it basically animates the recursive tree traversal and changes the colors to show when it rejects a prefix, finds a valid prefix, and finds a valid word (adding it to the list at the right). &nbsp;Without the animation part enabled, the valid words populate near instantaneously. &nbsp;This can literally be seen as I type the board in at the beginning: <br />
<a href="https://filedb.experts-exchange.com/incoming/2011/10_w42/510654/Idle-Mind-510654.flv" target="_blank" class="file-inline" title="DAWG + Boggle = Cool Animation (8.7 MB)"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><path d="M67.508 468.467c-58.005-58.013-58.016-151.92 0-209.943l225.011-225.04c44.643-44.645 117.279-44.645 161.92 0 44.743 44.749 44.753 117.186 0 161.944l-189.465 189.49c-31.41 31.413-82.518 31.412-113.926.001-31.479-31.482-31.49-82.453 0-113.944L311.51 110.491c4.687-4.687 12.286-4.687 16.972 0l16.967 16.971c4.685 4.686 4.685 12.283 0 16.969L184.983 304.917c-12.724 12.724-12.73 33.328 0 46.058 12.696 12.697 33.356 12.699 46.054-.001l189.465-189.489c25.987-25.989 25.994-68.06.001-94.056-25.931-25.934-68.119-25.932-94.049 0l-225.01 225.039c-39.249 39.252-39.258 102.795-.001 142.057 39.285 39.29 102.885 39.287 142.162-.028A739446.174 739446.174 0 0 1 439.497 238.49c4.686-4.687 12.282-4.684 16.969.004l16.967 16.971c4.685 4.686 4.689 12.279.004 16.965a755654.128 755654.128 0 0 0-195.881 195.996c-58.034 58.092-152.004 58.093-210.048.041z"/></svg>Idle-Mind-510654.flv</a>
</div>


Idle-Mind-510654.flv

<div>
How's this project going monica? &nbsp;Let me know if you need help tweaking the code I already posted, or if you want to see some code dealing with the DAWG approach.
</div>


<div>
Hello, I was trying out some different things but the DAWG approach sounds like the way I think i would like to go. &nbsp;So yes I would love to see some code for DAWG. &nbsp;
</div>


<div>
Alrighty...I'll try to post a stripped down example tomorrow.
</div>


ospd4-lwl.txt

<div>
Thanks your example is excellent and easy to follow. &nbsp;It has been very difficult to find examples of DAWGs that I understand. &nbsp; I want to understand how the algorithm works not just copy someone else's work. &nbsp; 
</div>


<div>
Ask any questions you might have about the code and I'll do my best to explain it. &nbsp;=)
</div>


<div>
One last question, Using this method with the DAWG I still need to have the permutation of all the letters that I select and then pass them in one by one in the hasword function? &nbsp;
</div>


<div>
The Word class makes a Graph from the input letters and connects each letter to every other letter. &nbsp;Then it uses a simple recursive algorithm to produce all the permutations. &nbsp;Without the DAWG, we would produce all combinations and check every single one for a valid word combination. &nbsp;In that scenario you could use a HashTable instead of a DAWG for word validation.<br />
<br />
<b>With the DAWG, though, we do NOT produce all possible permutations.</b> &nbsp;The magic happens in the Visit() method at lines #101 thru #103:<br />
<br />
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; If Not OtherLetter.Visited AndAlso <b>T.HasBeginning(Word &amp;&nbsp;OtherLetter.Value)</b> Then<br />
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; OtherLetter.Visit(Word, T, Words, MinLength)<br />
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; End If<br />
<br />
Here, using the HasBeginning() function, we only recurse to the next available letter if adding it to the current permutation produces a valid word beginning. &nbsp;This eliminates entire branches of the possible permutations from being generated. &nbsp;For instance, if the word &quot;quartz&quot; was passed in, we wouldn't generate any word permutations that start with &quot;qz&quot; or &quot;zq&quot; because the DAWG would report back that no words begin with those combinations. &nbsp;Thus the DAWG reduces the time needed to find all the possible words using a set of letters because the number of permutations actually produced and checked is significantly fewer than simply brute force checking every single permutation.<br />

</div>


<div>
<div class="content wysiwyg-content">
I am trying to figure out a way in VB.NET to take an array of say 7 items and arrange it in all possible combinations. &nbsp;So if I have a Char array or A,B,C,D,E,F,G my goal is to get it to A,C,B,D,E,F,G, A,C,D,BE,F,G etc. &nbsp;Then I would like to store each of these in a new array that lists each new combination. &nbsp;
</div>
</div>


I am trying to figure out a way in VB.NET to take an array of say 7 items and arrange it in all possible combinations.  So if I have a Char array or A,B,C,D,E,F,G my goal is to get it to A,C,B,D,E,F,G, A,C,D,BE,F,G etc.  Then I would like to store each of these in a new array that lists each new combination.  

Need an algorithm to rearrange an arry in all possible combinations in VB.NET

Visual Basic .NET (VB.NET) is an object-oriented programming language implemented on the .NET framework, but also supported on other platforms such as Mono and Silverlight. Microsoft launched VB.NET as the successor to the Visual Basic language. Though it is similar in syntax to  Visual Basic pre-2002, it is not the same technology,