Mensajes

[China]

Mi banco es el ICBC (International and Commercial Bank of China) y nunca me ha faltado un centavo (por ahora)... 

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

Código (vbnet) [Seleccionar] Expandir


#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): 

Código (vbnet) [Seleccionar] Expandir


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

Código (vbnet) [Seleccionar] Expandir


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.

[existe Gambas, un lenguaje similar]

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/

Cómo se puede decir... para que no resulte ofensivo... bueno, a la M13RD4, si se ofenden...

Alguien mínimamente crítico, va a confiar en un programa chino, que maneje dinero (cuentas bancarias, tarjetas)????.
Si hoy día chino, es casi sinónimo de mafioso y clonador... Probablemente China, sea el país con más hackers del mundo (y seguramente la mayoría a sueldo del gobierno).

Supongamos que Corea tiene capacidad de fabricar, impulsar y explotar con precisión el arma...  entonces a lo más que se puede llegar a dilucidar (si no es ininteligible y se habla sandeces), es que lo que querrían hacer sería atacar determinados satélites de EE.UU. porque hablar genéricamente de 'atacar a EE.UU.', carece de sentido...

Si estalla en el espacio, no veo ninguna forma de que 'atauqe' a EE.UU. si no a todo el planeta... si quiere atacar a EE.UU. debe detonarlo en tierras de EE.UU. ...o eso, o están creando sus propios cómics de ciencia ficción, para niños...

[ahora quieres guardar todos los datos de nuevo a otro fichero, pero manteniendo algún tipo de formato, ¿es así?]

tengo un txt. el txt me viene así, 0002254866villaruel garcia paco blablabla   blablabla.
he tenido que meter los datos a una matriz b. Para darle un formato correcto.
0002254866  villaruel garcia paco bla     blabla     blabla  bla.

la matriz quedaría algo asi b(i,200) = i filas, 200 columnas.

a cosa es que ahora me gustaría escribir todas las filas(i) en otro txt distinto al que tengo... y no se como hacerlo.

Bien, entonces tenías un fichero sin formato en el mismo, pero con un formato no implícito y (supongo que por claridad a la hora de consultarlo) ahora quieres guardar todos los datos de nuevo a otro fichero, pero manteniendo algún tipo de formato, ¿es así?.

Luego señalas que son 200 columnas... pero viendo el código que has puesto más abajo (salvo que hayas omitido parte por extensión), solo tienes 34 columnas (Navarra_101 hasta Navarra_134), tampoco es que corresponda al número de caracteres de cada línea, pués la última apunta al carácter 357 ( ...c0.Navarra_134_Nota) = linea.Substring(353, 357))

Ya te digo que si quieres escribir toda las 'i', estarás escribiendo todas las filas, es decir todo el contenido... salvo que estés refiriendo a escribir todas las filas para una determinada columna.

El código que tienes es una ensalada de cardo borriquero, le falta un toque para pasarlo de procedimental a objetos y proveer métodos acorde a lo que quieras hacer...

Ahora tengo que salir, a la noche si me has respondido (aclarado el punto que te señalo más arriba), te oriento...

Ten en cuenta que la herencia está más enfocada a la reutilización de código. Una interfaz se vale del mecanismo del paradigma de la POO, llamado Polimorfismo, cuyo objetivo principal es tener un comportamiento diferente, para los mismos métodos. El polimorfismo, no deja de ser una herencia, pero si no es bien entendido se desaprovecha su potencial, y bien entendido se hace herencias más sencillas y útiles.

[valores desordenados:]

Cuesta entenderte, de hecho ni siquiera estoy seguro de haberlo logrado...

Veamos, dices tener unos datos en un fichero txt y que estos están desordenados...
Qués es lo que está desordenados, los valores o los datos?.
por ejemplo:
valores desordenados:
144, 211, 083, 015, 202, 099
ordenados:
015, 083, 099, 144, 202, 211
-----------------------------------

datos desordenados:
13, 35, Juan Valdivia, 13856721, Perú, calle Sol;
06834965, 42, Calle de los álamos, Mejico, 156, Diego Centella
ordenados:
Nombre, edad, ciudad, calle, número, identificador;
Juan Valdivia, 35, Perú, Calle Sol, 13, 13856721
Diego Centella, 42, Méjico, Calle de los álamos, 156, 06834965
---------------------------------

Un array multidimensional, en realidad puede considerarse como un array unidimensional... con el añadido de que el acceso está 'cordinado' bajo un diseño específico.
Así un array como Array(0-9, 0-99, 0-1), tiene un tamaño de:
10*100*2=2000 (* número de bytes que ocupe el tipo de datos que almacena, si el tipo es un objeto, lo que se guarda ahí entonces es la dirección al objeto).
...y si imprimes la dirección donde se guardan los datos (basta el primero y  el último), verás que todos ellos están consecutivos en memoria.

Una forma fácil es forzar entonces la escritura a disco partiendo de la dirección del contenido en memoria es muy rápido, pero tiene sus pegas.. no todos los lenguajes habilitan de forma fácil el acceso a la dirección (desafortunadamente las funciones ptr... no son contempladas como pertenecientes a objetos, así pueden encontrarse en  clases de tipo Marshaling) la otra limitación es que si el array contiene objetos, tampoco sería util porque estarías guardando las direcciones de los objetos, no el dato (por ejemplo si son cadenas de texto), en resumen valdría solo para datos numéricos y buleanos.

