elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: [AIO elhacker.NET 2015] Compilación herramientas análisis y desinfección malware


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 [13] 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 ... 49
121  Informática / Hardware / Re: Cambiar ordenador poco a poco en: 27 Mayo 2017, 15:19
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.
122  Programación / .NET / Re: Poner varios números y que los separe en: 27 Mayo 2017, 15:00
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.
123  Informática / Hardware / Re: Cambiar ordenador poco a poco en: 26 Mayo 2017, 22:57
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...
124  Foros Generales / Noticias / Re: Alcamy, la plataforma de aprendizaje online que quiere ser como un hijo entre... en: 26 Mayo 2017, 03:40
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...  :silbar: :silbar: :silbar: (al menos las cosas básicas)...
125  Foros Generales / Noticias / Re: Científicos descubren el código utilizado por Volkswagen para perpetrar su ... en: 26 Mayo 2017, 03:37
Tienes razón engel...
126  Seguridad Informática / Abril negro / Re: [Abril Negro] S.P.O.K (Simple Production Of Keys) en: 26 Mayo 2017, 03:27

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
  1. Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click
  2.        Dim ClaveActual() As Byte, Min() As Byte, Max() As Byte
  3.        Dim z As Decimal
  4.  
  5.        ClaveActual = StringToByteArray(TextBox1.Text) ' Valor inicial: "ABXFD"
  6.        Min = StringToByteArray(TextBox2.Text)  ' Valor mínimo: Ejemplo: "AAAAZ"
  7.        Max = StringToByteArray(TextBox3.Text)  ' Valor final, Ejemplo: "ZWZZA
  8.  
  9.        z = bucl.EnumerarDo(ClaveActual, Min, Max)
  10.    End Sub
  11.  
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
  1.  
  2. ' Esta clase ya está creada en el mensaje del algoritmo FOR.
  3. Public Class cBucAni
  4.    Public Function EnumerarFor(ByRef sMin() As Byte, ByRef sMax() As Byte) As Decimal
  5.        ' esta función ya se puso más arriba, se comenta por claridad...
  6.    End Function
  7. ' Permite enumerar todas las permutaciones, para claves de largo entre 1 a 16 caracteres
  8.    Public Function EnumerarDo(ByVal ClaveActual() As Byte, ByRef sMin() As Byte, ByRef sMax() As Byte) As Decimal        
  9.        Dim Max(0 To 15) As Byte
  10.        Dim Min(0 To 15) As Byte
  11.        Dim Inc(0 To 15) As Short
  12.        Dim Ini(0 To 15) As Byte        ' Para establecer valores iniciales.
  13.        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).
  14.        Dim minA, minB, minC, minD, minE, minF, minG, minH, minI, minJ, minK, minL, minM, minN, minO, minP As Byte
  15.        Dim maxA, maxB, maxC, maxD, maxE, maxF, maxG, maxH, maxI, maxJ, maxK, maxL, maxM, maxN, maxO, maxP As Byte
  16.        Dim incA, incB, incC, incD, incE, incF, incG, incH, incI, incJ, incK, incL, incM, incN, incO, incP As Short
  17.  
  18.        Dim SizeClave As Short  ' Tamaño de las claves (cantidad de caracteres que contienen)
  19.        Dim ClavePermutada() As Byte  ' Clave generada en bytes.
  20.  
  21.        Dim t As Short, n As Short
  22.        Dim z As Decimal, Crono As Single
  23.        Dim txt As String = ""
  24.  
  25.        txt = ""
  26.        Crono = TimeOfDay.Ticks ' ticks a la hora actual
  27.  
  28.        z = CalcularNumPermutaciones(ClaveActual, sMin, sMax)
  29.        If (z < 0) Then
  30.            Return -1
  31.            'Exit Function
  32.        Else
  33.            SizeClave = ClaveActual.Length
  34.            ReDim ClavePermutada(0 To SizeClave - 1)
  35.  
  36.            ' Espacio usado por ClaveActual
  37.            ' para invertir las claves generadas, invertir el recorrido en este bucle
  38.            For t = 0 To (SizeClave - 2) Step 2 ' (SizeClave - 2) To 0 Step -2
  39.                Max(n) = sMax(t)
  40.                Min(n) = sMin(t)
  41.                Ini(n) = ClaveActual(t) ' inicializa (parcialmente) los valores iniciales d ela clave.
  42.                ClavePermutada(t) = Ini(n)
  43.                n += 1
  44.            Next
  45.            ' Definiendo el avance por cada carácter.
  46.            For t = 0 To n - 1 '((SizeClave \ 2) - 2)
  47.                If (Max(t) >= Min(t)) Then
  48.                    Inc(t) = 1
  49.                ElseIf (Max(t) < Min(t)) Then
  50.                    Inc(t) = -1
  51.                End If
  52.            Next
  53.  
  54.            ' Espacio no usado por ClaveActual (hasta 15 caracters).
  55.            For t = n To 15 'SizeClave To 15
  56.                Inc(t) = 255 'Min(t) = 255 : Max(t) = 255 :                
  57.            Next
  58.  
  59.        End If
  60.  
  61.  
  62.  
  63.        ' Establece los valores Iniciales del array Ini, a las variables sueltas (es más rápido)
  64.        valP = Ini(15) : valO = Ini(14) : valN = Ini(13) : valM = Ini(12) : valL = Ini(11) : valK = Ini(10) : valJ = Ini(9) : valI = Ini(8)
  65.        valH = Ini(7) : valG = Ini(6) : valF = Ini(5) : valE = Ini(4) : valD = Ini(3) : valC = Ini(2) : valB = Ini(1) : valA = Ini(0)
  66.        ' Establece los valores de Incremento del array Inc, a las variables sueltas (es más rápido)
  67.        incP = Inc(15) : incO = Inc(14) : incN = Inc(13) : incM = Inc(12) : incL = Inc(11) : incK = Inc(10) : incJ = Inc(9) : incI = Inc(8)
  68.        incH = Inc(7) : incG = Inc(6) : incF = Inc(5) : incE = Inc(4) : incD = Inc(3) : incC = Inc(2) : incB = Inc(1) : incA = Inc(0)
  69.  
  70.        ' Establece los valores Minimos del array Min, a las variables sueltas (es más rápido)
  71.        minP = Min(15) : minO = Min(14) : minN = Min(13) : minM = Min(12) : minL = Min(11) : minK = Min(10) : minJ = Min(9) : minI = Min(8)
  72.        minH = Min(7) : minG = Min(6) : minF = Min(5) : minE = Min(4) : minD = Min(3) : minC = Min(2) : minB = Min(1) : minA = Min(0)
  73.        ' Establece los valores Máximos del array Max, a las variables sueltas (es más rápido)
  74.        maxP = Max(15) + incP : maxO = Max(14) + incO : maxN = Max(13) + incN : maxM = Max(12) + incM
  75.        maxL = Max(11) + incL : maxK = Max(10) + incK : maxJ = Max(9) + incJ : maxI = Max(8) + incI
  76.        maxH = Max(7) + incH : maxG = Max(6) + incG : maxF = Max(5) + incF : maxE = Max(4) + incE
  77.        maxD = Max(3) + incD : maxC = Max(2) + incC : maxB = Max(1) + incB : maxA = Max(0) + incA
  78.  
  79.        ' La enumeración finaliza con un error, al tratar de escribir en una posición del array fuera de posición (desbordamiento).
  80.        ' No es nada elegante pero funciona y no lo ralentiza con una solución más elegante que exija más código.
  81.        Try
  82.            Do
  83.                Do
  84.                    Do
  85.                        Do
  86.                            Do
  87.                                Do
  88.                                    Do
  89.                                        Do
  90.                                            Do
  91.                                                Do
  92.                                                    Do
  93.                                                        Do
  94.                                                            Do
  95.                                                                Do
  96.                                                                    Do
  97.                                                                        Do
  98.                                                                            ClavePermutada(0) = valA
  99.                                                                            ' Usar Permutación desde aquí:
  100.                                                                            'txt = System.Text.Encoding.Unicode.GetString(ClavePermutada)
  101.                                                                            ' call FuncionX(ClavePermutada)
  102.                                                                            valA += incA
  103.                                                                        Loop While (valA <> maxA)
  104.                                                                        valA = minA
  105.                                                                        ClavePermutada(2) = valB
  106.                                                                        valB += incB
  107.                                                                    Loop While (valB <> maxB)
  108.                                                                    valB = minB
  109.                                                                    ClavePermutada(4) = valC
  110.                                                                    valC += incC
  111.                                                                Loop While (valC <> maxC)
  112.                                                                valC = minC
  113.                                                                ClavePermutada(6) = valD
  114.                                                                valD += incD
  115.                                                            Loop While (valD <> maxD)
  116.                                                            valD = minD
  117.                                                            ClavePermutada(8) = valE
  118.                                                            valE += incE
  119.                                                        Loop While (valE <> maxE)
  120.                                                        valE = minE
  121.                                                        'If (SizeClave = 10) Then GoTo salida
  122.                                                        ClavePermutada(10) = valF
  123.                                                        valF += incF
  124.                                                    Loop While (valF <> maxF)
  125.                                                    valF = minF
  126.                                                    ClavePermutada(12) = valG
  127.                                                    valG += incG
  128.                                                Loop While (valG <> maxG)
  129.                                                valG = minG
  130.                                                ClavePermutada(14) = valH
  131.                                                valH += incH
  132.                                            Loop While (valH <> maxH)
  133.                                            valH = minH
  134.                                            ClavePermutada(16) = valI
  135.                                            valI += incI
  136.                                        Loop While (valI <> maxI)
  137.                                        valI = minI
  138.                                        ClavePermutada(18) = valJ
  139.                                        valJ += incJ
  140.                                    Loop While (valJ <> maxJ)
  141.                                    valJ = minJ
  142.                                    ClavePermutada(20) = valK
  143.                                    valK += incK
  144.                                Loop While (valK <> maxK)
  145.                                valK = minK
  146.                                ClavePermutada(22) = valL
  147.                                valL += incL
  148.                            Loop While (valL <> maxL)
  149.                            valL = minL
  150.                            ClavePermutada(24) = valM
  151.                            valM += incM
  152.                        Loop While (valM <> maxM)
  153.                        valM = minM
  154.                        ClavePermutada(26) = valN
  155.                        valN += incN
  156.                    Loop While (valN <> maxN)
  157.                    valN = minN
  158.                    ClavePermutada(28) = valO
  159.                    valO += incO
  160.                Loop While (valO <> maxO)
  161.                valO = minO
  162.                ClavePermutada(30) = valP
  163.                valP += incP
  164.            Loop While (valP <> maxP)
  165.        Catch
  166.            z = z
  167.        End Try
  168.  
  169. salida:
  170.        ' Verificando la última clave.
  171.        txt = System.Text.Encoding.Unicode.GetString(ClavePermutada)
  172.        ' Devolver resultados        
  173.        Crono = ((TimeOfDay.Ticks - Crono) / 10000000)  ' ticks a la hora actual, menos los de comienzo= ticks invertidos en la tarea.
  174.        MessageBox.Show("Tiempo: " & Crono.ToString & vbCrLf & "Permutaciones: " & z.ToString & vbCrLf & "ültima permutación: " & txt)
  175.        Return z
  176.    End Function
  177. End Class
  178.  

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  :o
Nos vemos... en la sigiente entrega.
127  Programación / Programación C/C++ / Re: Algoritmo para Obtener el día de la semana[C] en: 26 Mayo 2017, 02:01
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:
DiaSemana(0 a 6) = [Domingo, Lunes, Martes, ...]

Este sería el cálculo:
Código:
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


128  Programación / Programación C/C++ / Re: ayuda / algoritmo para calcular el numero de veces que una cifra se repite en: 25 Mayo 2017, 23:49
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...  :silbar:

...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).
129  Foros Generales / Noticias / Re: Bitcoin no deja de crecer y supera los 2.700 dólares por unidad en: 25 Mayo 2017, 23:40
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.
130  Programación / Programación C/C++ / Re: ayuda / algoritmo para calcular el numero de veces que una cifra se repite en: 25 Mayo 2017, 23:28
Te lo he puesto en pseudocodigo...

bucle Mientras ---> es el bucle While
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 [13] 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 ... 49
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines