Mensajes

[bucle infinito = ((inc = 0) and (inicio <> final))]

Esto son temas de sobra conocidos en teoría de compiladores.

El primer tema a considerar: Los bucles infinitos versa que si el incremento es 0 y el valor inicial es igual al valor final, no es un bucle infitio, en otro caso si:
       bucle infinito = ((inc = 0) and (inicio <> final))
...y si el cuerpo está vacío (como es el caso), o no existe dentro una sentencia de escape del bucle (si existe, deberá examinarse también). Lógicamente en tiempo de compilación...
       Por eso no se cumple en el primer caso y sí en el segundo.

Los bucles infinitos de este modo, en realidad pueden ser tomados como bucles incondicionales (tipo do...loop) y han sido la solución para lenguajes en los que no existen otro tipo de bucles que no sean condicionados por una expresión aritmética pero que si admiten una sentencia de salida del mismo controlados por algún 'if then else'.

El segundo tema a considerar: En teoría de compiladores se trata en la optimización de código, para eliminar código redundante o código inaccesible. Código inaccesible es aquel que nunca se va a ejecutar, caso por ejemplo como:

Código [Seleccionar] Expandir


int x = 20
si x = 0
   ...
fin si
El compilador detectará que si a x se el asigna la constante 20, no puede tener de inmediato la contante 0, luego todo el código dentro del condicional incluído el condicional, puede ser omitido.
Piénsese que los condicionales 'if then', a efectos prácticos pueden considerarse bucles de 0 ó 1 ciclos.

Desde el momento en que entras en un bucle infinito, el código que venga detrás se vuelve inaccesible, que es lo que pasa en el segundo ejemplo.

Jo... cuanta inquina al XP. 

Desactivando determinados servicios y javascript, y no navegando por según que sitios, sigue siendo seguro... Si además tiene instalado algún que otro firewall, mejor que mejor.

[pero al crearlo hay que activarlas (en opciones avanzadas)]

El propio winrar incluye opciones de recuperación. Usando el algoritmo de Reed-Solomon, pero al crearlo hay que activarlas (en opciones avanzadas) porque ralentizan la compresión y engrosan el resultado final.

Si se activa el registro de recuperación,  puede recuperarse de errores no excesivamente agresivos, es decir daños típicos de transferencia, de un CD que lleva ahí mucho tiempo 'aparcado' (daños físicos), etc... pero, si los daños son provocados o  son excesivos (caso típico de una manipulación a propósito por ejemplo sobrescribiendo partes del archivo), entonces será imposible la recuperación incluso, ni parcial...

India y Pakistán, mantienen varias tensiones: está el eterno problema fronterizo, el problema racial y el religioso. Con esas 3 cosas chocan y ninguno quiere ceder lo más mínimo.
La tensión sube, o baja en función de los líderes capullos del momento.

Buenas:
...Intenté pasarlo con este enlace, pero me daba errores por todoas partes.
...Son menos códigos....

Cuantas excusas...

He probado con esa página y la verdad que lo hace bastante bien...
Tan solo conviene cambiar los tipos de UInt a int y los float a double.
Luego solo restan 3 conversiones que tratan sobre cadenas... obtener una cadena que consiste de x caracteres, en c# es usar el constructor new string(char, cantidad) (en vb solemos usar strDup, que es el heredero de Strings(char, cantidad)...

Yo no he tardado más de 1 minuto en pasarlo a C# usando el código devuelto por esa página (me reitero, lo hace bastante bien):

Aquí exactamente el mismo código que puse en VB (bueno debajo del progreso he añadido otra línea).

Código (csharp) [Seleccionar] Expandir


using System;
using Microsoft.VisualBasic;
using System.Threading;

