La responsabilidad de algo (profesional), queda delimitada, por lo que pone en tu contrato, y punto. De hecho si intentas hacer algo más que no está estipulado en tu contrato, es bastante probable que te paren los pies y te recuerden cual es tu puesto.

Lo que los demás quieran poner en tus espaldas, es problema de su imaginación. Tu mochila la define tu contrato.

Guau...
Esto es como decir que si hay un atraco en un banco y un atracador mata a alguien, la culpa es del muerto, por ir al banco...

La culpa SIEMPRE es del delincuente, en segundo lugar, será culpa de la seguridad del banco, y solo en último lugar, ¿los afectados podrían haber hecho mejor las cosas?, tal vez sí, tal vez no.

Continuamos...
El segundo algoritmo, es básicamente un esquema de revólver, exactamente tal y como es un cuentakilómetros.

La idea básica detrás de ello, es que hay un bucle por cada carácter. Y ese bucle se encarga de iterar exclusivamente ese carácter, al final del mismo (o antes de entrar) se pone el valor inicial de nuevo (esto es automático en los bucles for, ya que en ellos se declara explícitamente dichos valores de inicio y fin).
En cada bucle, por tanto se establece el valor actual en la posición que ocupa en el término permutado.
Cuando se alcanza el bucle interior, en cada iteración de éste, se obtiene ya la permutación completa.

La ventaja de este algoritmo (genérico), sobre el declarado en el mensaje previo, es que no requiere con cada permutación generar cada vez todos sus caracteres. La forma más clara de visualizar este algorimo, se refleja en un cuentakilómetros...

De este algoritmo expondré tres variaciones, la primera basada en un bucle for.
- La ventaja de éste algoritmo sobre el anterior es la velocidad gracias a evitar, la continua generación de caracteres que no cambia en la siguiente iteración.
- Su desventaja (como bucle for), la dificultad de establecer el punto inicial desde el que comenzar si no es, el comienzo de la permutación. Las variantes posteirores para este algoritmo solventan este problema.

Ahora ya vayamos con el código, para el mismo se ha provisto también una ventana y una clase que realiza el trabajo. Si bien la ventana será la misma para las tres variantes del algoritmo.

Aquí una vista de la interfaz, muy sencilla y el resultado tras la ejecución.


El código de la interfaz, es bien sencillo, básicamente se instancia la clase, y se invoca el método enumerar con los parámetros que aparecen en los textos. En esta versión, no se usa el valor de estado inicial, o dicho de otra manera, el valor de comienzo está fijado al comienzo de la iteración.

Public Class frm2 ' la ventana, formulario
    Private buc As New cBucAni ' instancia a la clase usada
 
    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
        Dim Min() As Byte, Max() As Byte
        Dim z As Decimal
 
        Min = StringToByteArray(TextBox2.Text)  ' Valor mínimo: Ejemplo: "AAAAZ"
        Max = StringToByteArray(TextBox3.Text)  ' Valor final, Ejemplo: "ZWZZA
 
        z = buc.EnumerarFor(Min, Max)
    End Sub
 
    Private Function StringToByteArray(ByRef Txt As String) As Byte()
        Return System.Text.Encoding.Unicode.GetBytes(Txt)
    End Function
End Class
 

- El código, primero se crea una instancia de la clase (llamada: "cBucAni", son bucles anidados, no me he complicado con el nombre).
- Luego el código del botón. Primero llama a una función para obtener los bytes (2 bytes por carácter) respectivos a los textos de límite de la enumeración. Luego invoca el método enumerar.
- La función devuelve la cantidad de permutaciones (aunque luego no usamos ese valor para nada). El tipo de datos Decimal, es un tipo de 96bits, + 1 bit de signo... Puede ponerse un tipo de bytes (64bits), después de todo, no es estrictamente necesario devolver la cantidad de permutaciones.

Vayamos con el código de la clase para esta variante del algortimo-B:

Public Class cBucAni
 
 
    Public Function EnumerarFor(ByRef sMin() As Byte, ByRef sMax() As Byte) As Decimal
        Dim a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p As short  ' 16bits con signo
        Dim Max(0 To 15) As Short
        Dim Min(0 To 15) As Short
        Dim Inc(0 To 15) As Short
        Dim SizeClave As Short  ' Tamaño de las claves (cantidad de caracteres que contienen)
        Dim ClavePermutada() As Byte  ' Clave generada en bytes.
 
        Dim t As Byte
        Dim z As Decimal, Crono As Single
        Dim txt As String
 
        Crono = TimeOfDay.Ticks ' ticks desde medianoche hasta la hora actual
 
        z = CalcularNumPermutaciones(sMin, sMax)
        If (z < 0) Then
            Return -1
            Exit Function
        Else
            SizeClave = sMin.Length
            ReDim ClavePermutada(0 To SizeClave - 1)
 
            For t = 0 To (SizeClave - 2) Step 2
                Max(n) = sMax(t)
                Min(n) = sMin(t)
                n += 1
            Next
            For t = 0 To n - 1 '((SizeClave \ 2) - 2)
                If (Max(t) > Min(t)) Then
                    Inc(t) = 1
                ElseIf (Max(t) < Min(t)) Then
                    Inc(t) = -1
                End If
            Next
 
            For t = n To 15 'SizeClave To 15
                Inc(t) = 256
                Min(t) = -1
                Max(t) = -1
            Next
 
        End If
 
        For p = Min(15) To Max(15) Step Inc(15)
            If (p >= 0) Then
                ClavePermutada(30) = p
            End If
            For o = Min(14) To Max(14) Step Inc(14)
                If (o >= 0) Then
                    ClavePermutada(28) = o
                End If
                For n = Min(13) To Max(13) Step Inc(13)
                    If (n >= 0) Then
                        ClavePermutada(26) = n
                    End If
                    For m = Min(12) To Max(12) Step Inc(12)
                        If (m >= 0) Then
                            ClavePermutada(24) = m
                        End If
                        For l = Min(11) To Max(11) Step Inc(11)
                            If (l >= 0) Then
                                ClavePermutada(22) = l
                            End If
                            For k = Min(10) To Max(10) Step Inc(10)
                                If (k >= 0) Then
                                    ClavePermutada(20) = k
                                End If
                                For j = Min(9) To Max(9) Step Inc(9)
                                    If (j >= 0) Then
                                        ClavePermutada(18) = j
                                    End If
                                    For i = Min(8) To Max(8) Step Inc(8)
                                        If (i >= 0) Then
                                            ClavePermutada(16) = i
                                        End If
                                        For h = Min(7) To Max(7) Step Inc(7)
                                            If (h >= 0) Then
                                                ClavePermutada(14) = h
                                            End If
                                            For g = Min(6) To Max(6) Step Inc(6)
                                                If (g >= 0) Then
                                                    ClavePermutada(12) = g
                                                End If
                                                For f = Min(5) To Max(5) Step Inc(5)
                                                    If (f >= 0) Then
                                                        ClavePermutada(10) = f
                                                    End If
                                                    For e = Min(4) To Max(4) Step Inc(4)
                                                        If (e >= 0) Then
                                                            ClavePermutada(8) = e
                                                        End If
                                                        For d = Min(3) To Max(3) Step Inc(3)
                                                            If (d >= 0) Then
                                                                ClavePermutada(6) = d
                                                            End If
                                                            For c = Min(2) To Max(2) Step Inc(2)
                                                                If (c >= 0) Then
                                                                    ClavePermutada(4) = c
                                                                End If
                                                                For b = Min(1) To Max(1) Step Inc(1)
                                                                    If (b >= 0) Then
                                                                        ClavePermutada(2) = b
                                                                    End If
 
                                                                    For a = Min(0) To Max(0) Step Inc(0)
                                                                        ClavePermutada(0) = a
                                                                        ' Usar Permutación desde aquí:
                                                                        'txt = System.Text.Encoding.Unicode.GetString(ClavePermutada)
                                                                        ' call FuncionX(ClavePermutada)
                                                                    Next
                                                                Next
                                                            Next
                                                        Next
                                                    Next
                                                Next
                                            Next
                                        Next
                                    Next
                                Next
                            Next
                        Next
                    Next
                Next
            Next
        Next
 
 
        ' Devolver resultados        
        Crono = ((TimeOfDay.Ticks - Crono) / 10000000)  ' ticks hasta la hora actual, menos los de comienzo= ticks invertidos en la tarea.
        txt = System.Text.Encoding.Unicode.GetString(ClavePermutada)
        MessageBox.Show("Tiempo: " & Crono.ToString & vbCrLf & "Permutaciones: " & z.ToString & vbCrLf & "Ultima clave Permutada: " & txt)
        Return z
    End Function
 
 ' ....
End Class
 

