Make your own free website on Tripod.com

Solución de problemas con Loops

 

La estructura lógica del loop es una estructura repetitiva o iterativa. Un gran número de problemas de administración conlleva ejecutar la misma tarea un sinnúmero de veces para diferentes grupos de datos, por lo que esta estructura es sumamente importante. Gracias a esta estructura, un programa puede procesar múltiples récords de una nómina o varios ítems de un inventario o poner una lista de direcciones en orden alfabético.

 

Hay tres tipos de estructuras loops: WHILE/WHILE-END loop, la cual repite las instrucciones mientras la condición sea CIERTA y para de repetir cuano encuentra una condición que NO es CIERTA. El segundo tipo es REPEAT/UNTIL loop, que repite instrucciones mientras una condición es FALSA o hasta que encuentra una condición que es CIERTA. El tercer tipo de loop es el CONTADOR-AUTOMÁTICO  en el cual una variable es igual a un número dado y aumenta en números equitativamente hasta que el número es mayor que el número final. Cada uno de estos tipos tiene un uso específico de acuerdo al lenguaje y al problema.

 

Incrementando

La tarea de incremento o contador consiste en añadir una constante, como el 1 o el 2, al valor de una variable. Para escribir la instrucción para incrementar una variable se usa  una declaración asignada. Por ejemplo:

 

contador = contador + 1

c = c + 1

cuando se quiere contar de uno en uno. Esta instrucción permite al programador contar el número de ítems, personas, temperaturas, etc. como parte de la solución de un problema.

 

Observa cómo la misma variable está al lado del signo igual (=). Esta instrucción toma el valor del contador, añade uno al mismo, y luego reemplaza el valor viejo del contador con el nuevo. El incremento puede ir de uno en uno, de dos en dos u otra constante, incluyendo números negativos, de tal forma que se puede aumentar o disminuir. El contador debe estar inicializado en 0 antes de empezar a contar.

 

Acumulando

 

Otra tarea común de los programas es la de acumular o sumar un grupo de números. El proceso de acumular es similar al de incrementar, excepto que es una variable, en lugar de una constante, la que se añade a otra variable, la cual toma el valor de la suma o del total. La instrucción para la acumulación es la siguiente:

 

SUM = SUM + VARIABLE  o S = S +V

 

Por ejemplo, la instrucción para buscar el total de ventas, sería:

 

TOTALSALES = TOTALSALES + SALES

 

También aparece el mismo nombre de la variable a ambos lados del signo mas, pero en este caso, lo que está al lado  derecho del signo + (en este caso SALES) es una variable y no una constante. En otras palabras, con un acumulador tu añades una variable (el ítem que acumulas) al valor de otra variable, que contiene la suma o el total. En estos ejemplos, SUM y TOTALSALES deben estar en cero antes de empezar el loop.

 

Tanto la instrucción de incremento como la de acumulación son una versión especial de la ecuación.

 

WHILE/WHILE-END

 

Esta clase de loop instruye a la computadora que mientras la condición es TRUE, se repiten todas las instrucciones que hay entre WHILE y WHILE-END. La forma del algoritmo y del flujograma (se utilizan los conectores dentro de una página por ser parte de un algoritmo mayor que tiene una parte que conecta con A y otra parte que se conecta con B) que es la siguiente:

 

Algoritmo

Flujograma

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


 

Al principio del loop WHILE/WHILE-END, el programa procesa la condición para decidir si ejecuta o no las instrucciones del loop. Cuando el resultado de la condición es FALSE al empezar, no se ejecutan las instrucciones del loop. Pero cuando el resultado de la condición es TRUE, se ejecutan todas las instrucciones del loop, una y otra vez, hasta que el resultado de la condición sea FALSE, en cuyo caso el proceso continúa con las instrucciones que siguen al WHILE-END.

 

La estructura iterativa también puede escribirse en forma de estructura decisional usando IF/THEN/ELSE en combinación con la instrucción del GOTO, pero esta forma es más difícil de leer que la estructura iterativa.

 

 

Estructura decisional equivalente a la iterativa

Algoritmo

