Mensajes

Hay que mirar el manual de la placa base.
En él se menciona los bancos de memoria que tiene , de qué tipo y si es ECC o no ECC.
Por ejemplo, si resulta que tu placa base admite 2 módulso de 4Gb. pués sería preferible comprar 1 módulo de 4Gb. (y si acaso más adelante otro de 4Gb.), en vez de adquirir uno de 2Gb. para tener 4Gb.

El manual se suele descargar de la web del fabricante, para eso se precisa tener la marca y el modelo de la placa base... dichos datos suelen estar a un laod de la CPU, a menudo entre éste y  la memoria o entre la CPU y la tarjeta gráfica...

Señala la marca y modelo, y veamos si existe aún un punto de descarga en la web del fabricante... (depende de la antigüedad de la propia placa base).

[a 20 personas]

Actualmente el Gobierno a matado a 20 personas, 80 estan desaparecidas 400 detenidas y 800 heridas, son cifras de hace 1 dia o 2.

Los muertos contados hasta hace unas horas eran 38... teniendo en cuenta el cambio horario, antes que acabe el día (allí) podrá crecer...

Me ha dado tiempo a rehacer lo que habíamos hecho, el resto es más de lo mismo y mañana en otro ratito lo completo... Al lío...

Dado que ahora tendremos varias categorías, es más eficiente crear una interfaz e implementar una clase por cada categoría, que andar complicando algoritmos con condicionales.

El código que tenías del proyecto previo, guardalo o bórralo... los cambios manuales son demasiados y es preferible copiar y pegar.

Añade un interfaz al proyecto. Este es el código de la interfaz:

Código (vbnet) [Seleccionar] Expandir