Como se ve la clase contiene exclusivamente un metodo (EnumerarFor), que admite dos parámetros. El comienzo de la iteración para cada carácter y el final de iteración para cada carácter.
Una particularidad extra de este algoritmo (en las 3 variantes), es que se ha modificado la forma del alfabeto que utiliza (ya vimos en el algoritmo previo diferentes formas de expresar un alfabeto). Con sólo esos dos parámetros, en realidad estamos definiendo un alfabeto exclusivo para cada carácter, además de dejar claro, el largo de las claves que se van a generar (tan largas como caracteres tienen ambos parámetros. De hecho es requisito que ambos parámetros sean igual de largos.
Esto hace popsible que si deseamos generar claves en la forma:
  AAAA-000-xx:QQQQ
  ZZZZ-999-pp:DDDD
Puede entenderse que para los 4 primeros caracteres (a la izquierda), el rango del alfabeto está en: A-Z, luego viene un guión fijo, los dos siguientes caracteres fijan su alfabeto al rango x-p, el siguiente carácter está fijo al carácter ":" y los 4 últimos caracteres usan un alfabeto en el rango Q-D (nótese que es decreciente)...

Partiendo de esta funcionalidad, es fácil deducir, otra donde delimitamos la entrada de un texto circunscrito a determinado rango de valores, para cada carácter y declaramos no válidos el resto.

Esto facilita enormemente la definición de alfabetos para cada carácter, al no exigir explicítamente un array por cada carácter, y en cuanto al código, implementar esto en el algoritmo, del mensaje previo (el definido como algoritmo A), sería complejo y la cantidad de comparaciones para delimitarlo, lo harían extremadamente lento, en éste en cambio, no existe penalización alguna (salvo una verificación inicial prácticamente sin coste en realción al tiempo empleado en la enumeración) ni exige arrays de alfabetos...
Eso sí, la definición de este alfabeto, establece el orden ASCII, es decir si definimos un inicion y fin como:
   00000000
   ZZZZZZZ
En realidad estamos definiendo un rango entre los caracteres ASCII '0' y 'Z', no del 0-9 y A-Z... y justamente se suceden en el orden en que aparecen en el ASCII... si no fuera el caso, sería necesario un Array que defina los caracteres y el orden que ocupan (o varios si cada carácter tuviera su propia evolución).

- Tras acceder a la enumeración, lo primero es contar las permutaciones resultantes, y una verificación de validez de los parámetros. Para ello se invoca una función que está en un módulo privado del proyecto pero común a todo el proyecto. Se explica más abajo dicha función, aquí baste decir que si los parámetros no son consecuentes, devuelve un valor negativo que fuerza la salida de la función y que debe interpretarse como error...

- Luego se genera un array de bytes (2  por cada carácter) del mismo tamamo que los parámetros, que será donde se deposite el resultado de la enumeración... y que se irá sobrescribiendo una y otra vez...

- Lo siguiente es establecer los valores adecuados para el inicio, final del bucle y dirección de avance (puede ir tanto desde A-Z, como desde Z-A, por tanto el bucle puede aumentar o reducir en unidades.

- Lo siguiente, si se mira bien, es que hay 16 bucles, esto implica que con la misma función, sin cambios, podríamos generar claves de largo entre 1 y 16. Las claves se generan en los bucles más internos, y quedan sin usar los bucles más externos, para estos se fijan Min, Max e Incremento a valores que hacen que el bucle se ejecute una sola vez y por tanto no alteran ni se cae en errores.

- Finalmente vienen los bucles, extreamadamente sencillos y que puede verse cómo actúan exactamente como los cuentakilómetros.
Se ha recurrido a señalar cada bucle, como a,b,c,d,e...p, el bucle 'a', es el más interno y sobre la clave produce el carácter 0, el más externo (el bulce 'p'), produce el último carácter (si usan claves de 16 caracteres.


A continuación adjunto el código de la función que se invoca a al entrada de la función enumerar... y que tiene por objeto contar el número de permutaciones que se van a generar y verificar un par de cosas: que ambos parámetros tienen el mismo tamaño de caracteres (podría añadirse una verificación de delimitación del tamaño mínimo (1) y máximo (16) caracteres, que no se realiza), puede ocurrir un error si el número de permutaciones sobrepasa el rango de 96 bits (12 bytes, pués se ha declarado la cuenta con un tipo de datos
Decimal). Nótese que los bucles no generarán error por desbordamiento, opera simplemente con 8 y 16 bits (byte y short) y el tamaño, simplemente es tiempo que tarda. Si se prefiere evitardesbordamiento incluso para 96 bits, puede omitirse la cuenta de permutaciones y devolverlo en formato de string en la forma X a la Y (26^7), (36^5), (256^16), etc...

 ''' <summary>
    ''' Calcula el número de permutaciones totales.
    ''' </summary>
    ''' <param name="Min">Define el valor mínimo para cada carácter.</param>
    ''' <param name="Max">Define el valor máximo para cada carácter.</param>
    ''' <returns>El número de permutaciones totales. Un valor negativo, si hubo errores.</returns>
    ''' <remarks>Cada carácter tiene su propio alfabeto, circunscrito al rango Min-Max, para el índice que ocupa.</remarks>
    Friend Function CalcularNumPermutaciones(ByRef Min() As Byte, ByRef Max() As Byte) As Decimal
        Dim k As Short, j As Short, n As Decimal, v As Short
 
        k = Min.Length
        If (k <> Max.Length) Then
            MsgBox("Los 2 arrays deben ser del mismo tamaño: Min y Max.")
            Return -2
            Exit Function
        End If
 
        Try
            n = 1
            For j = 0 To k - 2 Step 2
                v = Max(j) ' impide que la resta entre dos bytes (a continuación), de error por desbordamiento, si el resultado es menor de 0.
                v = (v - Min(j))
                n = (n * (Math.Abs(v) + 1)) ' ABS= Valor absooluto del número (esto es, ignora el signo y lo toma como positivo).
            Next
 
            Return n
        Catch ' de ocurrir un error se espera que sea desbordamiento... (de n).
            Return -1
        End Try
    End Function
 

Finalmente comentar que el código (el del algoritmo de permutación, no esta última función), pero resuelve el caso y es más rápido que el algortimo presentado anteriormente (en el mensaje previo), en contra tiene que no es cómodo establecer un punto de inicio distinto al inicio de las permutaciones, y también que el código no es muy elegante.

Y eso es todo por hoy...

En el próximo mensaje proveeré una variante que resuelve ambas cosas a costa de una pérdida de eficiencia en velocidad, debida a que recurro a un modelo recursivo, frente a este iterativo, además la recursividad será sobre una clase, no sobre un método.

---------------------
p.d.: Un tick en NET es la diezmillonésima parte de 1 sg. por ello al final se divide entre 10 millones, para tener el tiempo en segundos.

Cabe preguntarse si los hackers de esas extorsiones no serían personal propio del FBI, razón por la cual, tendría sentido recomendar el pago de los rescates...

Creo que es innecesario.
Básicamente porque son dos filosofías reñidas entre sí. Y lo que unos usuarios quieren lo encuentran en lo que eligen, si quisierna lo otro, se pasarían al otro sistema o viceversa...

Probablemente seremos los programadores, los más beneficiados del asunto, pero los usuarios creo que no tanto, por no decir prácticamente nada.

Un poco exagerado...
Vale que lo hizo deliberadamente, y por ello ciertamente implica una falta de respeto, pero...
Yo creo que un par de collejas y a lo sumo una semana de cárcel, sobraba como escarmiento.

La anonimicidad, amigo, marca la diferencia...



Igualmente pasa con el hackeo...

Voy a ir poniendo código, aunque sea cada día un algoritmo... y los comentarios pertinentes.... al final, comprimo el proyecto y lo subiré a una pagina de descarga...

Tal como dije me he ceñido estrictamente a no usar clases o métodos complejos, que haga inentendible el código para alguien no versado en Net...

De entrada paso a explicar, que en cad algoritmo he tratado de desarrollarlo de la forma que me ha parecido más adecuada, para traerlo aquí y explicar detalles... esto supone que por ejemplo en alguno habrá muchos detalles previos al algoritmo, y en otros apenas nada, en unos las claves vendrás con 2 bytes por carácter y en otro con uno, en unos con un tipo de datos y en otro con otros... debe quedar claro en todo momento, que al final hablamos siempre de bytes y solo bytes, luego nadie debiera tener dificultad alguna (si conoce adecuadamente el lenguaje que acostumbra a usar), para convertirlo al tipo de datos que precise según el uso al que se destine. Por ejemplo, si alguien se empeña guardarlo a disco, guardar los caracteres con 1 solo byte por carácter ocupará la mitad de espacio que si lo guarda con 2 bytes por caracter... del mismo modo, si lo guarda a disco, prescindir de saltos de línea también ahorra espacio... Después de todo abrir un fichero de pongamos 1Gb. para leerlo, carece de sentido y por lo mismo, da igual que no sea legible y no se abara con un visor de texto o se use un editor  hexadeciaml....

Dicho lo cual, vamos con el primero, el algoritmo-A.

El algoritmo-A, es el más simple de todos en cuanto a líneas de código y como dije es solo un cambio de base de numeración a la base cuyo tamaño representa el alfabeto usado. Es el algoritmo al que todo el mundo (que sepa un mínimo de programación debiera llegar...
- Su fuerte, la extrema sencillez de entenderlo... (y programarlo).
- Su defecto, que no es el más óptimo en cuanto a velocidad. Aún así, para pequeños diccionarios de hasta 5 caracteres (o incluso 6, dada la velocidad de los equipos de hoy día es suficientemente rápido si nios limitamos a un alfabeto de por ejemplo A-Z (entiéndase A-Z, como el rango de caracteres entre ellos dos: "A,B,C,D,E,F...,X,Y,Z").

Dado que este algoritmo es sencillo, me he parado en detalles extras, de los que he prescindido en los otros. También está profusamente lleno de comentarios sobre el código, en los demás he prescindido de tanto detalle.

Aquí una imagen de la interfaz, muy sencilla. Puede verse el selector de tamaño de las claves, el selector del conjunto de caracteres que formarán el alfabeto a permutar y el botón para realizar la tarea.
El conjunto de caracteres puede optarse por todo el ASCII (o una parte definiendo un punto de inicio y una cantidad de caracteres), o restringido a los caracteres: 0-9, A-Z, a-z, o cualquier combinación de ellas (pero siempre en el orden en que aparecen. También permite recibir un alfabeto personalizado (básicamente un array con los caracteres que se desee y en el orden que se quiera). Para el propósito de este texto es suficiente (me parece), pero cada cual que modifique a su gusto...




El código para este algoritmo, se resume en el código asociado a los eventos de la interfaz de usuario y una clase. Esta clase tiene otra interna (anidada), dedicada a generar el alfabeto. Se deja anidada solo por encapsulación, si un lenguaje no admite crear clases anidadas, igualmente se puede dejar fuera...
Vamos pués primero con el código de esta clase anidada:

Esta clase se la ha llamado: AlfabetoToUse

#Region "clase para generar el alfabeto"
 
    ''' <summary>
    ''' Facilitador para crear el alfabeto a usar.
    ''' </summary>
    ''' <remarks></remarks>
    Public Class AlfabetoToUse
        Private p_Alfabeto(0 To 255) As Byte    ' 08 bits
        Private p_Sizealfabeto As Short         ' 16 bits
 
        ''' <summary>
        ''' Facilita la generación automática del alfabeto, basado en un valor que identifica claramente el conjunto que se toma.
        ''' </summary>
        ''' <remarks></remarks>
        Public Enum CaracteresUsadosEnAlfabeto
            ''' <summary>
            ''' Este valor o inferior es un valor ilegal.
            ''' </summary>
            ''' <remarks></remarks>
            ALFABETO_VALOR_ILEGAL_MENOR = -2
            ''' <summary>
            ''' El cliente pasa el array con el alfabeto que desea usar.
            ''' </summary>
            ''' <remarks></remarks>
            ALFABETO_CUSTOM = -1
            ''' <summary>
            ''' El alfabeto es todo el espacio ASCII.
            ''' </summary>
            ''' <remarks></remarks>
            ALFABETO_ASCII = 0
            ''' <summary>
            ''' El alfabeto contiene los números.
            ''' </summary>
            ''' <remarks></remarks>
            ALFABETO_09 = 1
            ''' <summary>
            ''' El alfabeto contiene las mayúsculas (no 'Ñ' ni otros caracteres extendidos).
            ''' </summary>
            ''' <remarks></remarks>
            ALFABETO_AZ_UPPERCASE = 2
            ''' <summary>
            ''' El alfabeto contiene las minúsculas (no 'ñ' ni otros caracteres extendidos).
            ''' </summary>
            ''' <remarks></remarks>
            ALFABETO_AZ_LOWERCASE = 4
            ''' <summary>
            ''' El alfabeto es tomado parcialmente del ASCII
            ''' </summary>
            ''' <remarks></remarks>
            ALFABETO_OFFSET = 8
            ''' <summary>
            ''' Este valor o superior es un valor ilegal.
            ''' </summary>
            ''' <remarks></remarks>
            ALFABETO_VALOR_ILEGAL_MAYOR = 9
        End Enum
 
        Public ReadOnly Property Alfabeto() As Byte()    ' 8 bits
            Get
                Alfabeto = p_Alfabeto
            End Get
        End Property
        Public ReadOnly Property SizeAlfabeto As Short ' 16 bits
            Get
                SizeAlfabeto = p_Sizealfabeto
            End Get
        End Property
 
        ''' <summary>
        ''' Por defecto, el alfabeto es el ASCII y el tamaño 256.
        ''' </summary>
        ''' <remarks>Si las claves han de ser imprimibles como texto, se perderán aquellos caracteres no imprimibles. en tal caso definir el alfabeto a usar.</remarks>
        Public Sub New()
            'Me.New(0)
            p_Sizealfabeto = 256
            Call ConstruyeAlfabeto(CaracteresUsadosEnAlfabeto.ALFABETO_ASCII)
        End Sub
 
        ''' <summary>
        ''' Facilita la construcción del alfabeto basado en un valor de enumeración.
        ''' </summary>
        ''' <param name="Tipo">Pueden unirse entre sí los conjuntos: 0-9, A-Z y a-z (pero será en ese orden)</param>
        ''' <remarks>Aunque el valor 'custom' consta en la enumeración, es el cliente qien debe expresar en ese caso el conjunto de caracteres que se emplea.</remarks>
        Public Sub New(ByVal Tipo As CaracteresUsadosEnAlfabeto)
            If (ConstruyeAlfabeto(Tipo) = False) Then
                Err.Raise(-1, , "El 'tipo' recibido, no consta en la enumeración y/o no permite deducir el conjunto de caracteres a tomar para generar el alfabeto. Introduzca un valor en el rango admitido.")
            End If
        End Sub
 
        ''' <summary>
        ''' Permite declarar un alfabeto parcialmente indicando un desplazamiento sobre la tabla ASCII
        ''' </summary>
        ''' <param name="Comienzo">Punto de comienzo desde donde se toma el alfabeto.</param>
        ''' <param name="SizeAlfabeto">Cantidad de caracteres que se toman del alfabeto. Si es preciso se trunca.</param>
        ''' <remarks>Ejemplo: para generar un alfabeto que use solo las mayúsculas se llamaría con New(65,26)</remarks>
        Public Sub New(ByVal Comienzo As Byte, Optional ByRef SizeAlfabeto As Byte = 255)
            If (Comienzo < 255) Then
                If (SizeAlfabeto + Comienzo > 255) Then
                    SizeAlfabeto = (255 - Comienzo)
                End If
                p_Sizealfabeto = (SizeAlfabeto + 1)
 
                Call ConstruyeAlfabeto(CaracteresUsadosEnAlfabeto.ALFABETO_OFFSET, Comienzo)
            Else
                Err.Raise(-1, , "Si el comienzo es el byte 255, el tamaño del diccionario es 1 y solo genera una clave. ...¿qué sentido tiene???")
            End If
        End Sub
 
        ''' <summary>
        ''' Permite al usuario introducir su propio alfabeto.
        ''' </summary>
        ''' <param name="AlfabetoCustom">Array con el alfabeto del usuario.</param>
        ''' <remarks>OJO: No se verifica la validez del alfabeto, se supone correcto.</remarks>
        Public Sub New(ByRef AlfabetoCustom() As Byte)
            p_Alfabeto = AlfabetoCustom
            p_Sizealfabeto = p_Alfabeto.Length
 
            If (p_Sizealfabeto = 0) Then
                Err.Raise(-1, , "El alfabeto del usuario no puede estar vacío, o tener solo 1 elemento. ...¿con qué fin???")
            End If
        End Sub
 
        ''' <summary>
        ''' Recrea el alfabeto basado en la enumeración recibida
        ''' </summary>
        ''' <param name="Tipo">Enumeración que señala qué caracteres se tomarán para el alfabeto. Los conjuntos 0-9, A-Z y a-z, pueden aunarse entre sí.</param>
        ''' <returns>Devuelve True si el tipo recibido es existente o subyacente en la enumeración</returns>
        ''' <remarks>No se debe invocar el tipo 'custom'</remarks>
        Friend Function ConstruyeAlfabeto(ByVal Tipo As CaracteresUsadosEnAlfabeto, Optional ByVal Offset As Byte = 0) As Boolean
            Dim k As Short, n As Short
 
            n = 0 ' por claridad
            If (Tipo > CaracteresUsadosEnAlfabeto.ALFABETO_CUSTOM) And (Tipo < CaracteresUsadosEnAlfabeto.ALFABETO_VALOR_ILEGAL_MAYOR) Then
                Select Case Tipo
                    Case CaracteresUsadosEnAlfabeto.ALFABETO_ASCII, CaracteresUsadosEnAlfabeto.ALFABETO_OFFSET
 
                        For k = Offset To (p_Sizealfabeto + Offset) ' 0 to 255, si es ASCII
                            p_Alfabeto(n) = k
                            n += 1 ' n=k si offset=0
                        Next
                    Case Else
                        p_Sizealfabeto = 0
                        ' Intervienen los números?
                        If ((Tipo And CaracteresUsadosEnAlfabeto.ALFABETO_09) = CaracteresUsadosEnAlfabeto.ALFABETO_09) Then
                            For k = 48 To 57
                                p_Alfabeto(n) = k
                                n += 1
                            Next
                        End If
 
                        ' intervienen las mayúsculas?. Si sí, añadirlas (tras lo previo)
                        If ((Tipo And CaracteresUsadosEnAlfabeto.ALFABETO_AZ_UPPERCASE) = CaracteresUsadosEnAlfabeto.ALFABETO_AZ_UPPERCASE) Then
                            For k = 65 To 90
                                p_Alfabeto(n) = k
                                n += 1
                            Next
                        End If
 
                        ' Intervienen las minúsculas?. Si sí, añadirlas (tras lo previo)
                        If ((Tipo And CaracteresUsadosEnAlfabeto.ALFABETO_AZ_LOWERCASE) = CaracteresUsadosEnAlfabeto.ALFABETO_AZ_LOWERCASE) Then
                            For k = 97 To 122
                                p_Alfabeto(n) = k
                                n += 1
                            Next
                        End If
 
                        p_Sizealfabeto = n
                End Select
 
                Return True
            Else
                Return False ' el tipo recibido no permite deducir el conjunto de caracteres a tomar para generar el alfabeto.
            End If
        End Function
    End Class
 
#End Region
 

- En dicho código, aparece primero la declaración de variables a nivel de clase, luego una enumeración, que define que tipo de alfabeto se va a construir (si se ha de construir).
- Luego aparecen de propiedades de solo lectura (El alfabeto y el tamaño del alfabeto), ambas propiedades serán las que se lean cuando se use el algoritmo.
- Luego hay 4 constructores de clase, para permitir invocar el tipo de alfabeto de que se quiere generar en base a las opciones que permite.
- Finalmente hay un método que construye el alfabeto.

La idea de esta clase, es que el alfabeto sea definido una sola vez y pueda ser usada como parámetro para enumerar. Así se evita que mientras se enumere se modifique el alfabeto (o el tamaño del mismo) y dé lugar a errores durante la ejecución. Ya que se construye y luego es de solo lectura, no puede modificarse mientras se usa.

Pasamos ahora al código de la clase (llamada cBaseNum) que hospeda a ésta recién descrita (AlfabetoToUse): 

''' <summary>
''' Clase: Combinatoria-Alfabeto-Diccionario. Crea diccionario (in situ), mediante combinatoria.
''' </summary>
''' <remarks>No se ha previsto en ningún momento almacenar a fichero el diccionario creado</remarks>
Public Class cBaseNum
    ' siempre contiene 256 bytes, aunque luego no se usen todos.
    Private p_Alfabeto(0 To 255) As Byte  ' 08 bits sin signo
    Private p_Sizealfabeto As Short       ' 16 bits con signo
    Private s_LargoClaves As Byte
    Private s_MaxPermutaciones As UInt32    ' 64 bits sin signo 
 
 
#Region "clase para generar el alfabeto"
 
    ''' <summary>
    ''' Facilitador para crear el alfabeto a usar.
    ''' </summary>
    ''' <remarks></remarks>
    Public Class AlfabetoToUse
'... AQUI: va el código d ela clase anterior (que está anidada). Si un lenguej no permite anidar clases, dejarla fuera al mismo nivel y listo.
    End Class
 
#End Region
 
    Public Structure PermutarDatosImprescindibles
        Public Charset As AlfabetoToUse
        Public LargoClaves As Byte
        Public PermutacionInicialStr As String
        Public PermutacionInicialLng As Long
    End Structure
 
    ''' <summary>
    ''' Enumera todas las permutaciones.
    ''' </summary>
    ''' <param name="Datos">Alfabeto que se va a usar, Tamaño de las claves a generar y valor inicial.</param>
    ''' <remarks>El método usado en este algoritmo es la conversión entre sistemas de numeración.</remarks>
    Public Sub Enumerar(ByRef Datos As PermutarDatosImprescindibles)
        Dim Clave() As Byte
        Dim k As UInt32, n As Short ' contadores de bucle
        Dim v As UInt32, x As Byte, Numchars As Short
        Dim Crono As Single
 
        Crono = TimeOfDay.Ticks ' ticks a la hora actual
        With Datos
            p_Alfabeto = .Charset.Alfabeto
            p_Sizealfabeto = .Charset.SizeAlfabeto
            s_LargoClaves = .LargoClaves
 
            s_MaxPermutaciones = (p_Sizealfabeto ^ s_LargoClaves)
 
            Numchars = ((s_LargoClaves * 2) - 2)
            ReDim Clave(0 To Numchars + 1)
 
            If (.PermutacionInicialLng < 0) Then .PermutacionInicialLng = 0
            If (.PermutacionInicialStr.Length > 0) Then
                ' FALTA: código para convertir la clave a la enésima permutación.
                ' es el proceso inverso al seguido en el algoritmo y debiera facilitarse como una función pública. 
                ' k= EnesimaPermutacion(.PermutacionStr)
            Else
                k = .PermutacionInicialLng
            End If
 
 
            Do
                v = k
                n = Numchars
                Do
                    x = (v Mod p_Sizealfabeto)
                    Clave(n) = p_Alfabeto(x) ' convertir el byte a char.
                    v \= p_Sizealfabeto ' división entera.
                    n -= 2
                Loop While (n >= 0)
                ' USAR la clave desde aquí
                ' llamada a FuncionX(Clave)
                k += 1
            Loop While (k < s_MaxPermutaciones)
        End With
 
        Crono = ((TimeOfDay.Ticks - Crono) / 10000000)  ' ticks a la hora actual, menos los de comienzo= ticks invertidos en la tarea.
        MessageBox.Show(Crono.ToString & vbCrLf & s_MaxPermutaciones.ToString)
    End Sub
End Class
 

- La clase es bien sencilla, al inicio la declaración de variables, el alfabeto y el tamaño del mismo, por razones de rendimiento es preferible copiarlos a esta... Para que quede claro se deja constancia del tipo de datos que VB.NET son, para facilitar la conversión a otro lenguaje (tal como allí se designe el tipo equivalente).
- Luego viene la clase anidada (para generar el alfabeto).
- Detrás viene definida una estructura con los siguientes 4 elemntos:
----- La instancia de clase del alfabeto creado previamente y que se usará. éste contiene dos cosas, el alfabeto (charSet) a usar y el tamaño de dicho alfabeto).
----- El tamaño de las claves que queremos generar
----- Un posible punto de inicio, para enumerar las claves (en forma de una clave (string). Esta parte no se ha implementado...
----- Un posible punto de inicio, para enumerar las claves (en forma de la enésima clave (número)).
- Finalmente el método para Enumerar (generar las permutaciones). Recibe como único parámetro, la estructura que se acaba de explicar.
Inicia el crono 8para calcular el tiempo invertido en generarlo) y acto seguido toma de la clase AlfabetotoUse, tanto el alfabeto como su tamaño, así una posterior modificación de dicha clase, mientras se está permutando, no afecta al trabajo en curso evitando errores...
Luego unas asignaciones y cáclulos elementales, tras lo cual viene finalmente el bucle de la enumeración.
Las permutaciones se consiguen cambiando la base numérica desde un valor decimal (base 10), a la base numérica cuyo valor es el tamaño del alfabeto... dicho valor se usa como el desplazamiento dentro del alfabeto para seleccionar el carácter con que se representa en dicha base numérica.

Y eso es todo lo que respecta a la clase... al término de la enumeración indica el tiempo transcurrido.

Queda el código de la interfaz de usuario... Se ha omitido en la interfaz la designación tanto de un alfabeto custom, como un alfabeto basado en el ASCII, definido por un punto de inicio y una cantidad de caracteres... (queda al esfuerzo de los interesados, modificar y/o ampliar características).
Dado lo sencillo de la interfaz, las explicaciones dadas y el código a continuación creo superfluo extenderme más... pero si alguien tiene alguuna duda, que pregunte.

Public Class frm1 ' la ventana, formulario...
    Dim alfa As cBaseNum.AlfabetoToUse
 
    Dim SizeAlfabeto As Short
    Dim TipoAlfabeto As cBaseNum.AlfabetoToUse.CaracteresUsadosEnAlfabeto
 
 
    ''' <summary>
    ''' Por defecto, al inicio el alfabeto es A-Z (26 caracteres)
    ''' </summary>
    ''' <param name="sender"></param>
    ''' <param name="e"></param>
    ''' <remarks></remarks>
    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        TipoAlfabeto = cBaseNum.AlfabetoToUse.CaracteresUsadosEnAlfabeto.ALFABETO_AZ_UPPERCASE
        SizeAlfabeto = 26
    End Sub
 
    ''' <summary>
    ''' Selección del tipo de alfabeto a usar
    ''' </summary>
    ''' <param name="sender"></param>
    ''' <param name="e"></param>
    ''' <remarks>Se han ligado los eventos de todos los checkbox a este método</remarks>
    Private Sub CheckBox1_CheckedChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles CheckBox1.CheckedChanged, CheckBox2.CheckedChanged, CheckBox3.CheckedChanged
        TipoAlfabeto = 0 : SizeAlfabeto = 0
 
        If (CheckBox1.Checked = True) Then
            TipoAlfabeto = cBaseNum.AlfabetoToUse.CaracteresUsadosEnAlfabeto.ALFABETO_09
            SizeAlfabeto = 10
        End If
 
        If (CheckBox2.Checked = True) Then
            TipoAlfabeto = (TipoAlfabeto Or cBaseNum.AlfabetoToUse.CaracteresUsadosEnAlfabeto.ALFABETO_AZ_UPPERCASE)
            SizeAlfabeto += 26
        End If
 
        If (CheckBox3.Checked = True) Then
            TipoAlfabeto = (TipoAlfabeto Or cBaseNum.AlfabetoToUse.CaracteresUsadosEnAlfabeto.ALFABETO_AZ_LOWERCASE)
            SizeAlfabeto += 26
        End If
 
        ' si se deseleccionó todo, por defecto será todo el rango ASCIIasigna
        If TipoAlfabeto = 0 Then SizeAlfabeto = 256
 
        GroupBox1.Text = "Tamaño del diciconario: " & SizeAlfabeto.ToString
    End Sub
 
    ''' <summary>
    ''' Reunir todos los datos y llamar a la enumeración.
    ''' </summary>
    ''' <param name="sender"></param>
    ''' <param name="e"></param>
    ''' <remarks></remarks>
    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        Dim datos As cBaseNum.PermutarDatosImprescindibles
        Dim cad As New cBaseNum
 
        ' Reunir los parámetros en una estructura, único parámetro del método enuerar de la clase...
        With datos
            .Charset = New cBaseNum.AlfabetoToUse(TipoAlfabeto) ' construir el alfabeto
            .LargoClaves = NumericUpDown1.Value ' tamaño de las claves a generar.
            .PermutacionInicialLng = -1 ' cambiar si se quiere iniciar en una secuencia distinta de la primera.
            .PermutacionInicialStr = ""  ' no se ha implmenetado en la clase el inicio dado una clave concreta...
        End With
 
        cad.Enumerar(datos)
        MessageBox.Show("Finalizada la enumeración.")
    End Sub
End Class
 

Como se puede apreciar, no se incluído ningún método complejo, ni nada especial que impida entender el código aún sin tener idea de VB.NET.

--------------------

Mañana saco un tiempito, y paso con el algoritmo-2, hice 3 versiones (piondré uno de cada vez), cada uno con sus características, para dar riqueza de experiencia y aprendizaje...

Para aprender a programar no importa la edad... si uno está abierto a aprender, aprende. Si uno está cerrado, todo sonará a chino.

Yo te señalaría que en función del S.O. que tengas elijas un lenguaje adecuadamente implantado en dicha plataforma...
Por ejemplo si tienes Windows, te recomendaría .NET. Si partes de una base nula, mejor Visual Basic que C#. En cambio si tienes por ejemplo Linux, tirar por Phyton sería muy buena opción... Y en un punto medio a ambas plataformas, te diría Java... ahora tu decide.

VB6, sigue siendo bastante bueno pese a sus limitaciones. Después de todo, ahora que los equipos son mucho más potentes, las aplicaciones realizadas con VB6, corren muy rápido (si uno sabe que hace, por supuesto) y ocupan poco espacio en disco y no saturan memoria (comparado con NET, por ejemplo).

De todos modos existe Gambas, un lenguaje similar (ellos aseguran que no es un clon, creo que más para no entrar en la ansiedad por las exigencias de: "...pués en VB6 esto se comporta así, y no como sucede aquí...").
Tiene una implicación directa de Java, lo mismo que VB6, lo tiene de C... Nunca lo he usado, pero aseguran que tiene una evolución más allá de VB6. No sé si se refieren a que como parte del entorno Linux, pués tiran de bases de datos MySQL, en dez de SQL-Server o Access, Open-GL, en vez de DirectX... etc... o si se refieren a otra cosa...
Desconozco, por completo si han implementado algo similar a ActiveX, y por tanto si se podrá crear controles de usuario, y tal...

En fin si quieres hecharle un vistazo: https://es.wikipedia.org/wiki/Gambas o en inglés: https://en.wikipedia.org/wiki/Gambas
Adicionalmente un foro en español: https://www.gambas-es.org/