Flujograma

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Utiliza la estructura iterativa WHILE/WHILE-END cuando desconoces el número de veces que hay que repetir las instrucciones (no sabes el número de clientes para entrar determinada información, si buscas la cantidad total de ventas durante el día y no sabes el número de ventas), o cuando hay casos donde las instrucciones iterativas no deben procesarse (si vas a calcular el promedio de un examen para cada estudiante, pero  algunos estudiantes no tomaron el examen). Para calcular el promedio hay que acumular y contar las puntuaciones del examen y luego dividir la puntuación total por el número de exámenes. Si un estudiante no tomó ningún examen, la computadora va a dividir por cero, dando como resultado un error. La estructura iterativa WHILE/WHILE-END permite obviar a este tipo de estudiante y seguir con el siguiente.

 

Fases del Loop

 

Loop entry. El momento en el que el flujo de control lee la primera instrucción dentro del cuerpo del loop.

Iteration. Cada vez que el cuerpo del loop es ejecutado. Repetición de un loop.

Loop test. Antes de cada iteración, se pasa el control al principio del loop. Es el punto en el que la expresión While es evaluada y se toma la decisión para iniciar una nueva repetición o saltar a la instrucción que sigue inmediatamente al loop.

Loop exit. Cuando la última repetición es completada y el flujo de control pasa a la primera instrucción que sigue al cuerpo del loop, el programa ha salido del loop. El punto desde el que la repetición del cuerpo del loop finaliza y se pasa el control a la primera instrucción que sigue al loop.

Termination condition. La condición que causa la salida del loop.

 

Ten encuenta que el loop exit ocurre en un punto: cuando el loop test es ejecutado. Y aunque la termination condition haya sido satisfecha para no repetir el loop, la iteración actual es completada antes que la computadora verifique la expresión While otra vez.

 

 

Loops con WHILE en C++

Los dos tipos de loops más comunes son “count-controlled loops” (donde se repite un número específico de veces) y “event-controlled loops” o REPAET/UNTIL (el cual se repite hasta que ocurra algo dentro del loop, hasta que la condición, por ejemplo, sea CIERTA).

 

Count-controlled loop. Es un loop que ejecuta un número específico de veces.

 

Event-controlled loop. Es un loop que finaliza cuando sucede algo dentro del cuerpo del loop como señal de que hay que salir del loop.

 

Count-controlled Loops

 

Antes de entrar a este tipo de loop hay que inicializar (calibrar el valor inicial) la variable del loop y luego probarlo. Además, como parte de cada iteración (repetición) del loop, hay que incrementar (aumentar en 1) la variable del loop control. A continuación un ejemplo:

 

// Programa de Saludo

// Este programa demuestra un  count-controlled loop

#include <iostream>

 

using namespace std;

 

int main()

{

     int loopCount;     // Variable del loop control

     loopCount = 1;    // Inicialización

     while (loopCount <= 10)    //Test

    {

                cout << “HOLA!” << endl;

                loopCount = loopCount + 1;   // Incremento

    }

    return 0;

}

 

 

#include <iostream>

 

using namespace std;

 

int main()

{

     int loopCount;                

     loopCount = 1;                

     while (loopCount <= 10)         

    {

                cout << "HOLA!" << endl;

                loopCount ++;  

    }

    return 0;

}

 

En el programa anterior, loopCount es la variable loop control”. Se ha calibrado a 1 antes de la entrada al loop. La instrucción While evalúa la expresión

 

LoopCount <= 10

 

Y ejecuta el cuerpo del loop hasta que la expresión sea true. Una vez dentro del cuerpo del loop, la acción principal que queremos sea repetida es la instrucción del output (“HOLA”). La última instrucción del cuerpo del loop se encarga de incrementar loopCount añadiendo 1 a si mismo. Observa:

 

variable = variable + 1;

 

La variable que se usa de esta forma se llama counters o contador. La variable que controla un count-controlled loop es siempre un contador.

 

En C++ hay otra forma de incrementar una variable. El operador de incremento (++) aumenta la variable que es su operando. La instrucción

 

loopCount = loopCount + 1;  

 

hace el mismo efecto que

 

loopCount ++;

loopCount = loopCount + 1;  

 

 

//********************************************************************

// Suma

 

#include <iostream>

 

 

using namespace std;

 

int main()

{

   int sum, count, number;     

 

   sum= 0;                     // Inicializa la suma

   count = 1;

  

   while (count <=10)

   {

               cout << "Entra un numero: "<< endl;

               cin >> number;                      //Imput a value

               sum = sum + number;            //Ad a value to sum

               count++;

 

   }

  

   cout <<"Total: " <<sum;

 

   return 0;   // indicate program ended successfully

}

 

//--------------------------------------------------------------------------------------------

//Cuenta hasta cien

 

#include <iostream>

 

using namespace std;

 

            int main()

                        {

                        int contador = 0;

 

                        while ( contador<100 )

                                    {

                                    contador++;

                                    cout << "Ya voy por el " <<contador;

                                    cout<<" pararé enseguida."<<endl;

                                    }

           

 

            return 0;

            }

 

 

 

//**************************************************************

// Class average program with counter-controlled repetition

 

#include <iostream>

 

using namespace std;

 

int main()

{

   int total,                      // sum of grades

       gradeCounter,       // number of grades entered

       grade,                    // one grade

       average;                // average of grades

 

   // initialization phase

   total = 0;                           // clear total

   gradeCounter = 1;            // prepare to loop

 

   // processing phase

   while ( gradeCounter <= 5 )       // loop 5 times

                        {

          cout << "Enter grade: ";                    // prompt for input

          cin >> grade;                                     // input grade

          total = total + grade;                         // add grade to total

          gradeCounter = gradeCounter + 1;  // increment counter

                        }

 

            // termination phase

            average = total / 5;                // integer division

            cout << "Class average is " << average << endl;

 

   return 0;                                         // indicate program ended successfully

}

 

//*********************************************************************

//Otra forma desacar el promedio

// ********************************************************************

#include <iostream>

 

using namespace std;

 

int main()

{

   int total,                      // sum of grades

       gradeCounter,       // number of grades entered

       grade,count,                      // one grade

       average;                // average of grade;

   // initialization phase

   total = 0;                           // clear total

   gradeCounter = 1;            // prepare to loop

 

   // processing phase

   while ( gradeCounter <= 5 )       // loop 5 times

                        {

          cout << "Enter grade: ";                    // prompt for input

          cin >> grade;                                     // input grade

          total = total + grade;                         // add grade to total

          gradeCounter = gradeCounter + 1;  // increment counter

                        }

 

            // termination phase

           

            cout<<"El total es: " <<total <<endl;

            cout<<"Son: "<<gradeCounter-1 <<" notas"<<endl;

            count=gradeCounter-1;  //Formula del promedio

            cout << "Otra forma de sacar el promedio es "

                        << total/count << endl;

   return 0;                                         // indicate program ended successfully

}

 

// *********************************************************************

// Este programa suma los minutos y segundos

// de la duración de tres discos en un “party”

 

#include <iostream>

 

// Las tres líneas que siguen equivalían en versiones anteriores a using namespace std

 

using std::cout; 

using std::cin;

using std::endl;

 

int main()

{

   int numeroCounter,

               numeroDisc,       

       minutos,

               totalMinutos,

               segundos,

               totalSegundos,

               sumMinutos,

               sumSegundos,

               total;     

 

   // initialization phase

    

   totalMinutos = 0;

   totalSegundos =0;

   numeroCounter = 1;                   

 

   // processing phase

   while ( numeroCounter <= 3 )

  

   {       // loop 3 times

      cout << "Entra  # disco: ";          // prompt for input

      cin >> numeroDisc;                     // input grade

              cout << "Entra  minutos: ";

              cin >> minutos;

              cout << "Entra  segundos: ";

              cin >> segundos;

     

      numeroCounter = numeroCounter + 1;  // increment counter

              totalMinutos = totalMinutos + minutos;

              totalSegundos = totalSegundos + segundos;

   }

 

   // termination phase

              

   sumMinutos = totalMinutos;

   sumSegundos = totalSegundos;

  

   cout << "Total minutos es: " <<sumMinutos << endl;

   cout << "Total segundos es: " <<sumSegundos << endl;

 

   return 0;   // indicate program ended successfully

}

 

// ******************************************************************

 

 

Event-Controleld Loops

 

Sentinel-Controlled Loops

 

A veces el loop se utiliza para leer y procesar listas largas de datos. Cada vez que el cuerpo del loop es ejecutado, una nueva pieza de datos es leída y procesada. Entonces se utiliza el valor especial de un dato, llamado sentinel o trailer value como una señal para decir al programa de que no hay más datos para procesar. El loop para cuando el programa reconoce al centinela. En otras palabras, la lectura del valor centinela es el evento que controla el proceso del loop.

 

//*********************************************************************************

//Programa para leer datos del calendario

 

#include <iostream>

 

using namespace std;

 

int main()

{

           

            int mes;

            int dia;

           

            cout << "Entre el numero y el dia de un mes" << endl;

            cout << "Para salir del loop entra 2 y 31" << endl;

           

            cin >> mes >> dia;  / / Entrada del mes y día

 

            while (!(mes == 2 && dia == 31) )  // Valor Centinela

            {

                        cout << mes << " / "<< dia << endl;   // Procesa los datos entrados

                       

                        cin >> mes >> dia;   / / Entrada de la siguiente fecha

            }

            return 0;

}

 

// Este programa lee y cuenta los caracteres entrados hasta que se encuentre con una coma (,)

 

// Lee y cuenta los caracteres entrados

 

#include <iostream>

 

using namespace std;

 

int main()

 

{

   int count,sum;

   char entraChar;

 

   cout << "Presiona cualquier tecla" << endl;

   cout << "Para salir del loop debes presionar el punto (.)" << endl;

  

   // initialization phase

   count = 0;

 

 

   cin.get (entraChar);                // lee el primer caracter

  

 

    

   // processing phase

   while ( entraChar != '.')       //Valor del centinela

                                {

                                                count++;    //Increment counter

                                                cin.get (entraChar);  // Get the next character

                                                sum=count/2;

                                }

    

                cout <<"Total:  "<<sum << " caracteres."<<endl;

   return 0;   // indicate program ended successfully

}

 

La variable del contador en este ejemplo se conoce como iteration counter (es una variable que aumenta con cada iteración del loop) porque su valor equivale al número de repeticiones dentro del loop.

 

//******************************************************************************

 

Flag-Controlled Loop

 

// Suma y cuenta los primeros 10 numeros impares

//Se usa el operador modulus (%) para encontrar el impar

// Si el numero % 2 es igual a 1, el numero es impar

//La división modulo es el número entero del remanente

 

#include <iostream>

 

 

using namespace std;

 

int main()

{

   int sum, count, number,menosDeDiez;     

 

   count = 0;     // Initialize event counter

   sum= 0;                               // Inicializa la suma

  

   menosDeDiez = true;     //Initialize loop control flag

  

   while (menosDeDiez)

   {

                   cout << "Entra un numero: "<< endl;

                   cin >> number;                  //IGet the next value value

                   if (number % 2 == 1)  //¿Es impar el valor?

                   {

                                   count++;                                             //Yes -- Aumenta el contador

                                   sum = sum + number;       //Ad a value to sum

                       menosDeDiez = (count < 10);  //Actualiza el loop control flag

 

                   }

   }

   cout <<"Total: " <<sum <<endl;

 

   return 0;  

}

 

En este ejemplo, el contador es un event counter; es inicializado en 0 y aumenta sólo cuando ocurre cierto evento, en este caso cuando el número es impar. Todo número impar % 2 da siempre un remanente de 1; mientras que el número par % da siempre 0.

//*************************************************************************

#include <iostream>

 

 

using namespace std;

 

int main()

{

   int sum, negative, numero;     

 

   sum= 0;

   negative = false;   // initialization flag

   while (!negative)

   {

                cout << “Entra un numero (para salir el # debe ser > de 2  “ <<endl;   

                cin >> numero;

                                if (numero > 2)                      // Test input value

                                                negative = true;   //Set flag if even ocurred

                                else

                                                sum = sum + numero;

   }

  

   cout <<"Total: " <<sum;

 

   return 0;  

}