WEBVTT

00:00.390 --> 00:03.090
Ahora el tema es un tema muy muy importante.

00:03.090 --> 00:10.050
Este tema son los bucles que también se denominan declaraciones repetidas o declaraciones interactivas.

00:10.050 --> 00:17.610
Es al mismo tiempo que este tema juega un papel muy importante en la programación y este es un tema

00:17.840 --> 00:19.420
nuevo para los principiantes.

00:19.470 --> 00:22.910
Como si vienes de las matemáticas, las matemáticas no tienen bucles.

00:22.950 --> 00:28.620
Así que aquí tienes que aprender algo nuevo en programación y esto requiere mucha práctica.

00:28.650 --> 00:31.170
Qué todos los programas aprendes aquí bajo este tema.

00:31.170 --> 00:35.030
Debes practicarlos todos y debes resolver una serie de desafíos.

00:35.040 --> 00:40.340
Y ejercicios de codificación que debes hacer. si confía en esta parte de la programación.

00:40.350 --> 00:42.710
Entonces podrás solucionar cualquier problema.

00:42.810 --> 00:45.780
Si tiene algún conocimiento sobre ese problema.

00:46.200 --> 00:49.610
Ahora veamos qué otros bucles están disponibles en C ++.

00:49.830 --> 00:56.780
C ++ tiene tres tipos de bucles, while bucle do while bucle, for bucle y para cada bucle.

00:56.930 --> 01:01.560
ahora, en este video, les daré una introducción a los bucles y también les explicaré estos dos primeros, luego el siguiente video

01:01.560 --> 01:07.830
lo veremos para el bucle y para cada bucle que veremos en otro momento. ahora que son estos

01:07.820 --> 01:08.730
bucles.

01:08.730 --> 01:11.050
Entendamos de este diagrama de flujo.

01:11.670 --> 01:13.440
Ya hicimos un diagrama de flujo.

01:13.480 --> 01:15.120
Ahora veamos este diagrama de flujo.

01:15.120 --> 01:16.000
¿Cómo está funcionando?

01:16.020 --> 01:20.840
Lo rastrearé y les mostraré, el punto de partida y algunas aportaciones que se están tomando.

01:20.880 --> 01:23.700
Cualquiera que sea el problema, está recibiendo alguna aportación.

01:23.730 --> 01:27.700
El procesamiento se realiza después de que se verifique esa condición.

01:27.900 --> 01:34.390
Si la condición es verdadera, vuelve aquí y se procesa y la condición es verdadera.

01:34.440 --> 01:36.130
De nuevo se realiza el procesamiento.

01:36.180 --> 01:37.640
Esto se repetirá.

01:37.650 --> 01:41.060
Entonces, este bloque, esta parte de procesamiento, continuará Repitiéndose

01:41.070 --> 01:47.700
siempre que esa condición sea verdadera y una vez que las condiciones se vuelvan falsas, saldrá y cualquiera que

01:47.700 --> 01:52.920
sea la salida tiene que imprimir y luego detenerse, por lo que en cualquier procedimiento.

01:52.920 --> 01:59.410
Si tiene que ejecutar repetidamente algún conjunto de declaraciones, puede ejecutarlas repetidamente.

01:59.460 --> 02:08.650
Entonces, al usar el bucle, este es un bucle, por lo que estas declaraciones se usan para ejecutar repetidamente un conjunto de declaraciones.

02:08.730 --> 02:14.670
Este tipo de cosas que hacemos comúnmente en nuestra vida diaria repetidamente, realizamos algunos pasos como, tomaré

02:14.670 --> 02:20.880
un ejemplo simple, supongamos que tomas un café y tienes que agregar un poco de azúcar para que pongas

02:20.880 --> 02:25.530
un poco de azúcar cucharadita de azúcar y Lo removeré y lo comprobaré.

02:25.530 --> 02:33.290
Aún no está dulce, aunque puedo poner un poco de azúcar y revolverlo y comprobar que no está dulce y luego volver a ponerlo.

02:33.510 --> 02:40.920
Entonces seguirás mientras no esté dulce, cuando esté lo suficientemente dulce entonces pararás así que pon el azúcar revuélvelo

02:40.910 --> 02:44.460
y revísalo, pon el azúcar revuélvelo y revísalo.

02:44.670 --> 02:46.460
Así que este es un procedimiento repetido.

02:46.650 --> 02:48.120
Tomemos un ejemplo más.

02:48.230 --> 02:50.850
Estás caminando hacia tu casa.

02:50.910 --> 02:52.000
No he llegado a casa.

02:52.020 --> 02:54.960
Luego, camine un paso y luego camine y verifique.

02:55.020 --> 02:55.790
Has llegado a casa.

02:55.800 --> 02:57.080
No he estado en casa.

02:57.130 --> 02:58.000
Entonces da un paso.

02:58.020 --> 02:59.110
No he llegado a casa.

02:59.130 --> 02:59.940
Da un paso.

02:59.940 --> 03:05.050
Por lo tanto, mientras no haya llegado a casa, continuará tomando medidas.

03:05.160 --> 03:11.220
Una cosa más que hemos visto en el sistema numérico como convertir un número decimal llamado número

03:11.400 --> 03:15.090
binario dividido por dos, dividido por dos, dividido por dos.

03:15.090 --> 03:17.050
¿Cuánto tiempo? hasta que se vuelva cero.

03:17.100 --> 03:22.650
Entonces, ¿es cero, no cero continuar, no cero, dividir, no cero dividir, no cero dividir, cero?

03:22.740 --> 03:23.780
Parada.

03:23.790 --> 03:30.470
Así es como en muchos lugares usamos la repetición, por lo que en el cálculo también usamos la repetición.

03:30.470 --> 03:38.040
El ejemplo que le doy convierte a decimal, decimal a binario, así es como resolvemos los

03:38.070 --> 03:42.220
problemas que tienen pasos repetidos usando estos bucles.

03:42.240 --> 03:45.150
Ahora entendamos cómo funcionan estos bucles.

03:45.180 --> 03:50.400
Recogeré un momento y lo haré, mostraré este esqueleto y también el diagrama de flujo.

03:50.430 --> 03:57.730
Luego, más adelante veremos un problema o un programa en el que veamos la sintaxis de dos bucles.

03:57.760 --> 03:59.890
Eso es salvaje y hacer mientras.

04:00.580 --> 04:04.110
Así que aquí está la sintaxis while condition is there.

04:04.630 --> 04:12.390
Y luego este es el cuerpo de mientras se usan corchetes de flores de bucle, dentro de ese proceso, lo que sea que quieras

04:12.400 --> 04:16.890
hacer, puedes escribir en eso adentro. luego hazlo mientras, haz Primero, luego el

04:16.890 --> 04:19.840
corchete de flores y luego dentro del proceso está allí.

04:19.990 --> 04:26.170
Luego, mientras que la condición está al final y la condición que debe cerrarse con punto y coma, debe terminar con Punto y coma

04:26.170 --> 04:27.090
a la derecha.

04:27.100 --> 04:31.110
Aquí no es necesario el punto y coma, pero aquí el punto y coma debe hacerlo.

04:31.180 --> 04:35.020
Entonces, primero se verifica la condición y luego se realiza el proceso.

04:35.020 --> 04:38.160
Primero se procesa y luego se verifica la condición.

04:38.170 --> 04:38.970
Esto es diferente.

04:38.980 --> 04:40.470
Entonces hay una pequeña diferencia.

04:40.540 --> 04:42.100
No es una gran diferencia.

04:42.100 --> 04:43.540
Son casi iguales.

04:43.540 --> 04:45.520
La mayoría de los estudiantes se confunden aquí.

04:45.550 --> 04:46.420
Cuál es la diferencia.

04:46.420 --> 04:47.480
¿Cuál usas?

04:47.560 --> 04:50.940
Así que no es gran cosa que puedas usar cualquiera de ellos.

04:51.010 --> 04:55.440
La única diferencia es que esto primero procesará y luego verificará la condición.

04:55.480 --> 04:57.980
Significa la diferencia i.

04:58.210 --> 05:02.510
Si la condición ya es falsa, esto no se ejecutará, aquí, si la

05:02.590 --> 05:08.010
condición ya es falsa, suponga que la primera vez que solo la condición es falsa, primero se ejecutará.

05:08.050 --> 05:09.190
Luego verifique la condición.

05:09.190 --> 05:12.070
Por lo que se ejecutará como mínimo una vez.

05:12.190 --> 05:13.720
Esa es la diferencia.

05:13.780 --> 05:15.040
No hay dónde usarlos.

05:15.040 --> 05:17.110
¿Hay diferentes lugares para usar?

05:17.110 --> 05:18.440
No hay nada de eso.

05:18.670 --> 05:23.910
La mayoría de los programas usan este bucle y también este bucle, por lo que no hay una gran diferencia.

05:23.990 --> 05:24.470
Ahora,

05:24.670 --> 05:27.520
entendamos diagraméticamente, aquí este es un diagrama de

05:27.580 --> 05:30.340
flujo, así que estamos comenzando y tiene algo

05:30.340 --> 05:31.210
al principio.

05:31.210 --> 05:31.970
Solo déjalo.

05:32.140 --> 05:33.750
Míralo desde este punto.

05:33.820 --> 05:34.980
La primera condición es comprobar.

05:34.990 --> 05:36.730
Si es cierto, el proceso está terminado.

05:36.760 --> 05:40.430
Luego, nuevamente vuelve a este punto para que nuevamente verifique la condición.

05:40.510 --> 05:42.990
Si es cierto, los procesos están listos y luego repita.

05:43.060 --> 05:47.180
Así es como se repite el proceso si la condición es falsa, entonces continuará normalmente.

05:47.380 --> 05:50.530
Saldrá de este bucle y continuará normalmente.

05:50.530 --> 05:52.660
Entonces se verifica la primera condición y se realizan los procesos.

05:53.110 --> 05:58.220
Así que este es un diagrama de flujo para el ciclo while. ahora haz while loop.

05:58.250 --> 06:00.110
Comenzar el primer proceso está hecho.

06:00.110 --> 06:01.090
Verificación de condiciones.

06:01.370 --> 06:06.070
Y si es así, volverá a entrar en el proceso y repetirá el proceso para que

06:06.070 --> 06:11.830
el primer proceso se complete, luego la condición es verificar si la condición es falsa, luego continuará fuera del ciclo

06:11.830 --> 06:13.940
y continuará el resto de las declaraciones.

06:14.020 --> 06:17.380
Así que este es el diagrama de flujo para el ciclo do while.

06:17.410 --> 06:20.770
No, escribiré en un programa primero usando while loop.

06:20.830 --> 06:27.730
Escribiré un programa para mostrar números del uno al n y puede ser 10 o 20, lo que sea, así que

06:27.730 --> 06:28.620
supongamos que

06:28.660 --> 06:29.850
n es un 10.

06:29.850 --> 06:32.850
Mostraremos números del 1 2 3 4 5 al 10.

06:33.880 --> 06:37.290
Escribamos el programa para este para mostrar n números.

06:37.300 --> 06:37.710
Bueno.

06:37.840 --> 06:40.530
Primero escribiré un programa para esto usando este bucle.

06:40.540 --> 06:46.100
Entonces, nuevamente convertiré ese programa y le mostraré cómo escribir en la misma cosa usando do while loop.

06:46.480 --> 06:49.000
Echemos un vistazo al programa.

06:49.000 --> 06:54.810
Escribamos un programa para mostrar números del 1 al n, para eso ya tengo un diagrama de flujo.

06:54.940 --> 06:56.850
Veamos el diagrama de flujo de trabajo.

06:56.890 --> 07:01.750
En primer lugar, debemos saber un número que es 10, 20 hasta donde desea mostrar un número.

07:01.810 --> 07:03.820
Escribe de 1 a hasta qué.

07:03.940 --> 07:05.160
Entonces esa es una idea.

07:05.850 --> 07:13.350
Ahora suponga que si tengo que mostrar hasta diez, digamos que n es 10, entonces tengo que mostrar números del

07:13.350 --> 07:14.860
1 2 3 4.

07:14.860 --> 07:19.790
Así que para eso necesito algo para contar, contraataque a la

07:20.020 --> 07:20.550
derecha.

07:20.620 --> 07:26.130
Entonces, para eso tengo I que es inicialmente uno aquí que usé inicialmente 1.

07:26.980 --> 07:29.000
Entonces comenzaré desde el 1 en adelante.

07:29.000 --> 07:29.880
Entonces 1.

07:29.890 --> 07:33.440
Luego, verifique si i es menor que igual an.

07:33.540 --> 07:34.480
n es qué? 10.

07:34.540 --> 07:35.470
Así que ahora no diré n.

07:35.510 --> 07:38.440
diré 10. Yo menor que igual a 10.

07:38.530 --> 07:39.380
Si.

07:39.400 --> 07:43.890
Entonces, ¿qué? print i, I value is what, 1.

07:44.260 --> 07:52.730
Luego asigno con i más 1 que hemos visto operar esto en concordancia incremental en ese momento que les he

07:52.730 --> 07:53.330
mostrado.

07:53.330 --> 07:54.590
Esta es una práctica común.

07:54.590 --> 08:00.680
Esto es útil para contar que cualquiera que sea el valor de i, le está agregando uno, así que incremente.

08:00.680 --> 08:02.660
Entonces me convertiré en dos.

08:02.720 --> 08:04.450
Este es el primer paso.

08:04.710 --> 08:05.760
imprimir I.

08:06.040 --> 08:09.070
Yo era uno inicialmente y luego un incremento.

08:09.080 --> 08:10.490
Yo al siguiente número.

08:10.490 --> 08:11.550
Eso es 1.

08:11.600 --> 08:17.660
Luego continúe así nuevamente verifique la condición nuevamente verifique que la condición 2 sea menor que igual a 10.

08:17.690 --> 08:18.250
Si.

08:18.320 --> 08:19.720
Así que imprima e incremente.

08:19.970 --> 08:21.160
Entonces el siguiente es imprimir.

08:21.170 --> 08:21.590
Ahora.

08:21.590 --> 08:22.020
2.

08:22.040 --> 08:26.840
Yo es dos y luego de ese incremento, esto se convierte en 3.

08:27.080 --> 08:29.840
Luego, de nuevo, después de este bucle continuo a la derecha.

08:29.960 --> 08:31.380
Esto está usando while loop.

08:31.410 --> 08:35.000
Entonces, a continuación, verifique nuevamente que la condición i es menor que igual an.

08:35.150 --> 08:37.450
Entonces 3 es menor que igual a 10 sí.

08:37.460 --> 08:38.470
Así que el siguiente paso.

08:38.540 --> 08:39.730
Imprima e incremente.

08:39.800 --> 08:45.510
Entonces no, lo repetiré tres y cuatro, luego cuatro y luego se convertirán en cinco.

08:45.590 --> 08:52.370
Cinco es menos que diez, por lo que cinco, luego seis, luego seis es menor que diez para

08:52.370 --> 08:58.200
traer seis y hacer siete siete luego ocho, luego ocho y luego incrementar nueve.

08:58.400 --> 09:02.610
Luego imprima nueve incrementos 10 10 es menor que igual a.

09:02.780 --> 09:06.480
Sí, entonces imprima y luego incremente once.

09:06.530 --> 09:11.060
Ahora imprima un once, esta vez i es menor que igual a 10.

09:11.060 --> 09:12.440
No falso.

09:12.620 --> 09:13.640
Así que deja de.

09:13.640 --> 09:15.780
Después de esto, se detendrá.

09:15.920 --> 09:19.120
Así que les he mostrado el funcionamiento del diagrama de flujo.

09:19.140 --> 09:21.200
Funciona así.

09:21.350 --> 09:24.500
Ahora convierta ese diagrama de flujo en programa.

09:24.560 --> 09:26.690
Consulte para iluminar los programas como este.

09:26.690 --> 09:29.600
En primer lugar, debemos averiguar qué tienes que hacer.

09:29.630 --> 09:30.990
Primero debes hacer esto.

09:31.010 --> 09:33.480
Luego, a partir de esto, obtienes datos del diagrama de flujo.

09:33.590 --> 09:35.560
No obtendrá directamente la idea del diagrama de flujo.

09:35.750 --> 09:36.680
Trabaja en este.

09:36.730 --> 09:40.040
Prepara una mesa como esta e intenta averiguar lo que quieres.

09:41.130 --> 09:44.430
Luego, en base a esto, hay un diagrama de flujo de ese diagrama de flujo.

09:44.430 --> 09:51.950
Escribiré una programación en C ++ tan int main ahora dentro de esto.

09:52.110 --> 09:53.160
Necesito algunas variables.

09:53.160 --> 09:54.850
¿Qué son esos ny eye.

09:55.260 --> 09:57.910
Así que declararé que son de tipo int.

09:57.930 --> 09:58.490
Entonces

09:58.650 --> 10:03.700
n Y yo, ¿qué es lo primero que ingresa un número y lee un número?

10:03.720 --> 10:06.540
Entonces, ingrese un número y lea un número.

10:06.540 --> 10:18.150
C out ingrese el número luego C in n ahora inicialmente se me asigna uno, así que no tengo que hacerlo aquí, puedo asignarlo directamente, es

10:18.220 --> 10:24.880
igual a uno aquí que está al principio, luego verifique la condición y repita la

10:24.930 --> 10:25.590
declaración.

10:25.620 --> 10:31.460
Así que esto es bucle, así que while Bucle, while, cuál es la condición en while.

10:31.680 --> 10:33.020
Yo es menor que igual n.

10:33.300 --> 10:41.430
I es menor o igual an, entonces, ¿qué hay dentro del cuerpo de la impresión de bucle? Luego incremento

10:41.430 --> 10:49.650
i para imprimir i Cout I entonces, inicialmente es uno, imprimirá uno, luego 2 deberían aparecer en la siguiente línea.

10:49.650 --> 10:58.200
Así que aquí debería escribir endl y luego la siguiente declaración es I más más.

10:58.200 --> 11:01.280
Entonces, en lugar de escribir, asigno i más uno.

11:01.440 --> 11:07.630
Tenemos un operador de acuerdo i plus plus que podemos utilizar incluso tú puedes utilizar plus plus i.

11:07.920 --> 11:12.300
Luego, después de este final de este final de la función principal.

11:12.330 --> 11:14.140
Así que aquí tienes que anotar el retorno cero.

11:14.160 --> 11:14.920
Tú sabes bien.

11:15.090 --> 11:19.180
Así que este es un programa para imprimir números a partir de uno para dar un número n.

11:19.260 --> 11:21.450
Y eso es.

11:21.450 --> 11:23.490
Ahora te mostraré cómo convertir.

11:23.490 --> 11:25.820
Lo mismo que usar do while loop.

11:26.380 --> 11:30.990
Bien, haré cambios en el diagrama de flujo y luego les mostraré los cambios en el programa.

11:31.860 --> 11:34.770
Sí, he realizado cambios en el diagrama de flujo.

11:35.040 --> 11:37.670
Leamos el diagrama de flujo. empezar, tomar un

11:37.670 --> 11:38.390
número.

11:38.640 --> 11:40.150
Entonces le asigno uno.

11:40.410 --> 11:41.190
Primera impresión.

11:42.240 --> 11:43.830
Luego, de forma incremental.

11:44.010 --> 11:50.040
Luego, para verificar si I es menor que igual an, si es menor o igual que N, si es

11:50.370 --> 11:51.270
cierto, continúe.

11:51.840 --> 11:53.690
Si es falso, deténgase.

11:53.790 --> 11:57.300
Entonces puede ver ahora que la condición se verifica después.

11:57.360 --> 12:01.320
Primero se realizan las dos declaraciones, de modo que el procesamiento se realiza primero.

12:01.620 --> 12:03.150
Entonces obtienes el mismo resultado.

12:03.210 --> 12:06.840
Lo mismo todo en lugar de escribir mientras estás aquí.

12:06.930 --> 12:09.570
Tengo que escribir hacer y aquí.

12:09.570 --> 12:15.750
Debería escribir mientras i es menor o igual que n, eso es todo.

12:16.170 --> 12:21.120
Así que este es el programa para el bucle do while para imprimir los números usando el bucle do while.

12:22.020 --> 12:23.210
Entonces eso es fácil.

12:23.250 --> 12:24.600
Entonces no hay confusión.

12:24.600 --> 12:33.060
Te diré que siempre puedes escribir un código usando el bucle while y también hacer el bucle while. se puede escribir lo mismo.

12:33.150 --> 12:35.010
Es como una eleccion.

12:35.100 --> 12:37.790
Muy raramente nos encontramos con eso, primero necesitamos

12:37.870 --> 12:40.010
procesar y luego verificar la condición.

12:40.020 --> 12:41.550
Situaciones muy raras.

12:41.670 --> 12:44.610
Entonces, si te encuentras con esa situación, lo entenderás.

12:45.180 --> 12:47.160
Eso es todo sobre este.

12:47.400 --> 12:50.100
Así que les daré un ejercicio de codificación para esto.

12:50.100 --> 12:54.620
Por lo tanto, es posible que tenga que escribir solo la parte del bucle, si encuentra los ejercicios de codificación para esto.

12:54.630 --> 12:55.800
Solo escribe el bucle.

12:56.100 --> 12:59.750
Está bien para el bucle y también hay una demostración para este.

12:59.760 --> 13:06.210
Así que mira la demostración para while do while además de incluir for loop. así que ahora el próximo video estará

13:06.210 --> 13:07.370
en bucle.

13:07.500 --> 13:09.380
Y ese es el más utilizado.

13:09.380 --> 13:10.020
Círculo.

13:10.020 --> 13:10.980
Echemos un vistazo a seguir.
