Antes de nada yo hago uso de dos buffers, bueno realmente visible es 1, es decir, el buffer principal que varía su tamaño (si hay subsecuencia desde i hasta j, i incrementa recordemos), todo esto recalculando para no hacer overflow cada vez que finaliza una subsecuencia. Con longitud fija pues chupado. Y luego tenemos el buffer del descriptor del fichero el cual es múltiplo de 64KB o 64 KB depende del OS. La primera opción la he tenido en cuenta a la hora de lidiar con el buffer del descriptor de fichero. En C++ no había forma más que heredando y haciendo mi propia implementación así que use la interfaz de I/O de C.

Así que cuando el buffer principal ha llegado a casi el límite se guarda en chunks de 64 al fichero. Aquí entra en juego el punto número 2, pues también probe que el descriptor no usara buffer, es decir, escribe al file lo más pronto posible, con setbuf es posible desactivar el buffer del stream. ¿Es esto a lo que te refieres con quitarnos la cache de en medio (creo que no)? Tampoco noté mucha mejoría. Otra idea con sentido que tuve fue apuntar el stream del fd al buffer principal y hacer un flush (escribir al device y limpiar), pero sigo sin saber porque eso no funciona, si tan loca la idea no es y usaría solo un buffer, pero bueno parece que solo las primitivas estilo fputs o fwrite funcionan.

Y sobre la tercera, bueno de las primeras cosas que hice antes de meterme a la progamación son los cálculos matemáticos (como queda retratado en el paper) del storage con hashing y de words, por lo tanto tengo acceso al tamaño en bytes del fichero destino, claro que para secuencias grandes será descomunal, en esto si que no había caído y gracias por la recomendación sin duda lo probaré.

Un saludo!

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...

Voy con la siguiente entrega...

En esta ocasión, trato las permutaciones con una clase que se llama recursivamente.
Otra clase (padre de ésta), hace la vez de bucle principal y es la que el cliente invoca externamente.

Como en el caso previo, se opera con cada carácter de una vez, por lo que igualmente aquí, cada carácter puede tener su propio alfabeto, exactamente en la smismas condiciones que el código del algoritmo previo.
En este caso además se provee la capacidad de establecer un estado inicial distinto del comienzo de la permutación. El código también resulta algo más elegante (que un montón de bucles FOR), sin embargo el rendimiento es menor, ya que la recursividad siempre es más lenta que la iteración, dado que con cada llamada, debe almacenarse en la pila el estado previo de la función de la que se sale.

En esta ocasión el código se muestra en 4 apartados:
- El de la interfaz del usuario (como respuesta a pulsar el botón). La ventana
- El de la clase instanciada desde la interfaz. clase cPermut
- El código en un módulo (compartido con el proyecto). módulo mComun
- El de la clase instanciada desde la clase pública. clase Ciclos


Respecto de la interfaz, es la misma que aparece en el mensaje previo (ver la imagen), solo que aquí se expone el código relativo al botón que aparece en el centro...

Public Class frm2 ' la ventana, formulario
 
    Private perm As New cPermut
 
   Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        Dim ClaveActual() As Byte, Min() As Byte, Max() As Byte
        Dim z As Decimal
 
        ClaveActual = StringToByteArray(TextBox1.Text) ' Valor inicial: "ABXFD"
        Min = StringToByteArray(TextBox2.Text)  ' Valor mínimo: Ejemplo: "AAAAZ"
        Max = StringToByteArray(TextBox3.Text)  ' Valor final, Ejemplo: "ZWZZA
 
        z = perm.Enumerar(ClaveActual, Min, Max)
    End Sub
End Clasee
 

El código es muy simple.
Una referencia a la clase que alberga la funcionalidad, y luego el trabajo del botón, donde convierte a un array de bytes los 3 textos que la función encargada de permutar requiere como parámetros: El valor inicial, el valor mínimo y el valor máximo (de las permutaciones, respectivamente). Finalmente se llama a a la función enumerar de la clase. Devuelve el número de permutaciones y como se decía en el mensaje previo, no es estrictamente necesario... podría devoverse simplemente un buleano.