Public Interface ICombina

   ''' <summary>
   ''' Cantidad de valores enumerados.
   ''' </summary>
   ReadOnly Property Cantidad As UInt32

   ''' <summary>
   ''' Recrea el array de las combinaciones al inicio.
   ''' </summary>  
   Sub Enumerar()

   ''' <summary>
   ''' Decodifica el valor enumerado en la posicion indicada, a 6 pares de valores numericos.
   ''' </summary>
   ''' <param name="Index">Indice de la enumeracion solicitado</param>
   ''' <param name="Decenas">Array de los digitos que (ademas) pueden actuar como decenas</param>
   ''' <param name="Unidades">Array de los digitos que solo pueden actuar como unidades</param>
   ''' <returns>Devuelve la combinacion con las 6 apuestas separadas por ', '"</returns>
   Function Tranformar(ByVal Index As Int32, ByRef Decenas() As Byte, ByRef Unidades() As Byte) As String
End Interface

Los comentarios los puedes borrar si lo prefieres...
NOTA: La interfaz debe llamarse como figura ahí... luego que esté todo el código, podrás cambiarlo si lo prefieres.

Añade un módulo de código si no tienes alguno. Algunas funciones y extensiones de métodos se han trasladado aquí. es código estático (independiente de cualquier instancia). Este es el código a añadir dentro del módulo:

Código (vbnet) [Seleccionar] Expandir


   <Extension()>
   Public Function EnRango(ByVal Valor As Byte, ByVal Minimo As Byte, ByVal Maximo As Byte) As Boolean
       Return ((Valor >= Minimo) And (Valor <= Maximo))
   End Function
   <Extension()>
   Public Function EnRango(ByVal Valor As Char, ByVal Minimo As Byte, ByVal Maximo As Byte, ByVal Tope As Byte) As Boolean
       Dim asci As Byte = (Strings.Asc(Valor) - Tope)
       Return ((asci >= Minimo) And (asci <= Maximo))
   End Function


   Public Function EnumeraComb(ByRef Inicio As String, ByRef Final As String, ByVal Cantidad As UInteger) As String()
       Dim k As UInt32 = 0
       Dim Combina As String = Inicio
       Dim Maxchar As Byte = IndexLastChar(Inicio, Final) ' Final.Chars(Final.Length-1)
       Dim Permutas(0 To Cantidad - 1) As String
       Dim digitos(0 To 5) As Byte, n As Byte = 0

       For k = 0 To 5
           digitos(k) = k
       Next

       k = 0
       Do
           Permutas(k) = Combina
           If (digitos(5) = Maxchar) Then
               n = 4
               Do While Combina.Chars(n) = Combina.Chars(n + 1).Previo   '    digitos(n) = digitos(n + 1) - 1
                   n -= 1
               Loop

               digitos(n) += 1
               For n = n + 1 To 5
                   digitos(n) = digitos(n - 1) + 1
               Next

               Combina = "" ' 0
               For n = 0 To 5
                   Combina &= CharIndexAZ(digitos(n)) ' * (10 ^ (5 - n))
               Next
           Else
               Combina = Combina.NextComb()
               digitos(5) += 1
           End If
           k += 1
       Loop While (Combina < Final)
       Permutas(k) = Combina

       Return Permutas
   End Function

#Region "Las siguiente funciones y extensiones son solo de ayuda para la función anterior (enumerar)."
   <Extension()>
   Private Function NextComb(ByRef Combina As String) As String
       Dim Last As Byte = Asc(Combina.Chars(5))  ' ojo Estamos usando siempre longitudes de 6 caracteres.
       Return Strings.Left(Combina, 5) & Strings.Chr(Last + 1)
   End Function

   ''' <summary>
   ''' Calcula el caracter previo en la secuencia ASCII.
   ''' </summary>
   ''' <param name="Ch">Caracter en el rango A-Z</param>
   ''' <returns>Devuelve el carácter previo al dado (en la secuencia ASCII).</returns>
   ''' <remarks></remarks>
   <Extension()>
   Private Function Previo(ByRef Ch As Char) As Char
       Dim n As Byte = Strings.Asc(Ch) - 1
       Return Strings.Chr(n)
   End Function

   Private Function CharIndexAZ(ByRef Index As Byte) As Char
       Return Strings.Chr(65 + Index)
   End Function

   ' Devuelve la distancia entre el primer caracter de inicio y el último de 'final'
   ' Ejemplo: "'A'BCDEF" "EFGHI'J'" = 10;  "'A'BCDEF" "MNOPQ'R'" = 17
   Private Function IndexLastChar(ByRef Inicio As String, ByRef Final As String) As Byte
       Dim F As Byte = Strings.Asc(Final.Chars(Final.Length - 1))
       Dim I As Byte = Strings.Asc(Inicio.Chars(0))

       Return (F - I)
   End Function
#End Region


Se ha añadido alguna función, la principal es 'enumerarCombinacion'.
Las extensiones de métodos, son métodos que simplemente cambia la forma en que se llaman.
Si tu creas por ejemplo una función Ordenar que ordena un array, lo llamarías así:

Código (vbnet) [Seleccionar] Expandir

call Ordenar(elArray, parametro1, parametro2)
Mediante una extensión, resulta más cómodo, pués se recurre al intellisense, para que pueda invocarse así:
 

Código (vbnet) [Seleccionar] Expandir

elArray.Odenar(parametro1, parametro2)
Con lo que parece un método nativo más del tipo de datos al que se extiende. Naturalmente la extensión solo es aplicable al proyecto actual.

Finalmente volvemos a la ventana principal... (se asume que ahora mismo está vacía).

Código (vbnet) [Seleccionar] Expandir


Public Class Form1
   Private perm24, perm33, perm42, perm51,perm60 As ICombina
   Private Decenas() As Byte, Unidades() As Byte

   Public Sub New()
       InitializeComponent()
       ' Crear las instancias una única vez.
       perm24 = New Permutas2_4
       perm33 = New Permutas3_3
       perm42 = New Permutas4_2
       perm51 = New Permutas5_1
       perm60 = New Permutas6_0
   End Sub


   Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
       Dim Nums() As String, txt As String
       Dim k As UInt16, n As Byte
       Dim Permuta As ICombina

       txt = TextBox1.Text.Replace(" ", "")
       Nums = txt.Split(",")
       If (Nums.Length = 6) Then
           Array.Sort(Nums)
           Do While (Nums(n).Chars(0).EnRango(0, 4, 48) = True) And (n < 5)
               n += 1
           Loop

           If (n.EnRango(1, 5) = True) Then
               ReDim Decenas(0 To n - 1)
               ReDim Unidades(0 To 6 - n - 1)

               For k = 0 To n - 1
                   Decenas(k) = System.Byte.Parse(Nums(k))
               Next
               For k = n To 5
                   Unidades(k - n) = System.Byte.Parse(Nums(k))
               Next

               Select Case n
                   Case 2 : Permuta = perm24
                   Case 3 : Permuta = perm33
                   Case 4 : Permuta = perm42
                   Case 5 : Permuta = perm51
                   case  6: Permuta = perm60
               End Select

               ListBox1.Items.Clear()
               For j = 0 To Permuta.Cantidad - 1
                   ListBox1.Items.Add(Permuta.Tranformar(j, Decenas, Unidades))
               Next
               Label3.Text = "Cantidad en lista: " & Permuta.Cantidad.ToString ' ListBox1.Items.Count.ToString
           Else
               MessageBox.Show("No se puede generar combinaciones si no hay 2-5 dígitos menores de 5.")
           End If
       Else
           MessageBox.Show("No, no no... Debe haber 6 y solo 6 numeros, separados por 1 coma...")
       End If
   End Sub
End Class


Se han sacado las clases fuera de la clase del formulario, por claridad.
Ahora hay una instancia de la interfaz 'ICombina', por cada categoría...
Se considera una categoría, a cada diferenciación en la relación de cantidad entre dígitos que pueden ser decenas de los que no.
Un ejemplo: Sean los dígitos 3, 6, 8, 0, 5, 1  ...hay 3 valores que pueden ser decenas: 0,1 y 3, luego pertenecen a la categoróa asociada a la intancia 'perm3_3 (3 decenas y 3 unidades, para qué complicarnos más en el nombre).
Esta diferenciaciónd e categorías es necesaria, porque cada una presenta diferente cantidad de firmas, como ya se señaló en el mensaje anterior.
en lo que al código de la función del botón respecta, para hallar a qué categoría pertenece, tras crear el array con los dígitos (nums), lo ordenamos, ahora un recorrido con un bucle nos permite contarlos, y luego selecciona la clase que operará conforme a la categoría reconocida.
Se descartan los casos en que haya 0 o 1 decena solo (5,5,6,7,8,9) y (2, 5,6,7,8,9) y también cuando sean 6 decenas (esto directamente lo he descartado, generaría varios millones de combinaciones)

En la misma ventana del formulario, bajo la clase de dicho formulario, irán la implementación de cada clase.
Como digo, de momento, solo he dejado lista, la conversión d ela primera (que es equivalente a la que ya hice), las otras son básicamente rehacer lo mismo con pequeños cambios en la función transformar, ya mañana en otro ratito, lo completo.

Código (vbnet) [Seleccionar] Expandir



Friend Class Permutas2_4
   Implements ICombina

   Const MAX_COMBINAS As UInt16 = 210
   Private s_Combinas() As String     ' UInt32

   Public Sub New()
       Call Enumerar()
   End Sub

   Public ReadOnly Property Cantidad As UInteger Implements ICombina.Cantidad
       Get
           Return MAX_COMBINAS
       End Get
   End Property

   ' Para generar las permutaciones, delega en la función que yace en el módulo.
   Private Sub Enumerar() Implements ICombina.Enumerar
       '             combinacion inicial, final, Total combinaciones
       s_Combinas = EnumeraComb("ABCDEF", "EFGHIJ", MAX_COMBINAS)
   End Sub

   ' Alfabeto = X,Y,   R,S,T,U
   '  A   B   C   D   E      F   G   H   I   J
   '  XY  XR  XS  XT  XU     YR  YS  YT  YU  YX            
   Public Function Tranformar(ByVal Index As Integer, ByRef Decenas() As Byte, ByRef Unidades() As Byte) As String Implements ICombina.Tranformar
       Dim permuta As String = s_Combinas(Index)
       Dim s(0 To 5) As String, valor As String = ""
       Dim x As Byte = 0, k As Byte

       For k = 0 To 5
           x = (Strings.Asc((permuta.Chars(k))) - 65)

           Select Case x
               Case 0 : x = ((Decenas(0) * 10) + Decenas(1))
               Case 1 To 4 : x = ((Decenas(0) * 10) + Unidades(x - 1))
               Case 5 To 8 : x = ((Decenas(1) * 10) + Unidades(x - 5))
               Case 9 : x = ((Decenas(1) * 10) + Decenas(0))
           End Select

           If (x < 10) Then s(k) = "0" & x.ToString Else s(k) = x.ToString
       Next

       Array.Sort(s)
       Return Join(s, ", ")
   End Function
End Class


Y eso es todo por hoy. Mañana lo completo.
Nota que ya se ha aprovechado para ordenar los elementos de cada combinación así además de estar el listado ordenado, también los valores de cada combinación.


p.d.: Corrijo, con 6 dígitos como decenas, se generan muchas menos firmas, cuando lo calculé ayer, creí haber leído millones... pués nada, mañana se incluye también y se hace el cambio pertienente para contener su clase y en la llamada del botón considerar el caso.

p.d.: Corregido cantidad de combinaciones para 4_2 y 5_1

[Se divorcia tras 27 años de relación el único informático que tenía pareja]

Se divorcia tras 27 años de relación el único informático que tenía pareja

Bueno, pudo ser un fallo del driver del 'ratón'... (se sabe con el tiempo, son proclives a gatillazos y se mueve por la pantalla aleatoriamente).
...y pudo haber sido peor si le hubiera salido BSOD, o si su pareja le hubiera puesto los cuernos con el pingüi...

Acude directamente a la policía nacional (al apartadod e renovación de DNI) y alega extravío del DNI, te darán cita para hacerte otro nuevo y te dirán que papeleo necesitas, señala que tienes tu identidad francesa por si vale... típicamente en casos complicados (cuando no tienes otra documentación que pueda acreditar quien eres) se reclama una partida de nacimiento. Mientras tengas otra documentación (quizás un pasaporte?), no debería ser más problema.
...ahora, no recuerdo si en caso de pérdida, te cobraban cierta cantidad, te lo harán saber si es el caso.

[03?]

Hola.
Hoy he llegado tarde del trabajo, pero todavía he sacado un tiempito para calcular las cantidades...

Dado que (ahora) varía la cantidad de unidades y decenas que pueden aparecer, lo adecuado es categorizar, pués a unidades iguales las firmas son las mismas, resumiendo:

- Con 0 decenas y 6 unidades: No puede darse: ej: 5,6,7,8,9 ?
  Falta 1 dígito para poder formar 6 'apuestas'.

- Con 1 decenas y 5 unidades: Puede o no aceptarse (técnicamente no, pues estaríamos inventando un dígito 0): ej: 3;  5,6,7,8,9
35, 36, 37, 38, 39, 03?
En cualquier caso si se aceptara, sería una sola combinación y por tanto puede 'calcularse' manualmente. Luego puede dejarse fera.

- Con 2 decenas y 4 unidades: Salen 210 firmas distintas (son las calculadas anteriormente).
XY-RSTU
-------------------
XY XR XS XT XU
YX YR YS YT YU
Ej: 0,1,___6,7,8,9
10, 08, 09, 16, 17, 19

- Con 3 decenas y 3 unidades: Salen 5.005 firmas.
XYZ-RST
-------------------
XY XZ XR XS XT
YX YZ YR YS YT
ZX ZY ZR ZS ZT
Ej: 0,1,2,___ 7,8,9
  20, 17, 28, 09, 27, 12

- Con 4 decenas y 2 unidades: Salen 38760 143.080 firmas.
WXYZ-RS
-------------------
WX WY WZ WR WS
XW XY XZ XR XS
YW YX YZ YR YS
ZE ZX ZY ZR ZS
Ej: 0,1,2,3,___ 8,9
38,39,13, 01,29, 12

- Con 5 decenas y 1 unidad: Salen 177100 402.895 firmas.
VWXYZ-R    
-------------------    
VW VX VY VZ VR
WV WX WY WZ WR
XV XW XY XZ XR
YV YW YX YZ YR
ZV ZW ZX ZY ZR

Ej: 0,1,2,3,4,___ 9
  20,31,49, 43, 40

En total se aproximan al 1/4 de millón suben por encima del medio millón (y solo son las firmas).

p.d.: Mañana que vengo con más tiempo veré si me da tiempo a hacerlo.
p.d.2: Actualizado los valores de las combinaciones (había un error).

[Dados 6 digitos cualquiera que sea el orden en que se den, se trata de obtener con ellos todas las combinaciones posibles legales]

A ver si he entendido bien, y simplificando:

Dados 6 digitos cualquiera que sea el orden en que se den, se trata de obtener con ellos todas las combinaciones posibles legales (agrupadas de 6 en 6, claro).

Así, un dígito podrá ponerse como decena siempre que sea menor de 5, y un digito mayor de 5 solo podrá ponerse como unidad.

Un ejemplo: 7,9,2,1,8,0

01, 12, 17, 18, 19
10, 12, 07, 08, 09
20, 21, 27, 28, 29
...

Es así?

Todavía no me queda claro, si podría ser válido algo como:
01, 11, 22, 27, 28, 29
Es decir se permite que si un dígito es menor de 5, combinarse consigo mismo, o queda restringido a combinarse solamente con los demás?.
Si no se permite el único modo de formar 11, 22, 33 y 44, es que aaprezca 2 veces ese dígito, como en:
3, 2, 5, 7, 2, 6

te recomiendo win_7 para tu cuero cabelludo unas gotitas de minoxidil al 5% por 1 año y una pastilla interdiaria de finasteride al 1% por 6 meses

Probablemente win_7, tenga una medicación asignada. No procede para determinadas personas siquiera insinuar que se administren tal o cual cosa... Caulquier sustancia (al menos las que son de aplicación interna), requieren la supervisión médica (o psiquiátrica cuando es el caso). El médico debe evaluar efectos secundarios o incompatibles derivados de una actual medicación.

Y por cierto el minoxidil, no vale para nada...
Allá por el 90, un amigo que ya empezada a registrar entradas en su cuero cabelludo y que era incapaz de aceptar su imagen se puso en manos de '5V3N50N' (que se suspone que son especialistas en eso), después de 1 año, dejó el tratamiento... con cada 'dosis' de minoxidil que se acompañaba de un masaje del cuero cabelludo.
El resultado fue (al margen del cuantioso desembolso económico) que tardó un año en darse cuenta que no surtía ningún efecto y que a lo sumo se podría retrasar y que incluso en ese caso sería más factible que fuera un efecto del masaje que del producto. ...pero ahí siguen, 30 años después insistiendo en 'un producto nuevo...' (supongo que por miedo a denuncias si pusieran 'milagroso').

Ok. Gracias! Però se nota que no me lo he cortado bien el pelo de la cabeza?

No te preocupes... un ciego que pase por Alaska, no lo notará...
...y en poco tiempo acabará creciendo lo suficiente como para cubrir cualquier irregularidad.

[2]

estoy haciendo pruebas con varios ejemplos y en una de ellas pongo 2 3 4 6 7 8 y no me salen combinaciones con el cuatro si de terminal estilo 24 34 pero no me salen con el cuatro 42 43 etc etc .

Esa combinación de dígitos, empieza por 2 y 3, Los dos primeros dígitos de la serie,  son los únicos dígitos que son (pueden ser) decenas, los otros 4 solo pueden ser unidades...
Si el 4 ha de aparecer como decena, deberá intercambiarse por alguno de los dos primeros:
Si tienes 2 3 4 6 7 8 y quieres que el 4 aparezca en las decenas, intercámbialo por ejemplo por el 2:
2 3 - 4 6 7 8
4 3 - 2 6 7 8

Insisito en que fue lo que tú indicaste. Te pedí ejemplos, para en el caso de alguna ambigüedad resolver dudas consultando los ejemplos (a veces puede resultar más fácil terminar de expresar, o acotar lo que alguien quiere poniendo ejemplos)...

yo tengo  6 dígitos  ejemplo  2 3 5 6 8 9 <--- esos números deberán de formar parejas de esta forma :

de este grupo se toma el 2 y 3 solamente y se combinan con el resto :  5 6 8 9  formando pares de dígitos :
estos son los números resultantes
23  25  26 28 29
32  35  36 38 39
Resultado de esa combinación es esta ...
23,25,26,28,29,32
23,25,26,28,29,35
23,25,26,28,29,36
23,25,26,28,29,38
23,25,26,28,29,39
23,25,26,28,32,35
23,25,26,28,32,36
23,25,26,28,32,38
23,25,26,28,32,39
23,25,26,28,35,36
23,25,26,28,35,38

Si resulta que eso es solo mi interpretación de tu especificación, es que entonces es inexacta, o cuando menos incompleta y exigíria redefinirla con exactitud y rehacerlo todo...

y lo de las 210 combinaciones no es limitante se supone que con otro digito saldrán mas combinaciones ,no te preocupes por lo demás que aunque no sea experto ,se como hacer que guarde, imprima libere las variables etc

No. Esas son todas las formas de ordenar los dígitos en las condiciones (actuales) establecidas.
Antes bien, según los dígitos pasados, se formará alguna combinación ilegal... No se filtran porque se da por sentado que uno sabe reconocer que cualquier valor fuera dle rango 01-49 es inválido.


En realidad, a estas alturas asumo que lo que quieres, no encaja con la especificación resuelta.
Podemos hacer un último intento, pero considera entonces que no me pondría con ello mientras no quede todo perfectamente determinado, sin dudas y sin ambigüedades.
Rehacer cosas por emerger requisitos que no se dieron cuando se solicitaron, es algo siempre muy molesto y propenso a ser rechazado (porque implica que todo el tiempo previo empleado es completamente inútil, lo que no ofrece garantías de que ahora no fuera a ser distinto)...
Y hay que poner ejemplos, sobre todos de los casos 'irregulares', porque cuando uno no se expresa bien, puede verse plasmado en los ejemplos cierta intencionalidad...

Considera que el número total de combinaciones de la primitiva eleigiendo 6 número distintos entre el 1 y el 49, viene acotado por la fórmula: (49*48*47*46*45*44) = 10.068.347.520
Con ello quiero indicar que si tu acotación no restringe en cierta medida el número de combinaciones posibles, se puede disparar y resultar impráctico... si al final salen 2 millones de combinaciones (por ejemplo), que aunque sea una minucia respecto de la totalidad, carece de practicidad albergarlas en un listbox y mucho menos recrearlo con cada cambio de uno u otro dígito. Elegir unas pocas combinaciones entre 2 millones, al final no es muy distinto de elegirlas de entre los 10 mil millones...
La quiniela por ejemplo son 3^14 = 4.782.969 de permutaciones totales.

es que no se como pasar una toma de pantalla para que veas que es lo que hago,  porque no entiendo si pongo 1 3 4, 6 7 8 no me salen combinaciones con el cuatro adelante ???

Hay una tecla (Impr Pant) suele estar a la dercha de la tecla F12 (segúne el teclado). Eso hace una captura de la pantalla. Se abre un programa de im agen (basta cualquiera por simple que sea, que permita rcortar y guardar a fichero), se pega la imagen (teclas CTRL+V), y se edita... normalmente para recortar el área que es de interés, se copia y pega la selección (del recorte) como nueva imagen. Luego se guarda a fichero como jpg... cuando tiene texto, e spreferible como png, que conserva mejor los detalles de las letras.
Después se localiza el fichero en el disco, y se sube a una página de subida de imágenes (por ejemplo https://www.imgur.com ).
Después de subirla a una página, hay que tomar en enlace (de los que ofrezca elegir uno que ponga 'bbCode para foros'), y se pega el enlace en tu respuesta...
En realidad se tarda más en explicarlo con detalle que en hacerlo.

[y a veces tendría que introducir ejemplo ( 1 , 2 ,4 - 5,7,8 ) y ahora el programa para las combinaciones no toma el cuatro solo el 1 y 2]

en el ejemplo anterior usas los números que pongo de ejemplo  " 2, 3, 5,6,8, 9 " pero estos números cambian después de cada sorteo (después os explicare como los saco)

Que yo ponga ciertos valores de ejemplo, son solo para eso, para ver un ejemplo en marcha. Y puesto a poner un valor de ejemplo, qué mejor que poner los mismos que tu, que se supone que has probado y conoces de la guna manera su resultado, tal que un vistazo te permita descubrir si en efecto hace o no como se espera.
Es lógico que esos números cambien con cada sorteo-ocasión... por eso son variables , si no serían constantes y si fueran constantes, entonces bastaría calcularlos una vez al inicio y no haría falta ningún botón...
Lo que quiere decir... que los cambies por otros cualesquiera que necesites a cada ocasión (dentro de lo que admite)...

según voy entiendo el código este toma solo los dos primeros y los combina con el resto ,bien el tema es que como sabemos las decenas son hasta el cuatro y a veces tendría que introducir ejemplo ( 1 , 2 ,4 - 5,7,8 ) y ahora el programa para las combinaciones no toma el cuatro solo el 1 y 2

Código (vbnet) [Seleccionar] Expandir


txt = TextBox1.Text.Replace(" ", "")
Nums = txt.Split(",")


Esa linea de código, lo único que hace es eliminar espacios en blanco...
La siguiente línea de código, lo que hace es construir un array con cada elemento que resulte tras una coma...
Si te fijas en tu texto (que he resltado en negrita y de color rojo), entre el 4 y el -5 falta una coma, luego el 'split' fallará en obtener 6 números, ahí obtendrá una cadena de texto que al intentar parsearlo (yo puse byte.parse, no resulta preciso poner byte.Tryparse, cuando uno mismo es quien escribe los datos, no proceden de una fuente desconocida que 'a saber lo que contiene...'). Más aún, puesto que falta una coma, solo se hallarán 5 indices para el array, luego te saldrá un mensaje diciendo que deben ser 6 numeros separados por coma.

Por otro lado (cuando pongas la coma en su sitio), si los dígitos decimales van del 0 al 9, no entiendo por qué pones -5. Recuerda que yo no he puesto más interceptor de errores que distinguir si hay 6 indices en el array. Cada uno de esos valores deben ser 1 solo dígito entre el 0 y el 9, y los dos primeros restringido a un valor entre 0 y 4.
Debes ceñirte al formato que tú mismo especificaste mensajes atrás.

' <<<<<<<<<<<<<<   ACA CAMBIAN LOS NUMEROS NUNCA SON LOS MISMOS
'...Y DEBE TOMAR HASTA EL DIGITO 4  SABEMOS QUE LAS DECENAS SON 0 1 2 3 Y 4

Vamos a ver... tu premisa era que los dos primeros dígitos (solo 2), apuntaban al valor de decenas y los otros 4 siguiente (siempre 4), a los valores de las unidades...
Entonces si son solo los dos primeros dígitos, cuál es el problema?. Pueden tomar valores 0-4, pero 'valores', siempre serán solo 2 dígitos... ejemplos:

Dec   Unidades
------------------
0,4,    1,6,2,4
2,3,    1,4,0,9
4,2,    6,8,1,3
Como se ve siempre hay dos conjuntos:
- El de decenas son siempre dos dígitos, cuyos valores pueden variar entre el 0 y el 4.
- El de unidades son siempre 4 dígitos, cuyos valores pueden variar entre el 0 y el 9.
Tienes que separar conceptos... En ninguna parte se ha dicho que las decenas hayan de ser cualesquiera dígitos cuyo valores caiga en el rango 0-4, solo se refiere a los 2 primeros dígitos.

...pues esa fue tu premisa, te cito:

yo tengo  6 dígitos  ejemplo  2 3 5 6 8 9 <--- esos números deberán de formar parejas de esta forma :
de este grupo se toma el 2 y 3 solamente y se combinan con el resto :  5 6 8 9  formando pares de dígitos :

Este código, precisamente tiene por objeto obtener como parámetros ambos valores, fíjate como yo los 'desmonto' en dos parámetros (el 'tutti-fruti' es muy mala idea en programación).

' crear los parámetros para la funcion de Transformacion:
          ' Los dos dígitos de las 'decenas':
           Decenas(0) = System.Byte.Parse(Nums(0))
           Decenas(1) = System.Byte.Parse(Nums(1))

          ' Los 4 dígitos de las 'unidades':
           For k = 2 To 5
               Unidades(k - 2) = System.Byte.Parse(Nums(k))
           Next

Lo ideal es que cada uno tuviera su propio textbox, y para impedir introducción de datos incorrectamente mejor usar controles específicos, por ejemplo controles 'numericUpDown', que puedes limitar sus valores con sus propiedades minimun y maximun (abajo te pongo un dibujo a mano alzada de como podría ser), aunque dichos controles, no tienen opción de bloquear valores individuales más allá del rango definido por las propiedades antedichas:




Esto suele ser ineficiente... recorrer todos los controles, para vaciar el contenido de 8 o 10 textbox...

, he puesto un botón para limpiar y poder hacer pruebas y el código va de maravilla ,pongo el código y algunas observaciones  a ver que te parece ?
Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click
       For Each obj As Control In Me.Controls
           If (TypeOf obj Is TextBox) Then
               obj.Text = ""
           End If
           If (TypeOf obj Is GroupBox) Then
               For Each caja As Control In obj.Controls
                   If (TypeOf caja Is TextBox) Then
                       caja.Text = ""
                   End If
               Next
           End If
           ListBox1.Items.Clear()


       Next
   End Sub

Es preferible otras alternativas:
Cuando son pocos textbox (pongamos 4-12... uno mismo decide cuando son pocos).

Código (vbnet) [Seleccionar] Expandir


Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click
   Textbox1.text = ""
   OtroTextbox.Text =""
   txtboxNumero.text = ""
   txtBoxCantidad.text=""
   ' ...
end sub


Cuando son una cantidad moderada (>12, por ejemplo)
Se adjunta una variable de tipo coleccion y en New (tras la llamada a InitializeComponent, o incluso mejor en 'InitializeComponent' al final del todo) se introduce cada control que deba ser borrado de una tacada cuando se pulse el botón 'reset'.

Código (vbnet) [Seleccionar] Expandir


private ColTxtBox as new collection

private sub New(...)
   call InitializeComponent

   call AddTextBoxToCollection '<--- OJO: No antes de InitializeComponent
end sub

private sub AddTextBoxToCollection
   ColTxtBox.add(Textbox1)
   ColTxtBox.add(OtroTextbox)
   ColTxtBox.add(txtboxNumero)
   ColTxtBox.add(txtBoxCantidad)
   '...
end sub

' Cuando deban ser borrados:
Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click
  dim txtbox as textbox

   for each txtbox in ColTxtBox
       txtbox.text = ""
   next
end sub


Y por último... cuando la cantidad es inmensa y sobretodo si además de borrar el contenido de los textbox hay que restablecer otras propiedades de otros objetos:
Es preferible crear una ventana modal, que contenga toda esa interfaz... cuando se quiera borrar todo, o sea hacer un reset... simplemente se cierra la ventana... como cerrar la ventana no es intuitivo de lo que implica, se añade un botón 'Reset' (y dicho botón lo hace de forma transparente al usuario).

Desde la ventana principal (o una función main, si esa ventana resultase ser toda la interfaz del programa):
- Añade un modulo de código...
- Esto iría en dicho módulo y debe indicarse en las propiedades del proyecto, que la aplicación arranca desde 'Main' (en NET se exige que primero debe añadirse el módulo, si no no estará disponible dicha opción)...
- Para que incluso esa opción esté disponible, antes hay que hacer antes una de dos cosas (como tu caso no es una aplicación de consola, es la opción 'A'):
---- A - Desmarcar: "Habilitar marco de trabajo de la aplicación".
---- B - Marcar que es una 'aplicación de consola'...

Código (vbnet) [Seleccionar] Expandir


Module Module1
   Public ResetApp As Boolean

   Public Sub Main()
       Dim frm As Form1

       Do
           ResetApp = False        ' Si no se indica exprofeso, se cierra la app...
           frm = New Form1         ' crea la nueva ventana
           frm.ShowDialog()        ' la carga y hasta que no se cierre, no se ejecutará la siguiente línea de código.
           frm = Nothing           ' elimina el contenido actual
       Loop While (ResetApp = True)
   End Sub
End Module

En la ventana... añadimos un botón y el código asociado a dicho botón será:

Código (vbnet) [Seleccionar] Expandir


Public Class Form1
   Private Permuta As New Permutaciones
   Private Decenas(2) As Byte, Unidades(4) As Byte

   Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click
       Module1.ResetApp = True
       Me.Close()
   End Sub

   ' ...

Esa línea ("Module1.ResetApp = True"), es para distinguir cuando estás haciendo un 'reset' de cuando la aplicación termina de verdad, para salir del bucle en Main... sin ella será como 'el día de la Marmota' con Bill Murray...

Esto te permite reabrir la ventana cuantas veces quieras, sin necesidad de cerrar y abrir la aplicación y tendrás la interfaz en su estado inicial, ergo un reset, muy 'barato' en código... ya en la carga de la ventana uno se afana en que cada control tenga el valor inicial que deba tener, luego es preferible delegar en ello cuando es complejo y costoso restablecer un estado inicial.




Por último...  

 

Código (vbnet) [Seleccionar] Expandir


  ...

       Public Sub New()
           Dim combina As UInteger = 12345       ' combinacion inicial -----------NO ENTIENDO ESTO YA QUE LOS NUMEROS DE LAS DECENAS NO PUEDEN PASAR DEL 4
           Dim final As UInteger = 456789           '  combinación final --------------???????????????


Esos son valores que definen el inicio y final del bucle.
Cada dígito, representa sobretodo su posición... '012345' equivale a decir
0 el par de digitos XY
1 el par de dígitos XR
2 el par de dígitos XS
3 el par de dígitos XT
4 el par de dígitos XU
5 el par de dígitos YX
Son 2 dígitos, porque hay que formar 6 números, olvida que sean 012345, igual podría haber elegido letras... ABCDEF, pero tomandolo como números sale más eficiente en ´calculo' y más rentable en memoria (ocupan 2 bytes por indice, frente a un cadena representando 6 caracteres, que serían 6 bytes por indice).

Si 'descomentas' los dos funciones de abajo, añades un botón que referencie al código del botón (aquí se llama button2), y ejecutas el programa y pulsas el botón el listbox se llena con los valores de dicho array... son las 210 combinaciones en 'crudo', son combinaciones abstractas, la función transformar hace un cambio de codificación de los valores de ese array interpretando cada dígito conforme a los dígitos recibidos... es una traducción de código desde uno abstracto y fijo a uno específico, el código para interpretar dicho cambio son los dígitos recibidos.

Código (vbnet) [Seleccionar] Expandir

         
      Public ReadOnly Property Permuta(ByVal X As UInt16)
           Get
               Return s_Combinas(X)
           End Get
       End Property
   End Class

   ' Mostras la lista de permutaciones en el listbox.... va en conjunto con la propiedad 'Permuta' de la clase permutaciones.
   Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
       Dim k As UInt16, j As UInt32, s As String = ""

       ListBox1.Items.Clear()
       For k = 0 To Permuta.Cantidad - 1
           j = (Permuta.Permuta(k))
           If (j < 123456) Then s = "0" & j.ToString Else s = j.ToString
           ListBox1.Items.Add(s)
       Next
   End Sub
End Class

Ese array contiene las 210 permutaciones de forma 'condensada' (como la leche), que es más eficiente que recrear desde cero cada vez cada combinación... (la mitad del trabajo, la mitad más 'pesada' se hace una sola vez, durante la creación de la clase).

Que lo entiendas o no, ya depende de tus conocimientos y capacidades... pero te pondré un ejemplo:
Sean los días de la semana: Lunes, martes, miercoles...
Acaso no puede uno ejemplificarlos con números Lunes=1, Martes=2, miercoles= 3... (en programación sería una enumeración)...
Entonces yo luego podría querer almacenar datos en la forma: "el trabajador Luis, esta semana trabajó los días: 1,3,5,6". ...por que en una base de datos (por ejemplo), en ese formato ocupa mucho menos espacio que escribir los nombres de los 4 días en que ha trabajado... pero qué si luego uno quiere tener los días textuales, después de todo, uno no sabe 1 es lunes o es martes o incluso domingo...
...pues resulta que deberá haber una decodificación, un cambio de formato...

Código (vbnet) [Seleccionar] Expandir


dim dia as string

dia = DecodificarDia(3)
messagebox.show(dia)

function DecodificarDia(byval D as byte) as string
   Select case D
       case 1: devolver "Lunes"
       case 2: devolver "Martes"
       case 3: devolver "Miércoles"
       case 4: devolver "Jueves"
       case 5: devolver "Viernes"
       case 6: devolver "Sábado"
       case 7: devolver "Domingo"
       case else: devolver "Error, no existe el día: " & d.tostring
   end select
end function
Más aún... ese código, vale incluso si cambias de idioma, variando simplemente los valores constantes que son los nombres de los dias de la semana, bastando para ello un parámetro adicional 'idioma', y que derive a un select case u otro, o simplemente que cargue desde fichero, array, base dedatos, etc... los nombres de los días que corresponden al idioma entrado.
La función Transformar hace esto último, con cada día que se le pide (al caso se le piden todos)...

Ten en cuenta, que cambiar condicionantes en combinatoria, suele suponer tener que tirar todo y rehacerlo de nuevo, por eso antes de empezar, uno debe tener claro y fijo que es lo que pretende hacer. No hay fórmulas universales, tal que una modificación suponga solo cambiar un dato (que a veces pudiera ser, pero por lo general no). Un prisma, un cubo, una esfera... cada uno tiene su fórmula para calcular su volumen... aunque en tal caso si hay una solución universal si 'existe físicamente', pués se sumerge en un líquido y ya Arquímedes y su eureka, solucionaron el caso.

No sé si me dejo algo en el tintero, pero creo que ya queda un mensaje largo... adjunto el dibujo antes que lo olvide: