Question

There are these 19 bytes (I am looking for combinations not the number of combinations)

17 00 00 00 A4 EA DB 13 02 00 00 00 00 00 00 A3 D3 02 CC

I need any possible unique combination which matches these “rules”:

• at least 4 bytes long

• the order of the bytes can’t change(so 17 A3 D3 02 CC is ok but A3 D3 02 CC 17 isn’t, because
  in the original string 17 was at the being but A3 D3 02 CC was at the end)

Let me try giving you examples of possible combinations:

17 00 00 00 A4 EA DB 13 02 00 00 00 00 00 00 A3 D3 02

17 00 00 00 A4 EA DB 13 02 00 00 00 00 00 00 A3 D3

17 00 00 00 A4 EA DB 13 02 00 00 00 00 00 00 A3

all the way to
17 00 00 00

17 A3 D3 02 CC

17 00 A3 D3 02 CC

00 A3 D3 02 CC

17 A4 02 CC

See the bytes stay in the same order for example the first byte 17 can only in the first byte’s place

I don’t want combination like

A4 17 02 CC

Because now 17 has changed order compared to A4

Answer 1

I think this is what you are looking for:

Module Module1

    Sub Main()
        Dim bytes() As Byte = {&H17, &H0, &H0, &H0, &HA4, &HEA, &HDB, &H13, &H2, &H0, &H0, &H0, &H0, &H0, &H0, &HA3, &HD3, &H2, &HCC}

        Combine(New Byte() {}, bytes)
    End Sub

    Sub Combine(ByVal sequence() As Byte, ByVal pool() As Byte)
        '   test current sequence
        If Test(sequence) Then
            Console.Write("Found sequence: ")
            For Each b As Byte In sequence
                Console.Write("{0:X2} ", b)
            Next
            Console.WriteLine()
        End If

        '   done if pool is empty
        If pool.Length = 0 Then
            Return
        End If

        '   recurse adding next byte from the pool
        Dim newSequence(sequence.Length) As Byte
        Array.Copy(sequence, newSequence, sequence.Length)
        newSequence(sequence.Length) = pool(0)
        Dim newPool(pool.Length - 2) As Byte
        Array.Copy(pool, 1, newPool, 0, pool.Length - 1)
        Combine(newSequence, newPool)

        '   recurse without adding next byte from the pool
        Combine(sequence, newPool)
    End Sub

    Function Test(ByVal sequence() As Byte) As Boolean
        '   the test function that you haven't provided goes here

        '   this example returns True if the sequence is 4 bytes or more, causing every combination of at least 4 bytes to be printed
        If (sequence.Length >= 4) Then
            Test = True
        Else
            Test = False
        End If
    End Function

End Module

I leave the implementation of the Test function to you as you didn’t provide that in the original question. My implementation basically treats all sequences of 4 bytes or more as passing the test, so it prints all combinations.

I used a recursive algorithm that starts with an empty sequence and all 19 of your bytes in a “pool” of bytes. I then recurse both by moving the first byte of the pool into the sequence I’m building, then by ignoring the first byte of the pool altogether.