Ahora vamos por el código de la clase cPermut:
Esta clase es pública y contiene a la otra anidada, así es privada para esta clase. Si un lenguaje no admite clases anidadas, no importa, basta ponerla al mismo nivel que esta clase, pero dejarla privada, para ser instaciada sólo a nivel de proyecto y listo...
El código d ela clase anidada, se pone aparte, para facilitar entender cada parte y por si uno tiene que ponerlo como clases sueltas e independientes (o hacer cambios cómodamente).

Public Class cPermut
 
    Public Enum ValoresDeIncremento
        VALOR_DECREMENTO = -1
        VALOR_INCREMENTO = 1
    End Enum
 
#Region "Accesible para las clases 'Ciclo'. "
    Private Shared Fin As Boolean ' Control de fin de la enumeración (mejor que forzar una comparación).
    Private Shared SizeClave As Short  ' Tamaño de las claves (cantidad de caracteres que contienen)
    Private Shared ClavePermutada() As Byte  ' Clave generada en bytes.
 
    Private Shared Max() As Byte ' En cada índice se deja el valor máximo.
    '    Ejemplo: 78,78,78,78,78,78,78,78 --> Todos iguales.
    '    Ejemplo: 45,37,22,65,90,90,90,90 --> Cada uno distinto.
 
    Private Shared Min() As Byte ' En cada valor se deja el valor mínimo.
    '    Ejemplo: 00,00,00,00,00,00,00,00 --> Todos iguales.
    '    Ejemplo: 00,18,05,22,12,12,00,08 --> Cada uno distinto.
 
    ' Establece datos operativos.
    '  Establecer un tamaño, no necesariamente borra el previo.
    Private Shared Sub EstablecerPuntoInicial(ByRef Abc() As Byte, ByRef vMax() As Byte, ByRef vMin() As Byte, Optional ByVal SinRepeticion As Boolean = False)
        SizeClave = (Abc.Length - 2)
        ClavePermutada = Abc
        Max = vMax : Min = vMin
        Fin = False
    End Sub
#End Region
 
    Private p_Ciclos As New Ciclos ' Crea una instancia de la clase anidada (privada)
    Private Alfabeto As String
    Private vMin() As Byte
    Private vMax() As Byte
    Private UltimaPalabra As String
 
 
 
    ' Enumera todas las permutaciones desde la combinación de entrada con los límites establecidos.
    '  Devuelve el número de permutaciones totales
    Public Function Enumerar(ByVal ClaveActual() As Byte, ByVal Min() As Byte, ByVal Max() As Byte) As Decimal
        Dim z As Decimal, Crono As Single
 
        Crono = TimeOfDay.Ticks ' ticks a la hora actual
 
        z = CalcularNumPermutaciones(ClaveActual, Min, Max)
        If (z < 0) Then
            Return -1
            Exit Function
        End If
 
        ' Establece el estado inicial y final de las permutaciones
        Call EstablecerPuntoInicial(ClaveActual, Max, Min) ', SinRepeticion)
        ' Prepara los valores iniciales en cada clase 'ciclo'
        p_Ciclos.SetEstadoInicial()
 
        ' Iniciar las permutaciones de entre los límites fijados
        Do
            p_Ciclos.Mutar()
            ' Usar Permutación desde aquí:
            ' call FuncionX(Permutacion)
        Loop While (Fin = False)
 
        ' Devolver resultados
        Enumerar = z
        Crono = ((TimeOfDay.Ticks - Crono) / 10000000)  ' ticks a la hora actual, menos los de comienzo= ticks invertidos en la tarea.
        MessageBox.Show("Tiempo: " & Crono.ToString & vbCrLf & "Permutaciones: " & z.ToString)
    End Function
 