static class Module1
{
    public static void Main()
    {
        Console.Title = "Simulador barra de progreso";
        Console.WindowWidth = 80;   // X ancho.
        Console.WindowHeight = 20;  // Y altura.
        Console.CursorVisible = false;

        int k;
        Progreso p = new Progreso(0, 58, 0, 5); // por defecto columna 12
        for (k = 0; k <= p.Maximo; k++)
        {
            p.Incrementar();     // incrementa y redibuja todo.
            Thread.Sleep(40);    // 40 milisegundos.
        }

        Console.ReadKey();
    }

    private class Progreso
    {
        private int p_Min, p_Max;
        private int p_Fila, p_Columna;
        private double p_Valor, s_Avance, s_Porcen;
        private string FullProgreso;

        public Progreso(int Min, int Cantidad, int Value, int Fila = 5, int Columna = 12)
        {
            p_Min = Min;
            p_Max = (p_Min + Cantidad - 1);
            p_Valor = Value;
            s_Avance = (Cantidad / (double)100);
            s_Porcen = (100 / (double)Cantidad);
            FullProgreso = new string((char)177, Cantidad);

            p_Fila = Fila;
            p_Columna = Columna;

            this.Dibujar(true);
        }

        public int Maximo
        {
            get
            {
                return p_Max;
            }
        }

        public void Incrementar()
        {
            p_Valor += s_Avance;
            this.Dibujar(false);
        }

        private void Dibujar(bool Previo)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            if ((Previo == true))
            {
                Console.SetCursorPosition(p_Columna, p_Fila - 2);
                Console.Write("0 %                         50 %                     100 %");
                Console.SetCursorPosition(p_Columna - 1, p_Fila - 1);
                Console.Write("{0}{1}{0}", (char)179, new string((char)205,(p_Max - p_Min + 1))); // 205= 2 rayas horizontales 240=1raya horizontal. 179=carácter de puntos (no macizo)
                // dibujamos la misma línea por debajo de la barra de progreso.
                Console.SetCursorPosition(p_Columna - 1, p_Fila + 1);
                Console.Write("{0}{1}{0}", (char)179, new string((char)205, (p_Max - p_Min + 1)));
            }
            Console.SetCursorPosition(p_Columna, p_Fila - 4);
            Console.Write("Cargado: {0} {1}", (p_Valor * s_Porcen / (double)s_Avance).ToString("N2"), " %");
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.SetCursorPosition(p_Columna, p_Fila);
            Console.Write(FullProgreso.Substring(0, Convert.ToInt32 (p_Valor / s_Avance)));
        }
    }
}


Y te repito, que aunque sena apenas 10-15 líneas de código más, resulta más legible y más fácilmente modificable, también es más eficiente... el código de la función dibujar solo dibuja ciertas líneas una única y tan solo en cada ciclo redibuja lo que cambia.



En fin, creo que tu mayor problema es que vas a saltos, no conoces lo esencial del lenguaje, vas aprendiendo a base de tropezarte con las piedras que encuentras en el camino, y en vez de enfrentarte a ellas para apartarlas del camino (esto es entenderlas), tu lo que haces es sortearlas... así que ahí siguen y seguirán pese al tiempo que transcurra.
Al final solo usarás del lenguaje aquello que entiendes, porque lo que no entiendes, te da pereza y huyes de ello. Así no se puede ser programador.
No puedes aprovechar el potencial de un lenguaje si no conoces al menos lo básico. No es que todo deba ser hecho de la mejor manera posible, a veces es más práctico no perder demasiado tiempo en algo a condición de que también resuelva de modo eficiente el problema en cuestión, pero tampoco tendrás opciones para ello, porque las desconoces...

Los asuntos de anti-cheat, son un defecto del diseño del hardware, el software no puede impedirlo al completo, solo obstaculizarlo.

[Elektro]

...He hecho esto gracia a ustedes y no me dibuja la línea...

mmm.... Me hace gracia eso...
Gracias a ¿nosotros?. Más bien gracias a tí...

Ya sé que no vas a adoptar la solución que te propone Elektro, porque son muchas líneas de código... pero la que yo te propuse no son muchas más que las que tu ya tienes... Y es que en realidad lleva solo 5 minutos, pasar mi pseudocódigo a código:

