Mensajes

[El enlace que me has mostrado, es como contabilizar los números, y eso lo tengo echo]

NEBIRE: El enlace que me has mostrado, es como contabilizar los números, y eso lo tengo echo. Esa parte se me es fácil.

Sigo sin entenderte... a mi me dices esto...
Pero luego a electro, le respondes esto otro:

Gracias, eso (el código de Electro) separa los números, pero necesito una vez separado esos números contabilizarlos, lo que tendría que asignar cada número en una variable, ¿No es así?

Así que no hay quien entienda a veces que rayos pedís...

De todos hay un código mucho más fácil para convertir un número en un array, de los valores que lo componen...

Código (vbnet) [Seleccionar] Expandir


Private Function Splitter(ByVal X As Integer) As Char()
   Return x.ToString().ToArray()
End Function


Y en la imagen la llamada, y un despliegue del resultado:

En cuanto a lo de pensar un mínimo, llevo varios días buscando la forma, y pensando en como conseguirlo. Tengo hasta el SeudoCodigo echo, pero no logro encontrar la forma de separar los números y poder utilizarlos.

Varios días, ayyyyy... habría que ver el pseudocódigo que has hecho.

De todos modos el código del enlace que te daba, también separa los números (tanto si luego los cuentas como si no). De hecho, la conversión a array (ue hace VB, tras convertirlo a string, es más lento que esto: tomar las unidades del número y dividir entre 10, tomar las unidades, y dividir entre diez,  tomar las unidades del número y dividir entre 10, tomar las unidades del número y dividir entre 10... hasta que el valor a dividir sea 0... indicativo de que ya no hay más cifras...

mmmmm.....una caja de chapa... es una caja de chapa... si quieres gastarte 200 euros, por tener 4 lucecitas led, y 25 ventiladores innecesarios, allá tú.

Gástate el dinero, el lo primordial, no en tonterías.

Sobre la caja, es suficiente con que quepa todo lo que quieres montar (que sea el mismo formato (firm factor), que la que quieres poner en un futuro, seguramente el equipo que tienes es idéntica, así que te vale, pero si no quieres desmontar el PC actual, (por si un día el otro tiene un fallo y te lleva varios días rescatarlo, mientras puedas tirar con este, aunque viejo, funciona, no?)).
Es más si andas apurado de dinero, incluso un pc que tiran al contenedor, lo rescatas, retiras todo, lo limpias bien (si procede lo pintas), et voilá... listo. Ahora si quieres comprar una caja, para presumir ante tus amigos, pués vale gástate 100, 200, euros, o lo que tu veas...

p.d.: Si te compras una fuente de alimentación actual, puedes estar seguro que incorpora los conectores actuales. Los cables SIEMPRE tienen la longitud adecuada para unir desde la placa base al alojamiento en la caja para cada dispositivo, por algo se llaman "FIRM FACTOR", esto es...estándares con especificaciones, precisamente para evitar eso que temes.

[emanuek]

Esta pregunta, (al menos la primera parte), es idéntica a la que ya se respondió en:
http://foro.elhacker.net/programacion_cc/ayuda_algoritmo_para_calcular_el_numero_de_veces_que_una_cifra_se_repite-t470039.0.html

Lo que me fuerza a sospechar que:
- O el tema es una tarea del cole, que varios alumnos tienen que resolver...
- O el usuario emanuek, es también SlayerBur (¿para qué un registro duplicado?). Supongo que los moderadores podrán verificar si la IP de estos usuarios coincide, y por ende deducir que se trata del mismo usuario...

Básicamente la mayor parte de problemas, es de doble dirección, es decir: si avanzas x, giras a la derecha y, subes z, avanzas n, bajas t, giras a derecha s, subes k.... ir desde el final al comienzo, es hacer el camino inverso...

Lo que quiere decir, que si el problema anterior se resolvió tomando la unidad, y dividiendo entre 10, dentro de un bucle....esto se resuelve igualmente siguiendo el bucle... y si antes dividíamos entre 10, ahora multiplicamos por 10 y si antes extraíamos las unidades, ahora la sumamos...

No se debe resolver problemas a base de preguntar, porque entonces jamás en la vida termina uno de preguntar cada cosa, cada día. Hay que pensar un mínimo, y no rendirse a los dos minutos, porque a fin de cuentas este problema son matemáticas de 9-10 años... y programarlo, es básicamente "darle nombre" a cada operación.

p.d.: aunque releyendoel mensaje de nuevo, al final no queda claro, si quieres separar separar las cifras sueltas, o unirlas tras recibirlas sueltas.
...Si es separarlas y llevar la cuenta de cada una, ya se explicó en el enlace proporcionado... y siguen siendo matemáticas de 10 años... y un simple toque de programación.

Si vas justillo de dinero, quizás sea mejor que aguantes un año más con ese equipo mientras sigues ahorrando algo más...

Y mientras, puedes por ejemplo comprarte una tablet de entre 120-150 euros... Te da para navegar, ver pelis, oir música... y para lo más elemental sigues con el pc que tienes... algún programilla que suelas usar. Ya te digo que tu equipo no es tan viejo, ni mucho menos obsoleto... el mío (de casa) tiene ya 8 años y aquí sigue...

Puedes hechar cuentas:
- Una fuente de alimentación, piensa entre 80-100 euros.
- Placa base: 40-70 euros.
- Procesador: 120-150 euros
- Memoria: 130 aprox. Depende de cuanta... pero mira de coger un módulo DDR4, de 16Gb. (que en la placa base quede hueco para otro banco), tiempo más adelante puedes comprar otro de 16 y así tendrías 32 a la vuelta de 1-2 años.
- Unidad SSD: 240Gb. 90euros... No desprecies el disco duro que tengas, puedes montarlo con una segunda unidad. Y quizás poner un SSD de arranque.
--------------------
Total: 460-560 euros... y no será lo más potente, pero si te valdrá para tirar bien...

La carcasa, mira si te vale la misma, te ahorras 20-30 euros. Lo mismo ratón  y teclado... otros 20-30 euros si coges algo básico.

Si no es que tu PC, sea tan lento, que debas esperar que arranquen las aplicaciones, que las pelis vayan a saltos y tal... te diría que esperes y ahorres y si de verdad te hace falta algo que funcione y ya tira por una tablet de 10-12 pulgadas, por un precio de entre 120-150 euros... y saldrás del atolladero, hasta que a la vuelta de 1-2 años tengas más presupuesto disponible.. ya ves que lo mires como lo mires se va a los 500euros... y tienes justo la mitad.... peor para una tablet (con windows 10 o android, o mejor mixto (ambos), te sobra la mitad...

Cuando esto crezca más (y mejor si esuviera disponible en español), sería un buen sitio donde enviar a la gente a aprender...  (al menos las cosas básicas)...

[engel]

Tienes razón engel...

Nueva entrega... Esta vez hacemos el mismo algoritmo, ya visto, 3ª versión.
Realizada con bucles Do, como la versión con bucles For, es sencilla de entender y más rápida que las dos versiones previas, y al igual que la 2ª versión, admite un estado inicial de trabajo distinto a la primera secuencia del alfabeto.
Igualmente que en las predecores, admite un alfabeto propio por cada carácter, que es la particularidad más interesante de este 2º algoritmo.

Comparte con los otras 2 versiones de este algoritmo 2º, la interfaz del usuario... es decir las 3 cajas de texto, donde se introducen, el estado inicial del alfabeto, el estado mínimo y máximo de cada carácter del alfabeto y un botón específico para realizar la tarea. Por tanto de esa parte, solo se pondrá el cóodigo relativo al botón, a continuación:

Código (vbnet) [Seleccionar] Expandir


Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.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 = bucl.EnumerarDo(ClaveActual, Min, Max)
    End Sub

La función StringToBytearray, ya se puso el código de ella en un mensaje anterior.
El objeto Bucl, ya fue definido para la versión del algoritmo usando FOR, y en esa misma clase, se aloja la función EnumerarDo. Podría haber sido una sobrecarga, pero así queda más claro que función se asocia con cada algoritmo.
Y respecto de la interfaz, no requiere más comentarios...


Vamos con el algoritmo. Primero el código y luego los comentarios, si bien, la mayor parte ya ha sido comentado en los anteriores mensajes... aquí por tanto solo se señala lo específico de esta versión.

Código (vbnet) [Seleccionar] Expandir



' Esta clase ya está creada en el mensaje del algoritmo FOR.
Public Class cBucAni
    Public Function EnumerarFor(ByRef sMin() As Byte, ByRef sMax() As Byte) As Decimal
        ' esta función ya se puso más arriba, se comenta por claridad...
    End Function
' Permite enumerar todas las permutaciones, para claves de largo entre 1 a 16 caracteres
    Public Function EnumerarDo(ByVal ClaveActual() As Byte, ByRef sMin() As Byte, ByRef sMax() As Byte) As Decimal       
        Dim Max(0 To 15) As Byte
        Dim Min(0 To 15) As Byte
        Dim Inc(0 To 15) As Short
        Dim Ini(0 To 15) As Byte        ' Para establecer valores iniciales.
        Dim valA, valB, valC, valD, valE, valF, valG, valH, valI, valJ, valK, valL, valM, valN, valO, valP As Byte ' podríasn desbordar si min o máx llegan a 0 ó 255... (en tal caso cambiarlo a short).
        Dim minA, minB, minC, minD, minE, minF, minG, minH, minI, minJ, minK, minL, minM, minN, minO, minP As Byte
        Dim maxA, maxB, maxC, maxD, maxE, maxF, maxG, maxH, maxI, maxJ, maxK, maxL, maxM, maxN, maxO, maxP As Byte
        Dim incA, incB, incC, incD, incE, incF, incG, incH, incI, incJ, incK, incL, incM, incN, incO, incP As Short

        Dim SizeClave As Short  ' Tamaño de las claves (cantidad de caracteres que contienen)
        Dim ClavePermutada() As Byte  ' Clave generada en bytes.

        Dim t As Short, n As Short
        Dim z As Decimal, Crono As Single
        Dim txt As String = ""

        txt = ""
        Crono = TimeOfDay.Ticks ' ticks a la hora actual

        z = CalcularNumPermutaciones(ClaveActual, sMin, sMax)
        If (z < 0) Then
            Return -1
            'Exit Function
        Else
            SizeClave = ClaveActual.Length
            ReDim ClavePermutada(0 To SizeClave - 1)

            ' Espacio usado por ClaveActual
            ' para invertir las claves generadas, invertir el recorrido en este bucle
            For t = 0 To (SizeClave - 2) Step 2 ' (SizeClave - 2) To 0 Step -2
                Max(n) = sMax(t)
                Min(n) = sMin(t)
                Ini(n) = ClaveActual(t) ' inicializa (parcialmente) los valores iniciales d ela clave.
                ClavePermutada(t) = Ini(n)
                n += 1
            Next
            ' Definiendo el avance por cada carácter.
            For t = 0 To n - 1 '((SizeClave \ 2) - 2)
                If (Max(t) >= Min(t)) Then
                    Inc(t) = 1
                ElseIf (Max(t) < Min(t)) Then
                    Inc(t) = -1
                End If
            Next

            ' Espacio no usado por ClaveActual (hasta 15 caracters).
            For t = n To 15 'SizeClave To 15
                Inc(t) = 255 'Min(t) = 255 : Max(t) = 255 :               
            Next

        End If



        ' Establece los valores Iniciales del array Ini, a las variables sueltas (es más rápido)
        valP = Ini(15) : valO = Ini(14) : valN = Ini(13) : valM = Ini(12) : valL = Ini(11) : valK = Ini(10) : valJ = Ini(9) : valI = Ini(8)
        valH = Ini(7) : valG = Ini(6) : valF = Ini(5) : valE = Ini(4) : valD = Ini(3) : valC = Ini(2) : valB = Ini(1) : valA = Ini(0)
        ' Establece los valores de Incremento del array Inc, a las variables sueltas (es más rápido)
        incP = Inc(15) : incO = Inc(14) : incN = Inc(13) : incM = Inc(12) : incL = Inc(11) : incK = Inc(10) : incJ = Inc(9) : incI = Inc(8)
        incH = Inc(7) : incG = Inc(6) : incF = Inc(5) : incE = Inc(4) : incD = Inc(3) : incC = Inc(2) : incB = Inc(1) : incA = Inc(0)

        ' Establece los valores Minimos del array Min, a las variables sueltas (es más rápido)
        minP = Min(15) : minO = Min(14) : minN = Min(13) : minM = Min(12) : minL = Min(11) : minK = Min(10) : minJ = Min(9) : minI = Min(8)
        minH = Min(7) : minG = Min(6) : minF = Min(5) : minE = Min(4) : minD = Min(3) : minC = Min(2) : minB = Min(1) : minA = Min(0)
        ' Establece los valores Máximos del array Max, a las variables sueltas (es más rápido)
        maxP = Max(15) + incP : maxO = Max(14) + incO : maxN = Max(13) + incN : maxM = Max(12) + incM
        maxL = Max(11) + incL : maxK = Max(10) + incK : maxJ = Max(9) + incJ : maxI = Max(8) + incI
        maxH = Max(7) + incH : maxG = Max(6) + incG : maxF = Max(5) + incF : maxE = Max(4) + incE
        maxD = Max(3) + incD : maxC = Max(2) + incC : maxB = Max(1) + incB : maxA = Max(0) + incA
       
        ' La enumeración finaliza con un error, al tratar de escribir en una posición del array fuera de posición (desbordamiento).
        ' No es nada elegante pero funciona y no lo ralentiza con una solución más elegante que exija más código.
        Try
            Do
                Do
                    Do
                        Do
                            Do
                                Do
                                    Do
                                        Do
                                            Do
                                                Do
                                                    Do
                                                        Do
                                                            Do
                                                                Do
                                                                    Do
                                                                        Do
                                                                            ClavePermutada(0) = valA
                                                                            ' Usar Permutación desde aquí:
                                                                            'txt = System.Text.Encoding.Unicode.GetString(ClavePermutada)
                                                                            ' call FuncionX(ClavePermutada)
                                                                            valA += incA
                                                                        Loop While (valA <> maxA)
                                                                        valA = minA
                                                                        ClavePermutada(2) = valB
                                                                        valB += incB
                                                                    Loop While (valB <> maxB)
                                                                    valB = minB
                                                                    ClavePermutada(4) = valC
                                                                    valC += incC
                                                                Loop While (valC <> maxC)
                                                                valC = minC
                                                                ClavePermutada(6) = valD
                                                                valD += incD
                                                            Loop While (valD <> maxD)
                                                            valD = minD
                                                            ClavePermutada(8) = valE
                                                            valE += incE
                                                        Loop While (valE <> maxE)
                                                        valE = minE
                                                        'If (SizeClave = 10) Then GoTo salida
                                                        ClavePermutada(10) = valF
                                                        valF += incF
                                                    Loop While (valF <> maxF)
                                                    valF = minF
                                                    ClavePermutada(12) = valG
                                                    valG += incG
                                                Loop While (valG <> maxG)
                                                valG = minG
                                                ClavePermutada(14) = valH
                                                valH += incH
                                            Loop While (valH <> maxH)
                                            valH = minH
                                            ClavePermutada(16) = valI
                                            valI += incI
                                        Loop While (valI <> maxI)
                                        valI = minI
                                        ClavePermutada(18) = valJ
                                        valJ += incJ
                                    Loop While (valJ <> maxJ)
                                    valJ = minJ
                                    ClavePermutada(20) = valK
                                    valK += incK
                                Loop While (valK <> maxK)
                                valK = minK
                                ClavePermutada(22) = valL
                                valL += incL
                            Loop While (valL <> maxL)
                            valL = minL
                            ClavePermutada(24) = valM
                            valM += incM
                        Loop While (valM <> maxM)
                        valM = minM
                        ClavePermutada(26) = valN
                        valN += incN
                    Loop While (valN <> maxN)
                    valN = minN
                    ClavePermutada(28) = valO
                    valO += incO
                Loop While (valO <> maxO)
                valO = minO
                ClavePermutada(30) = valP
                valP += incP
            Loop While (valP <> maxP)
        Catch
            z = z
        End Try

salida:
        ' Verificando la última clave.
        txt = System.Text.Encoding.Unicode.GetString(ClavePermutada)
        ' Devolver resultados       
        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 & vbCrLf & "ültima permutación: " & txt)
        Return z
    End Function
End Class


Lo primero que vemos es un chorro de variables... vamos a explicar a que se debe.
Puesto que cada carácter tiene definido su propio alfabeto, es preciso que para cada uno se provean 5 cosas: El estado inicial del carácter, el estado actual del bucle, el valor mínimo que puede alcanzar el alfabeto para ese carácter, el estado máximo que puede alcanzar el alfabeto para ese carácter y la dirección de avance sobre el alfabeto.
Bien dado que la propia función tiene capacidad para operar con claves de hasta 16 caracteres, se necesitan 5 variables por cada una. Sin embargo, el hecho de facilitar la entrada a la función con solo 3 parámetros, implica que para asginar los valores de una forma rápida recurrimos a una fase preparatoria mediante bucles y arrays. Una vez que cada valor está en su sitio, se hace una asignación unitaria desde los arrays a variables sueltas, la razón?.
Hay dos razones:
- La 1ª es que siempre es más ra´pido acceder a la dirección de una variable que a una dentro de un array, ya que a esas debe llegarse como un desplazamiento del acceso al array, luego es más rápido solo por eso.
- la segunda es más d elo mismo, pero con una razón más poderosa... Cada vez que se accede a un array, se verifica si el índice reclamado existe dentro dle array, y si no es así arrojar un error "fuera de límites", etc... La sobrecarga de que cada vez que se tome el valor procedente de un array, deba vigilarse si el índice está fuera de límites, supone un retraso enorme... así matamos ese retraso también, junto al previo, si cambiamos los arrays por variables sueltas....
Finalmente para evitar un popurrí de variables, todas tienen nombres similares, alfabetizadas... así es fácil saber en que bucle estamos o qué variables es (útil con tantas como hay).

La partefea del algoritmo, es que acaba siempre con un error. La razón?. Hay 16 bucles anidados, comprobar al final de cada uno de ellos si la tarea terminó, es una sobrecarga inutíl. Cuando llegue a un bucle que esté fuera de curso, saltará un error porque intentará escribir en el array que contiene la clave permutada.
Aunque tratar un error puede conllevar la llamada (transaprente desde el código),  unas 8-12 rutinas adicionales para localizar todos los datos del error y luego vaciarlo todo, esto es enormemente más rápido que poner en cada bucle un interceptor de fin de permutaciones.

Al final de la función, podría saberse si de verdad acabó o hubo un auténtico error no esperado, si al comienzo se establece que bucle no debe llegar a alcanzarse y luego al cazar el error se verifica si en efecto el valor del contador en ese bucle varió... se ha omitido cualquier comprobación al respecto.

El código de la función es sustancialmente idéntico al del bucle for, excepto que como el bucle DO, permite hacer las comprobaciones tanto al principio (Do while condicion... loop) como al final (do.... loop while condicion), haciéndolo al final, podemos reastaurar el contador del bucle al vamor minimo aceptado en el alfabeto para el carácter en ´juego en dicho bucle... pudiendo por tanto asignar fácilmente antes del inicio de los bucles como contador el valor del estado desde el que se quiere empezar la enumeración de las permutaciones.

Las comprobaciones que debe hacer antes de iniciar el bucle, ya han sido comentadas, en los dos mensajes previos.
Y resta decir que de las tres variaciones de este algoritmo 2, ésta e sla más rápida (los bucles do, son más rápidos que los bucles for).

Respeto de este algoritmo, decir que todavía se pueden optimizar, pero habría que acudir al ensamblador... algo que comentaremos en la siguiente entrega.
----------------------------

En la sigiente entrega veremos otro algoritmo de naturaleza algo diferente. El alfabeto, vuelve a ser fijo para todas las claves (es decir todos los caracterestienen el mismo y único alfabeto). Es un algoritmo generado con concatenación...

cualquier duda, preguntad 
Nos vemos... en la sigiente entrega.

Hay varios algoritmos que solucionan esto de una forma eficaz...

Te señalo, por ejemplo el algoritmo conocido como: "congruencia de Zeller":

Crea un array con los días de la semana:

Código [Seleccionar] Expandir

DiaSemana(0 a 6) = [Domingo, Lunes, Martes, ...]

Este sería el cálculo:

Código [Seleccionar] Expandir

Funcion CalcularDiaSemana(Dia, Mes, Año) string
    n = ((14 - Mes) \ 12)
    Año = (Año - n)
    Mes = (Mes + (12 * n) - 2)
    Return DiaSemana(((Dia + Año + (Año \ 4) - (Año \ 100) + (Año \ 400) + ((31 * Mes) \ 12)) Mod 7))
Fin Funcion


[No, tu implementación del código, no es correcta...]

No, tu implementación del código, no es correcta...
- Dónde está el array?.
- Dónde está la línea: Cifra = (valor módulo 10) ... 'C' tiene un operador llamado módulo, no lo conoces????.
- Dónde ves que incremente 'cifra'?
..lo que se incrementa es el enésimo indice (cuyo valor se recoge en 'cifra') en el array. MiArray(x) +=1 ...dónde x, es el índice, al mismo tiempo que la cifra recién hallada, por eso sirve de índice: MiArray(cifra) +=1
El mismo error lo vuelves a cometer dentro del condicional: valor=valor+1
Si no entiendes lo que está sucediendo, no serás capaz de 'traducirlo' a código...

Además, debes decidir si el array lo devuelves en la función. Bueno, viendo las complicaciones que tienes, mejor no, haz la presentación bajo el primer bucle.

La presentación será recorrer el mismo array y exponer el valor que contiene en cada índice. Pero de verdad, si esto tan simple no alcanzas a hacerlo tu mismo...  

...por último, te señalaba (edité el mensaje más arriba), que si el valor del que se quieren contar sus cifras fuera 0, esta cifra, se contaría dos veces y que dejaba a tu ingenio solventar ese pequeño detalle (sugerencia: que tal con un if, antes del bucle while).

Enserio va ser que minar en bitcoin alguna dia sea rentable ya lo veo proximo..

Ni siquiera en días tan tempranos como 2012 era ya rentable... entre el 2010 y el 2012, el cambio en la potencia de cálculo (para minar) fue espectacular al haber algunos fabricantes que decidieron crear equipos exclusivamente dedicados a esto.

Recuerdo a un compañero que trabajaba en otra empresa y que utilizaba los PCs, de la empresa durante la noche, para minar bitcoins... hasta que le pillaron y se fue a la calle. Si no cuentas con muchos PCs, cuyo gasto energético recaiga en el bolsillo de otro (algo presumiblemente ilegal o no ético sin conocimiento expreso del/los deueños de esos PCs), con PCs, no vale la pena...

Ahora si simplemente uno quiere sentir que está minando... sin esperar un rendimiento económico, pués vale... experimenta una semana, un mes y ya.