Comentando el código:
- Primero aparece una enumeración, básicamente sirve para saber si el alfabeto para un carácter es creciente o decreciente, es decir, puede indicarse el alfabeto para un carácter tanto A-Z, como Z-A, en cuyo caso debe ser decrementado.
- Después delimitado en una region (una región no es código, solo es de carácter informativo, para agrupar código e indicar que está relacionado (por el comentario que se acompaña), aparecen varios campos "Private Shared", que señala que no son accesibles fuera d ela clase, pero que si son compartidos con las clases anidad que 'ésta' tuviere (de hecho tiene una, Ciclos...si se traduce a otro lenguaje y la clase ciclos debe quedar fuera, también este código debe quedar fuera y ser accesible tanto desde esta clase, como de cualquier instancia de Ciclos.
- En la misma región se ha incluído una función que establece el valor de esos campos. El detalle de esos valores se verá en la clase ciclos, ya que desde aquí sólo se establecen, no se opera con ellos.

- Luego llegamos a la función enumerar:
---- Como ya se explicó en el algoritmo previo (mensaje previo), pasando como parámetros los límites de la enumeración para cada carácter, es posible de forma sencilla delimitar el alfabeto, además para cada carácter (ver mensaje previo), en este además se adjunta un terce rparámetro, la claveActual desde donde continuar la permutación. Esto implica que podemos empezar donde queramos parar en la parte señalada como final, y en otra ocasión continuar desde donde se dejó y marcar otro punto como final...
---- Tras acceder a la función enumerar, lo primero es verificar que los parámetros son congruentes entre si, llamando a  la función CalcularNumPermutaciones(,,,), aunque ya la vimos más arriba esta es ligeramente distinta, es una sobrecarga de la otra... De entrada se exige que tengan el mismo tamaño (que define el tamaño de las claves que se generan, así:
Actual:   CCC
Minimo:   AAA
Maximo:   ZZZ
Declara que se van a generar claves de 3 caracteres, que para cada carácter su alfabeto será A-Z, y que la clave Inicial será CCC, por tanto se permutará desde esa clave.
Otro ejemplo:
Actual:  C0CCXXCC
Minimo:  A0AAZZAA
Maximo:   Z9ZZAAZZ
Declara que se van a generar claves de 8 caracteres, que cada carácter tiene su propio alfabeto, para algunas es de A-Z, para otras de Z-A y para otra es de 0-9
Además, dicha función verifica (y trunca si procede) que la clave actual está en el rango fijado para el alfabeto de cada carácter, si no es así, se trunca (se fuerza), al valor límite... es decir si se pone estos parámetros como entrada:
Actual:  AAA
Minimo: DDX
Maximo: ZZD
Dado que, inicio para los dos caracteres a la izquierda sean DD, trunca la clave actual para esos caracteres a DD, ya que AA, es menor que DD. Igualmente para el carácter a la derecha de la clave actual es Z, queda fuera de rango, pués empieza en  X y finaliza en D, y A es menor, pasa a valer truncada 'D', así la clave actual finalmente sería: DDD
El código de esta función va debajo de estos comentarios... 
---- Una vez validado los parámetros, se establecen los valores a los campos sobre los que la clase Ciclos, va a operar. Función: EstablecerPuntoInicial
---- Luego invoca a la clase ciclos, para establecer el estado inciial. Esto se explica más abajo al describir la clase Ciclos. (SetEstadoInicial)
---- Finalmente viene el bucle de enumeración, invocando un método de la clase Ciclos.Mutar , que hace la Permutación. Con cada llamada se genera una clave. Tras la vuelta, puede usarse la clave generada, luego si alcanzó el final de la permutación el bucle finaliza y se sale de la función.


Viene ahora el código de la sobrecarga de la función que verifica los parámetros de enumerar... se acaba de describir suficientemente ya el código de esta función:

Module mComun
 
' nota: ya hay una función del mismo nombre muy similar, pero con solo dos parámetros, cuyo código está más arriba, en otro mensaje...
 
''' <summary>
    ''' Calcula el número de permutaciones totales. Y garantiza que la clave actual esté dentro del rango, truncándolo cuando sea preciso.
    ''' </summary>
    ''' <param name="ClaveActual">Fija la clave actual de comienzo, dentro del rango.</param>
    ''' <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 ClaveActual() As Byte, ByRef Min() As Byte, ByRef Max() As Byte) As Decimal
        Dim k As Short, j As Short, n As Decimal, v As Short
        Dim x As Short, y As Short, z As Short
 
        k = ClaveActual.Length
        If ((k <> Min.Length) Or (k <> Max.Length)) Then
            MsgBox("Los 3 arrays deben ser del mismo tamaño: Palabra, Min y Max.")
            Return -2
            Exit Function
        End If
 
        Try
            n = 1
            For j = 0 To k - 2 Step 2
                x = ClaveActual(j)
                y = Min(j)
                z = Max(j)
                v = (z - y)
 
                If (v > 0) Then
                    If (x > z) Then
                        ClaveActual(j) = z
                    ElseIf (x < y) Then
                        ClaveActual(j) = y
                    End If
                ElseIf (v < 0) Then
                    If (x > y) Then
                        ClaveActual(j) = y
                    ElseIf (x < z) Then
                        ClaveActual(j) = z
                    End If
                End If
 
                n = (n * (Math.Abs(v) + 1))
            Next
 
            Return n
        Catch ' de ocurrir un error se espera que sea desbordamiento... sucederá si ponemos demasiados caracteres y un rango de alfabeto para ellos muy grande... depende de tales valores que se llegue a un desboramiento o no.
            Return -1
        End Try
    End Function
End Module
 

Solo queda por comentar que al truncar un carácter se comprueba que límite supera, si supera el límite 'Max', se fija con el carácter 'Máx', si supera el límite 'Min', se fija el carácter con el carácter'Min'. Máx y Min, como extremos del alfabeto para ese carácter.

Finalmente vamos con el código de la clase Ciclos, que es quien realiza todo el trabajo 'sucio'...

'Public Class cPermut
 
 
' Se crean tantas instancias de esta clase como caracteres ha de tener la clave +1.
    ''' <summary>
    ''' Esta clase representa un sólo carácter en una posición dada de la clave. Y retiene los valores máximo y mínimo que puede alcanzar.
    ''' </summary>
    ''' <remarks>La clase se encadena al siguiente carácter a través de p_Next.</remarks>
    Private Class Ciclos
        Private p_Valor As Byte          ' El valor actual del byte/carácter
        Private p_Min As Byte            ' El valor mínimo que puede alcanzarse (en el rango 0-255)
        Private p_Max As Byte            ' El valor máximo que puede alcanzarse (en el rango 0-255)
        Private p_PosicionChar As Byte   ' La posición que registra el 'Valor' de esta clase en el alfabeto.
        Private s_Inc As Short           ' el valor que se aumenta: -1 si es regresivo (Min mayos que Max), sino, es +1. 
        Private p_Next As Ciclos         ' Referencia a la instancia que opera sobre el carácter á la izquierda de éste.
 
        ''' <summary>
        ''' Prepara los valores de inicio, fin e incremento para el 'carácter x' del alfabeto.
        ''' </summary>
        ''' <remarks>Se reinvoca a sí mismo, hasta asignar una instancia de la clase a cada carácter del alfabeto. Tras el carácter más a la izquierda asocia una instancia 'fin'.</remarks>
        Public Sub SetEstadoInicial()
            Dim niM As Byte, xaM As Byte
 
            If (SizeClave >= 0) Then         ' C - Examina Size y si es mayor o igual a cero:
                p_PosicionChar = SizeClave    ' A - se asigna el índice actual.
                '                                               B - Con el índice actual, tomar:
                ' el 'valor' actual y los límites 'Max' y 'Min'.
                p_Valor = ClavePermutada(p_PosicionChar)
                niM = Min(p_PosicionChar)
                xaM = Max(p_PosicionChar)
 
                s_Inc = Math.Sign(xaM - niM) ' esto devuelve = 0, -1, +1
                If (s_Inc = 0) Then
                    p_Valor = niM : p_Min = niM : p_Max = niM  ' El carácter es fijo en la clave.
                Else
                    p_Max = xaM : p_Min = niM
                End If
 
                SizeClave -= 2              ' Z - Decrementa Size en 1
                If (p_Next Is Nothing) Then ' Y - Si no existe,
                    p_Next = New Ciclos '     crea otra clase anidada 'Next' (que será las decenas, centenas, etc...)
                End If
                Call p_Next.SetEstadoInicial()            ' X - Invoca su método 'Nuevo'.
                '                             W - vuelve a sumar el size... para compararlo con 'fin'.
            Else                            ' Si es menor que cero:
                ' Es el dígito a la izquierda del último reclamado,
                ' Su función es detectar el final de la enumeración.
 
                ' Se ponen los valores en la clase que intercepta el final de la enumeración.
                p_PosicionChar = 255 ' Este valor detecta el final.
                p_Min = 0 : p_Max = 0 : p_Valor = 0 ' necesario, porque si ya exisitía esta clase antes, podría tener valores...
                p_Next = Nothing    ' Z - Elimina (si existe) la clase anidada 'Next' y subsiguientes.
            End If
        End Sub
 
        ' Sumar ó restar 1. 
        ''' <summary>
        '''  Incrementar ó decrementa el valor en una unidad y lo actualiza en la posición asignada. Si no alcanza el límite
        ''' </summary>
        ''' <remarks></remarks>
        Friend Sub Mutar()
            If (p_Valor = p_Max) Then
                p_Valor = p_Min
                If (p_PosicionChar < 255) Then ' se llegó a un dígito/carácter más alla del tamaño de la clave?
                    p_Next.Mutar()
                Else
                    Fin = True
                    Exit Sub ' porque noo existe ese index en permutacion
                End If
            Else
                p_Valor += s_Inc ' s_inc puede valer:  +1, ó -1
            End If
            ClavePermutada(p_PosicionChar) = p_Valor
        End Sub
 
        ' Elimina las clase anidadas de nivel superior (existentes previamente y no usadas en esta enumeración)... y aquélla elimina a la siguiente, etc... (dígitos).
        Protected Overrides Sub Finalize()
            p_Next = Nothing
            MyBase.Finalize()
        End Sub
    End Class
 
'End Class
 

---- La clase registra un sólo carácter y nada más que uno, y guarda la info especifica para ello. Esto es: el valor actual, el valor Max, El Min, el incremento (+1
ó -1, en realidad +2, -2, pués manejamos 2 bytes por carácter).
---- p_PosicionChar, indica la posición que este carácter (ésta instancia de la clase ciclos) ocupa en la clave que se está generando.
---- p_Next, es una instancia a la clase que amneja el siguiente carácter. Recuerdo, que se opera como un cuentakilómetros, solo se mueve un dígito, y cuando alcanza su tope, fuerza-arrastra al siguiente al tiempo, que este regresa a su valor mínimo.
---- El método, SetEstadoInicial, en realidad recrea el 'cuentakilómetros, ya que recursivamente va generando una clase por cada carácter y luego se le cede el control, con cada 'carácter' coloca los valores asociados al carácter, valor actual límites Maxy Min, el valor de incremento... Cuando se llega al último carácter (el de la izquierda), se crea una última instancia con datos específicos, que luego son entendidos como: fin, ya no hay más caracteres, y sirve para retroceder en las devoluciones de llamdas en recursividad.
Si una llamada previa hubiere generado 2 caracteres, y por tanto 20 instancias, y la de ahora solo 6, asociar p_Next, para la clase final a Nothing, tiene por objeto destruir toda la estructura por encima de ella, es decir las instancias de clases, para los caracteres 7 a 21, serían  eliminadas y la 6ª haría las veces de clase límite.

--- Cuando desde el bucle del metodo "Enumerar" de la clase cPermut,  se invoca Ciclos.Mutar, se esta pidiendo generar una clave cada vez. el método Mutar (de Permutar), realiza un incremento-decremento (según la dirección del alfabeto), al valor actual. Pero si ya se alcanzó el límite, entonces se coloca el valor mínimo y luego invoca a la siguiente clase, para mutar su valor. Se reconoce, cuantas veces puede invocarse Mutar, porque tras el último carácter, se invoca la instancia que actúa de límite, la cual tiene establecido como posición en el array 255, y por tanto se avisa de que ha llegado al final (Fin = True), valor que detecta el bucle iterador principal de la clase padre, tras cada permutación.
En la práctica, asignar el valor de psoición del carácter como 255, implica que se podría permutar (sin cambios en el código), claves de hasta 254 caracteres de largo, ya que la instancia con valor 255, actúa de límite.
Finalmente, la instancia 'mutada' coloca el valor actual en la clave generada.
- El último método (finalize), es para liberar la memoria, cuando ya no se requiera el objeto... Esto en cad alenguaje debe hacerse tal como sea preciso en el lenguaje.

Y eso es todo. El código es más elegante y más corto que para el algortimo de los bucles FOR, pero mucho más lento, por usar recursividad, también porque constantemente se verifica que posición de carácter ocupa esa instancia. La recursividad no es la misma función, si no a la misma función de otra clase.

Mañana o pasado, más...

dices que en tu maquina hace 2,500,000,000 claves por minuto guauu

una duda que maquina tienes de ram y procesador?

y dices que no tienes la versión para windows ya que lo quería probar en mi maquina pero tengo windows

saludos Flamer y si mis cálculos son correctos tardarías como casi 2 horas para hacer un diccionario con el abecedario que son 27 dígitos y con 8 de longitud de las claves, es correcto