Eso sí, en Visual Basic, en C# y lenguajes similares, me aburre la cansina sintaxis de tanto punto y coma, de tanta llave y paréntesis, y la estúpida insistencia en ser sensible a la capitalización... I'm sorry, pero pasarlo a c# es casi casi idéntico...

Código (vbnet) [Seleccionar] Expandir


Imports System.Threading

Module Module1
   Sub Main()
       Console.Title = "Simulador barra de progreso"
       Console.WindowWidth = 80   ' X ancho.
       Console.WindowHeight = 20  ' Y altura.
       Console.CursorVisible = False  

       Dim k As UInteger
       Dim p As Progreso = New Progreso(0, 58, 0, 5) ' por defecto columna 12
       For k = 0 To p.Maximo
           p.Incrementar()     ' incrementa y redibuja todo.
           Thread.Sleep(40)    ' 40 milisegundos.
       Next

       Console.ReadKey()
   End Sub

   Private Class Progreso
       Dim p_Min, p_Max As UInteger
       Dim p_Fila, p_Columna As UInteger
       Dim p_Valor, s_Avance, s_Porcen As Single
       Dim FullProgreso As String

       Sub New(ByVal Min As UInteger, ByVal Cantidad As UInteger, ByVal Value As UInteger, Optional ByVal Fila As UInteger = 5, Optional ByVal Columna As UInteger = 12)
           p_Min = Min
           p_Max = (p_Min + Cantidad - 1)
           p_Valor = Value
           s_Avance = (Cantidad / 100)
           s_Porcen = (100 / Cantidad)
           FullProgreso = Strings.StrDup(Integer.Parse(Cantidad), Chr(177)) ' 219

           p_Fila = Fila
           p_Columna = Columna

           Me.Dibujar(True)
       End Sub

       Public ReadOnly Property Maximo As UInteger
           Get
               Return p_Max
           End Get
       End Property

       Public Sub Incrementar()
           p_Valor += s_Avance
           Me.Dibujar(False)
       End Sub

       Private Sub Dibujar(ByVal Previo As Boolean)
           Console.ForegroundColor = ConsoleColor.Red
           If (Previo = True) Then          ' Dibujamos la barra del portentaje.              
               Console.SetCursorPosition(p_Columna, p_Fila - 2)
               Console.Write("0 %                         50 %                     100 %")
               Console.SetCursorPosition(p_Columna - 1, p_Fila - 1)
               Console.Write("{0}{1}{0}", Chr(179), Strings.StrDup(Convert.ToInt32(p_Max - p_Min + 1), Chr(205))) ' 205= 2 rayas horizontales 240=1raya horizontal. 179=carácter de puntos (no macizo)
           End If
           Console.SetCursorPosition(p_Columna, p_Fila - 4)
           Console.Write("Cargado: {0} {1}", (p_Valor * s_Porcen / s_Avance).ToString("N2"), " %")
           Console.ForegroundColor = ConsoleColor.Yellow
           Console.SetCursorPosition(p_Columna, p_Fila)
           Console.Write(FullProgreso.Substring(0, (p_Valor / s_Avance)))
       End Sub

       ' No se usa en este ejemplo
       'Public WriteOnly Property Valor() As UInteger
       '    Set(ByVal value As UInteger)
       '        p_Valor = value
       '        Me.Dibujar(False)
       '    End Set
       'End Property
   End Class
End Module


P.d: Y aquí el aspecto de como se ve...

[la propia planta para no gastar recursos]

Hay que ser un auténtico ceporro de etiqueta para llegar a afirmar que: "no es el WiFi el que mata las hojas, sino la propia planta para no gastar recursos de manera innecesaria.

Cualquiera diría que se lo ha dicho la propia planta...
Ahora ya sabemos que si prendes fuego a una planta, no se quema por el fuego, es la propia planta que se quema antes para evitar que luego tu la quemes. Y si un vehículo te atropella y te amputa el brazo, no es el golpe el que lo amputa, eres tu mismo de forma inconsciente que te lo amputas para no sentir dolor o algo similar...

