Diferencias

Muestra las diferencias entre dos versiones de la página.

--- curso-cpp:estructuras-repetitivas [2017/02/07 03:40]
santo
+++ curso-cpp:estructuras-repetitivas [2017/10/29 19:26] (actual)
santo
@@ Línea 11: / Línea 11: @@
 La sintaxis (forma de escritura) de esta instrucción es idéntica al ''if'' común (sin ''else''), pero utilizando en su lugar la palabra ''while'':
-<code>
+<code cpp>
 while (condicion)
 {
     instruccion1;
     instruccion2;
-    ...
+    //...
     instruccionFinal;
 }
@@ Línea 27: / Línea 27: @@
 Veamos un primer ejemplo sencillo de esto, en el siguiente programa:
-<code>
+<code cpp>
 #include <iostream>
@@ Línea 50: / Línea 50: @@
 Recomendamos al lector ejecutar este programa para ver el efecto que tiene, y analizar cómo siguiendo las instrucciones mecánicamente de la forma que hemos explicado, se explica perfectamente el comportamiento de la computadora.
-**TODO: Primero uno que imprima los números de 1 a N, con while. Luego, lo mostramos con for para mostrar que for piola. Luego viene inmediatamente el ejercicio de la suma. Luego muestra la solución. Luego variantes de ejercicio. Luego finalmente do while para completar la sección. Luego más ejercicios.**
+Imaginemos ahora otro ejemplo: supongamos que deseamos mostrar por pantalla todos los números desde ''1'' hasta ''N'', una por línea, siendo ''N'' un cierto valor que el usuario pueda ingresar. Como la cantidad de cosas que tenemos que escribir no está prefijada, sino que depende de lo que ingrese el usuario, tendremos que utilizar necesariamente alguna estructura repetitiva, para poder así imprimir muchas veces.
+Veamos cómo puede llevarse a cabo esta tarea utilizando while. Para eso, deberemos encontrar una **condición** que nos permita saber cuándo seguir escribiendo, y cuándo parar. En estos casos puede ser útil preguntarse lo siguiente: ¿Cómo realizaríamos esta tarea, si tuviéramos que realizarla manualmente, de manera mecánica? Si tuviéramos que escribir por ejemplo, los números del 1 al 1000, lo que haríamos sería **ir contando**: escribimos el 1, **luego pasamos al siguiente número**, que es el 2, y lo escribimos, **luego pasamos al siguiente**, que es el 3, y lo escribimos, y así seguiríamos **mientras no hayamos escrito todos los números que queríamos**. ¿Cómo podemos saber si ya escribimos todos los números? Como solamente queremos escribir números **hasta N**, queremos seguir escribiendo mientras que el número a escribir a continuación **sea menor o igual que N**.
+Teniendo esto en cuenta, podemos escribir el siguiente programa para mostrar todos los números desde 1 hasta un cierto entero positivo que ingrese el usuario:
+<code cpp>
+#include <iostream>
+using namespace std;
+int main()
+{
+    int N;
+    cin >> N;
+    int x = 1;
+    while (x <= N)
+    {
+        cout << x << endl;
+        x++; // Es lo mismo que x = x + 1 en C++: incrementa el valor de x en 1
+    }
+    return 0;
+}
+</code>
+Notar que necesitamos utilizar una variable ''x'', que sirve para saber cuál es el numero actual, que vamos a escribir en cada paso. Con esta variable vamos **contando** los números que pasan, comenzando desde el 1, y aumentando en cada paso mientras que sea ''x <''''= N''. Se suele decir que ''x'' es un **contador**.
+Este mecanismo es muy común, y es el que utilizamos cuando tenemos que repetir ciertas operaciones sobre todo un **rango** de números: utilizamos una variable como contador, de forma tal manera que en el cuerpo del while, realizamos las operaciones utilizando el valor del contador (en nuestro ejemplo, ''x''). Y luego de cada paso, **cambiamos el contador al siguiente valor**, permitiendo que en la siguiente iteración se procese el siguiente número.
 ===== La instrucción for =====
+El patrón del ejemplo anterior es muy común: tenemos una **inicialización** justo antes del ''while'', donde guardamos en el contador un valor inicial adecuado: ''int x = 1;'' en el ejemplo. Luego, tenemos el ''while'' con una **condición** que indica cuándo hay que seguir procesando: ''x <''''= N'' en el ejemplo. Finalmente, para pasar al siguiente número, al final de cada paso aumentamos ''x'' al siguiente valor: usamos en el ejemplo la instrucción ''x++''. Notar que **este patrón es independiente de las operaciones que vayamos a realizar sobre los valores de x**: en cualquier caso en el que queramos **recorrer** todos los números de 1 hasta N para hacer **algo** con ellos, tendremos un código muy similar, con esas 3 partes.
+Este patrón en 3 partes (inicialización, while con condición, e incremento del contador al final del while) es tan común que existe una instrucción que lo resume para facilitar la lectura de los programas: es la instrucción ''for''.
+La sintaxis del ''for'' es:
+<code cpp>
+for(inicializacion; condicion; incremento)
+{
+    // Cuerpo de instrucciones a realizar
+}
+</code>
+Es decir, las 3 partes del patrón anterior se ponen todas juntas, entre paréntesis y separadas por punto y coma, en el momento de declarar el for. Un for como el anterior es equivalente a:
+<code cpp>
+{
+  inicializacion;
+  while(condicion)
+  {
+      // Cuerpo de instrucciones a realizar
+      incremento;
+  }
+}
+</code>
+De esta forma, el ejemplo anterior generalmente se escribiría utilizando un for, de la siguiente manera:
+<code cpp>
+#include <iostream>
+using namespace std;
+int main()
+{
+    int N;
+    cin >> N;
+    for(int x = 1; x <= N; x++)
+        cout << x << endl;
+    return 0;
+}
+</code>
+Notar que podemos omitir las llaves en este último ejemplo porque el cuerpo del for contiene una única instrucción: el incremento ''x++'' ya no se pone en el cuerpo al utilizar el for. Generalmente, la escritura con for es más clara porque separara la parte de la **iteración**, utilizada para **recorrer los valores de x que nos interesan**, del cuerpo principal donde realizamos las **operaciones** que nos interesan sobre cada valor de x.
+Además notemos que es válido declarar la variable ''x'' en la parte de inicialización del for: El ámbito de dicha variable es todo el contenido del for (tanto el encabezado de 3 partes, como el cuerpo de instrucciones). La variable ''x'' declarada en la inicialización del for **no puede** utilizarse fuera del for. Si se vuelve a realizar otro for similar, se estaría utilizando una variable x **diferente**.
+==== Ejercicios ====
+  - Escribir un programa que lea un número ''N'', y escriba en pantalla un solo número: la suma de todos los números desde 1 hasta ''N''.
+  - Escribir un programa que lea un número ''N'', y escriba en pantalla un solo número: la suma de todos los números desde 1 hasta ''N'' que sean múltiplos de 3.
+  - Escribir un programa que lea un número ''N'', y escriba en pantalla un solo número: la suma de todos los números desde 1 hasta ''N'' que sean múltiplos de 3 pero no de 5.
+  - Escribir un programa que lea un número ''N'', y escriba en pantalla un solo número: el producto de todos los números desde 1 hasta ''N'' (a este número se lo conoce como **N factorial**, y se escribe N!).
+  - Escribir un programa que lea un número ''N'', y escriba en pantalla un solo número: la suma todos los números desde 1 hasta ''N'', pero elevados al cuadrado (por ejemplo, para N=3 la respuesta es 14=1+4+9).
+==== Soluciones a los ejercicios ====
+  - El siguiente código muestra un ejemplo de solución: <code cpp>#include <iostream>
+using namespace std;
+int main()
+{
+    int N, suma = 0;
+    cin >> N;
+    for(int x = 1; x <= N; x++)
+        suma = suma + x;
+    cout << suma << endl;
+    return 0;
+}
+</code> Se puede observar que utilizamos una variable auxiliar ''suma'', que comienza en ''0'', y en cada paso lo que hacemos sumarle el número actual. De esta forma, como en cada paso el valor de ''suma'' es aumentado en el número correspondiente, al final del proceso tendrá la suma de todos los números, y por eso escribimos su valor al final. La instrucción ''suma = suma + x'' justamente aumenta el valor de suma, porque lo que allí se indica es que se guarde en la variable suma, el valor que hay ahora en la variable suma, más el valor de x. Esta instrucción también puede abreviarse en C++ como ''suma += x'' (similarmente, existen operadores ''-='' para restar, ''*='' para multiplicar, etc).
+  - Este ejemplo es muy parecido al anterior: basta agregarle un if para que solamente se ejecute la operación de suma, cuando el número actual es múltiplo de 3. <code cpp>#include <iostream>
+using namespace std;
+int main()
+{
+    int N, suma = 0;
+    cin >> N;
+    for(int x = 1; x <= N; x++)
+    if (x % 3 == 0)
+        suma += x;
+    cout << suma << endl;
+    return 0;
+}
+</code>
+  - <code cpp>#include <iostream>
+using namespace std;
+int main()
+{
+    int N, suma = 0;
+    cin >> N;
+    for(int x = 1; x <= N; x++)
+    if (x % 3 == 0 && x % 5 != 0)
+        suma += x;
+    cout << suma << endl;
+    return 0;
+}
+</code>
+  - Este ejercicio es casi igual al primero, pero en lugar de sumar los números, queremos multiplicarlos. Utilizaremos ''*'' entonces en lugar de ''+'' para la operación. <code cpp>#include <iostream>
+using namespace std;
+int main()
+{
+    int N, producto = 1;
+    cin >> N;
+    for(int x = 1; x <= N; x++)
+        producto *= x;
+    cout << producto << endl;
+    return 0;
+}
+</code> Un detalle importante es que al calcular un producto, **inicializamos la variable auxiliar en uno**, y no en cero como hacíamos en el caso de la suma. Notar que como le vamos multiplicando cada vez más números, si comenzara en cero, quedaría en cero para siempre. Los factoriales son números que crecen muy rápidamente: si ejecutamos el programa, veremos que ya con valores de ''N'' mayores que 12 obtenemos resultados demasiado grandes para el tipo de datos int, con lo cual veremos resultados erróneos, y a veces incluso negativos.
+  - <code cpp>#include <iostream>
+using namespace std;
+int main()
+{
+    int N, suma = 0;
+    cin >> N;
+    for(int x = 1; x <= N; x++)
+        suma += x*x;
+    cout << suma << endl;
+    return 0;
+}
+</code>
 ===== La instrucción do-while =====
+La última estructura de control repetitiva es la instrucción do-while, que es la menos utilizada de todas. Esta instrucción funciona igual que ''while'', pero con la única salvedad de que la condición se verifica **luego** de cada paso, en lugar de **antes** de cada paso. Por lo tanto, do-while siempre realiza al menos un paso, mientras que con un while, si la condición es falsa al comenzar, no se realiza ningún paso.
+<code cpp>
+do
+{
+   // cuerpo de instrucciones a repetir
+} while (condicion);
+</code>
 ===== Ejercicios =====
-    * Escribir un programa que lea un numero N, y luego imprima la suma de los primeros N naturales.
+    * [[http://juez.oia.unsam.edu.ar/#/task/pares_impares/statement|Escribir un programa que lea un numero N, y luego imprima la suma de los números pares, menos la suma de los impares, para los primeros N naturales]]. Por ejemplo, para N=3 sería 2 - (1+3), para N=6 sería (2+4+6)-(1+3+5), para N=1 sería -1.
-    * Escribir un programa que lea una palabra, y la imprima encerrada en un cuadrado de asteriscos. Ejemplos:<code>
+    * [[http://juez.oia.unsam.edu.ar/#/task/pollo_pan/statement|Escribir un programa que lea una palabra, y la imprima encerrada en un cuadrado de asteriscos]]. Ejemplos:<code>
       Si lee "pollo" imprime:
        *******
@@ Línea 68: / Línea 232: @@
        *pan*
        *****</code>
-    * Escribir un programa que lea N numeros, y visualice el maximo, el minimo y la suma. El valor de N se solicita al comenzar.
+    * [[http://juez.oia.unsam.edu.ar/#/task/max_min_sum/statement|Escribir un programa que lea N números, y visualice el máximo, el mínimo y la suma]]. El valor de N se solicita al comenzar.
-    * Escribir un programa que lea una palabra, y la imprima al revés (leída de derecha a izquierda).
+    * [[http://juez.oia.unsam.edu.ar/#/task/string_reverser/statement|Escribir un programa que lea una palabra, y la imprima al revés (leída de derecha a izquierda)]].
-    * Un numero es perfecto, cuando la suma de sus divisores es igual al mismo numero. Crear un programa que busque y encuentre los primeros 3 numeros perfectos.
+    * Un número es perfecto, cuando la suma de sus divisores es igual al mismo número. [[http://juez.oia.unsam.edu.ar/#/task/busca_perfectos/statement|Crear un programa que dado un N, busque y encuentre todos los números perfectos hasta N]].
-    * Un numero es primo, cuando no tiene divisores que no sean 1 o el mismo numero. Hacer un programa que imprima los primos hasta N, para N dado por la entrada.
+    * Un número es primo, cuando no tiene divisores que no sean 1 o el mismo número. [[http://juez.oia.unsam.edu.ar/#/task/busca_primos/statement|Hacer un programa que imprima los primos hasta N, para N dado por la entrada]].

OIA-Wiki

Herramientas de usuario

Herramientas del sitio

Diferencias

Herramientas de la página