De todos modos como no queda claro, en qué consiste ese orden que le quieres dar a los datos y el inespecífico "medida de las columnas dle array" (no sé si quieres señalar el tamaño de las dimensiones del array o si te refieres al ancho de las columnas de por ejemplo un control de tipo "Grid"...

Tampoco aclaras de qué lenguaje se trata, así que aventurando digamos de forma genérica que los objetos Streamwriter, StringWriter, StreamBuffer, etc... son adecuados para esos menesteres suelen tener métodos llamados Open para abrir un canal de escritura y Writebytes (con múltiples sobrecargas) para escribir los datos...
Y siempre puedes crear tus propios métodos, según el tipo de datos y hacerlo de forma un poco más manual recorriendo tu mismo el array y así escribiendo lo que te parezca y en el orden que prefieras... Para ello recurre a clases en el espacio IO que tienen métodos Write, para tipos de datos genéricos.

Lo que describes es lo que se llama una interfaz.

Una interfaz, recoge por lo general solo los nombres de los métodos que contiene el objeto... (la firma, sin contener código en su interior).
Luego hay que implementar la interfaz. Cada clase que implementa una interfaz hereda pues todos sus miembros, pero al implmenetarlos, cada uno puede hacerlo de forma distinta (incluso algunos pueden tener el mismo código para determinados métodos).

Si hay un comportamiento por defecto, para uno o varios métodos, entonces ese comportamiento puede estar descrito (escrito el código), en la propia interfaz y desde la clase que la implementa, si no tiene un comportamiento distinto a la de la interfaz (el comportamiento por defecto), entonces para ese método se invoca a la interfaz).
... pero ojo, la interfaz no debe retener métodos privados, ya que si no serían sobrescritos por clases diferentes y no sería algo deseable (cuando es deseable suele ser en casos en los que actúa como un servidor y admite que diferentes 'componentes' (objetos), puedan modificarlo y los demás puedan aceptarlo (pero esto es algo muy distinto a lo que tú buscas)).

Código [Seleccionar] Expandir

Interfaz Planta

enumeracion TipoDehojas  
  Perenne=0
  Caducifolio=1
fin enumeración

propiedad Nombre
Propiedad Raiz  ' valor fijo para propiedad...
  Raiz = True
fin propiedad
propiedad Hojas(modelo como TipoDehojas))
propiedad Fruto
propiedad Tallo
propiedad FechaDeRecoleccion
método Madurar(CantidadFrutos)
método Floracion(Cantidad, Color)
método Recolectar( P como Planta, fechaActual) como buleano
   Si p.FechaDeRecoleccion >= fechaActual luego
       Mostrar mensaje "Ha llegado la hora de recolectar."
       Devolver cierto
   fin si ' devuelve falso   
fin metodo

' si hubiera métodos privados, las clases que implementen la interfaz, no requieren implementarlos... o si los necesita puedne llamarse de forma diferente y contener parámetros distintos.


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

Código [Seleccionar] Expandir

Clase Amapola implementa Planta

miembro privado _TipoDehojas como TipoDeHojas
miembro privado _FechaDeRecoleccion numero

propiedad Nombre
  Devolver "Amapola"
fin propiedad
propiedad Raiz   'ejemplo que delega en algo por defecto.
  Devolver Planta.Raiz
fin propiedad

' Nota que por simplicidad se ha puesto propiedad x... como representación de lo que corresponda: lectura y escritura/solo lectura/ solo escritura)
' Aquí se representaría Write y Read de la propiedad Hojas
propiedad HojasW(modelo como TipoDehojas)
   _tipoDehoja=modelo
fin propiedad
propiedad HojasR como TipoDehojas
   devolver _TipoDeHojas
fin propiedad

propiedad Fruto....
...
...
...
propiedad FechaDeRecoleccion
     devolver _FechaDeRecoleccion
fin propiedad

método Madurar(CantidadFrutos)
....
fin metodo
método Floracion(Cantidad, Color)
   llamar AumentarFlores(Cantidad)
   llamar CambiarColores(Color)
Fin método
método Recolectar( P como Planta, fechaActual) como buleano ' método por defecto...
    llamar Planta.Recolectar(Esta Amapola, FechaActual)
fin metodo


metodo privado AumentarFlores(cantidad)
...
fin metodo
metodo privado CambiarColor(Color)
...
fin metodo




Otra planta, podría tener una floración diferente, pero en cambio la propiedad Hojas  no tenga diferente contenido de la anterior pero cada cual debe guardar ese dato sobre sí mismo... La propiedad Raiz, sobre todas tendrán raíz, pero es un modo dever como se delega en la interfaz cuando algo es común. Algunos lenguajes no permiten a un interfaz nada más que definir su composición, no admitiendo código alguno.
Quizás en vez de implementar directamente una planta u otra, si uno va a implementar 8pongamos) cientos de plantas, es seguro que mucha funcionalidad va ser equivalente en un muchas plantas, entonces es cuendo se puedne implementar sólo determinadas ramas de plantas (por ejemplo acuáticas, cereales, legumbres, tuberculo, arbol, etc...) y luego las diferencias entre las diferentes plantas heredarlas de la clase padre.... (por ejemplo: trigo, centeno, maíz, heredarla de la clase cereal, que podría mantener una característica 'espigas' que en la interfaz podría ser algo más abstracto, partiendo de la propiedad Fruto, que podría ser una enumeración desde "no tiene" hasta el resto "grano de espiga", "grano de vaina", "fruta fresca", "fruto seco", etc...