Me pregunto en qué pecera nadarán estos tipos, porque parecen intoxicados de "tontitis aguda".

Básicamente la UE, está diciendo que un vendedor puede ocultar sus datos de contacto, tanto como quiera... cosa que en mi opinión, si vulnera la ley.

Los datos de contacto de un vendedor como amazon, debieran estár bien accesibles... Es más la ley debiera exigir que aparecieran (si no aparecen los datos sueltos en cada página ), como muy distante a un click pulsando en un botón obligatorio de 'Contacto'...
Esa página de contacto debeira reunir toda la info de contacto disponible y nada más (por claridad).

No entiendo por qué la ley es lasa en estas cuestiones que debieran de estar más que trilladas desde hace 20-25 años...

La forma más coherente (a cambio de posiblemente, algunas líneas más de código), es encapuslar lo mínimo de una barras de progreso (que uses una clase o lo dejes ahí suelto, ya es cosa tuya):
Campos:
- Mínimo
- Maximo
- Valor
Metodos:
- Inicializar(min, cantidad, valor, [fila, columna])
- Incrementar(+x) //con alguna sobrecarga
- Dibujar(dibcosasprevias)   // Actualizar el 'gráfico'.


Y tratándose de consola, convendría además mantener la fila donde dibujar y la columna inicial de dibujado, ambos valores pueden ser pasados al inicializar...

NOTA: que no se acomete comprobaciones, si lo vas a usar tú es obvio que no pondrás valor fuera de límites.

Código [Seleccionar] Expandir

funcion Inicializar(0,100,0, fila=5, columna=12)
   p_Min = min
   p_Max = p_min + (Cantidad-1)  //nótese que cantidad puede ser negativo, y consecuentemente max serlo también, si no se desea designar tipos sin signo).
   p_Valor = valor
   p_Fila = Fila
   p_Columna = columna
   Dibujar(true)
fin funcion

propiedad Set Valor(x)  // propiedad Get Valor ... probablemente solo precises que sea de escritura.
    Si (x <> p_Valor)
       p_valor = x
       dibujar(false)
    fin si
fin propiedad

funcion Incrementar(x)
    p_valor +=x
    dibujar(false)
fin funcion
funcion Incrementar
    Incrementar(1)
fin funcion

funcion Dibujar(previo)
    si previo
        dibujar infoprevia //texto, etc... se supone que basado en p_fila -algo
    fin si

    establecer posicioncursor(p_fila, p_columna)
    bucle desde p_min a p_valor
        dibujar char(219) 
    siguiente
fin funcion

Luego simplemente inicializas con los valores oportunos... y ya se dibuja.
Cuando hagas alguna tarea de carga usarías valor = x o incrementar o incrementar(x) como remplazo de tu 'printCargando'. Usar uno u otro depende de lo que se haga, en el bucle posiblemente 'incrementar' vaya bien, pero si hay algna tarea anterior o posterior pudiera darse un incremntar(10) (por ejemplo), o si hay varias tareas, volver a ponerlo a 0 Valor = 0, incluso un nuevo Inicializar(,,,) si los límites son diferentes...

La gran ventaja de hacerlo más estructurado (que solo líneas espagueti sin fin) es que con posterioridad cualquier cambio, es más sencillo de llevar a cabo y si pasa demasiado tiempo, un simple vistazo sobra para entender lo que hacía y saber donde tocar si se quiere hacer algún cambio, sin perder tiempo en empaparse con lo escrito tiempo/años atrás. Por ejemplo, alojado en una clase, podrías reutilizarlo en distintos proyectos, con tan solo cambiar lo que se dibuje como 'info previa', (los textos que se asocien a lo que se haga, como 'leyendo fichero...', 'buscando...', ordenando...', etc... que si además lo parametrizas, pués mejor que mejor).