Introdução à Programação Vol. 2

Vista previa del material en texto

2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
AUTORES 
ING. YOLANDA ESCOBAR MANCILLA 
ING. JOSE LUIS FLORES MAMANI 
 
 
 
 
NUMERO DEPOSITO LEGAL: 4 – 1 – 2969 – 2022 
 
 
DISEÑO, DIAGRAMACIÓN E IMPRESO 
EN LOS TALLERES GRÁFICOS 
Creaciones PROGRAFIC 
CEL.: 67066679 – 742 74777 
 
 
 
 
PREFACIO 
El presente libro Introducción a la Programación Volumen 2, abarca las 
Estructuras Repetitivas, las mismas se utilizan para la ejecución de un conjunto de 
instrucciones en un determinado numero finito de veces, a esta operación se la 
llama bucles o ciclos. Conocer la teoría y la practica utilizando un lenguaje de 
programación es principal para la formación profesional del área de ingeniería, el 
presente libro toma como lenguajes de programación al lenguaje C y lenguaje 
java, así mismo el libro contempla el proceso para la resolución de un problema, 
partiendo del análisis del problema, elaboración del diagrama de flujo, 
demostrando la prueba de escritorio y codificando en lenguaje C y JAVA junto con 
la captura de salida en ambos lenguajes. 
La motivación sobre la elaboración de este libro, deriva en ofrecer un material 
educativo que incorpore los aspectos necesarios para la resolución de un 
problema hasta la salida de un programa por computadora escrito en lenguaje C o 
lenguaje JAVA, a través de ejemplo expresados de forma didáctica mediante una 
explicación clara y sucinta de los ejemplos resueltos en el libro. 
La introducción a la comprensión de las estructuras repetitivas comprende el 
funcionamiento y la sintaxis en ambos lenguajes de programación de los ciclos for, 
while y do-while, además aplicando los ciclos repetitivos, efectuar la resolución de 
series y sumatorias. 
Cada uno de los capítulos que conforman este libro, se exponen aspectos teóricos 
y prácticos, mediante ejemplo resueltos y su codificación en ambos lenguajes de 
programación que facilita el aprendizaje de la programación y refuerza los 
aspectos teóricos y prácticos de este presente libro. 
 
 
ÍNDICE 
CAPITULO I ............................................................................................................................ 7 
FUNDAMENTOS .................................................................................................................... 7 
1.1 DEFINICIÓN ................................................................................................................ 7 
1.2 ESTRUCTURA REPETITIVAS ................................................................................... 7 
Características ........................................................................................................................ 8 
1.2.1 Funcionamiento de un ciclo ................................................................................. 8 
1.2.2 Contador ............................................................................................................... 9 
1.2.3 Acumulador .......................................................................................................... 9 
CAPITULO II ......................................................................................................................... 12 
LENGUAJES DE PROGRAMACIÓN ................................................................................... 12 
2.1.1. Lenguaje ................................................................................................................. 12 
2.1.2. Lenguaje de Programación .................................................................................... 12 
2.1.3. Ejemplos de lenguajes de programación ............................................................... 12 
2.1.4. Componentes.......................................................................................................... 13 
2.2. LENGUAJE C ............................................................................................................ 13 
2.3. LENGUAJE JAVA ...................................................................................................... 13 
CAPITULO III ........................................................................................................................ 15 
CICLO WHILE (mientras) ..................................................................................................... 15 
3.1. DEFINICIÓN .............................................................................................................. 15 
3.2. SINTAXIS .................................................................................................................. 15 
3.3. REPRESENTACIÓN CICLO WHILE EN DIAGRAMA DE FLUJO ........................... 16 
EJEMPLO 01 ................................................................................................................. 17 
EJEMPLO 02 ................................................................................................................. 18 
EJEMPLO 03 ................................................................................................................. 20 
EJEMPLO 04 ................................................................................................................. 22 
EJEMPLO 05 ................................................................................................................. 24 
EJEMPLO 06 ................................................................................................................. 26 
EJEMPLO 07 ................................................................................................................. 28 
EJEMPLO 08 ................................................................................................................. 31 
EJEMPLO 09 ................................................................................................................. 34 
EJEMPLO 10 ................................................................................................................. 37 
EJEMPLO 11 ................................................................................................................. 39 
EJEMPLO 12 ................................................................................................................. 40 
6
 
EJEMPLO 13 ................................................................................................................. 43 
EJEMPLO 14 ................................................................................................................. 46 
8. SALIDA EN JAVA: ................................................................................................. 48 
EJEMPLO 15 ................................................................................................................. 48 
EJEMPLO 16 ................................................................................................................. 51 
CICLO DO-WHILE (hacer - mientras) .................................................................................. 56 
4.1. DEFINICIÓN .............................................................................................................. 56 
4.2. SINTAXIS .................................................................................................................. 56 
4.3. REPRESENTACIÓN CICLO DO-WHILE EN DIAGRAMA DE FLUJO .................... 57 
EJEMPLO 17 ................................................................................................................. 59 
EJEMPLO 18 ................................................................................................................. 60 
EJEMPLO 19 ................................................................................................................. 64 
EJEMPLO 20 ................................................................................................................. 67 
CAPITULO V ........................................................................................................................70 
CICLO FOR (para) ............................................................................................................... 70 
5.1. DEFINICIÓN .............................................................................................................. 70 
5.2. SINTAXIS .................................................................................................................. 70 
5.3. REPRESENTACIÓN CICLO FOR EN DIAGRAMA DE FLUJO ............................... 71 
EJEMPLO 21 .................................................................................................................... 72 
EJEMPLO 22 ................................................................................................................. 73 
EJEMPLO 23 ................................................................................................................. 75 
EJEMPLO 24 ................................................................................................................. 77 
EJEMPLO 25 ................................................................................................................. 78 
EJEMPLO 26 ................................................................................................................. 80 
EJEMPLO 27 ................................................................................................................. 82 
EJEMPLO 28 ................................................................................................................. 83 
EJEMPLO 29 ................................................................................................................. 85 
EJEMPLO 30 ................................................................................................................. 87 
EJEMPLO 31 ................................................................................................................. 88 
EJEMPLO 32 ................................................................................................................. 90 
EJEMPLO 33 ................................................................................................................. 93 
EJEMPLO 34 ................................................................................................................. 95 
EJEMPLO 35 ................................................................................................................. 97 
EJEMPLO 36 ............................................................................................................... 101 
 
EJEMPLO 13 ................................................................................................................. 43 
EJEMPLO 14 ................................................................................................................. 46 
8. SALIDA EN JAVA: ................................................................................................. 48 
EJEMPLO 15 ................................................................................................................. 48 
EJEMPLO 16 ................................................................................................................. 51 
CICLO DO-WHILE (hacer - mientras) .................................................................................. 56 
4.1. DEFINICIÓN .............................................................................................................. 56 
4.2. SINTAXIS .................................................................................................................. 56 
4.3. REPRESENTACIÓN CICLO DO-WHILE EN DIAGRAMA DE FLUJO .................... 57 
EJEMPLO 17 ................................................................................................................. 59 
EJEMPLO 18 ................................................................................................................. 60 
EJEMPLO 19 ................................................................................................................. 64 
EJEMPLO 20 ................................................................................................................. 67 
CAPITULO V ........................................................................................................................ 70 
CICLO FOR (para) ............................................................................................................... 70 
5.1. DEFINICIÓN .............................................................................................................. 70 
5.2. SINTAXIS .................................................................................................................. 70 
5.3. REPRESENTACIÓN CICLO FOR EN DIAGRAMA DE FLUJO ............................... 71 
EJEMPLO 21 .................................................................................................................... 72 
EJEMPLO 22 ................................................................................................................. 73 
EJEMPLO 23 ................................................................................................................. 75 
EJEMPLO 24 ................................................................................................................. 77 
EJEMPLO 25 ................................................................................................................. 78 
EJEMPLO 26 ................................................................................................................. 80 
EJEMPLO 27 ................................................................................................................. 82 
EJEMPLO 28 ................................................................................................................. 83 
EJEMPLO 29 ................................................................................................................. 85 
EJEMPLO 30 ................................................................................................................. 87 
EJEMPLO 31 ................................................................................................................. 88 
EJEMPLO 32 ................................................................................................................. 90 
EJEMPLO 33 ................................................................................................................. 93 
EJEMPLO 34 ................................................................................................................. 95 
EJEMPLO 35 ................................................................................................................. 97 
EJEMPLO 36 ............................................................................................................... 101 
 
EJEMPLO 38 ............................................................................................................... 103 
EJEMPLO 39 ............................................................................................................... 107 
EJEMPLO 40 ............................................................................................................... 109 
EJEMPLO 41 ............................................................................................................... 110 
EJEMPLO 42 ............................................................................................................... 112 
EJEMPLO 43 ............................................................................................................... 114 
EJEMPLO 44 ............................................................................................................... 116 
EJEMPLO 45 ............................................................................................................... 117 
EJEMPLO 46 ...............................................................................................................119 
EJEMPLO 47 ............................................................................................................... 121 
EJEMPLO 48 ............................................................................................................... 123 
EJEMPLO 49 ............................................................................................................... 125 
EJEMPLO 50 ............................................................................................................... 127 
EJEMPLO 51 ............................................................................................................... 130 
PROBLEMAS CON SUMATORIA ..................................................................................... 134 
EJEMPLO 52 ............................................................................................................... 137 
EJEMPLO 53 ............................................................................................................... 138 
EJEMPLO 54 ............................................................................................................... 141 
EJEMPLO 55 ............................................................................................................... 143 
EJEMPLO 56 ............................................................................................................... 145 
EJEMPLO 57 ............................................................................................................... 147 
EJEMPLO 58 ............................................................................................................... 149 
EJEMPLO 59 ............................................................................................................... 152 
EJEMPLO 60 ............................................................................................................... 156 
 
 
 
 
7
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
CAPITULO I 
FUNDAMENTOS 
1.1 DEFINICIÓN 
 
La programación estructurada es un paradigma 
considerado como un estándar en la programación, 
orientado a mejorar la claridad en la resolución de 
problemas, mejorar la calidad y tiempo de desarrollo de un 
programa utilizando funciones y estructuras, la 
programación estructurada rige estructuras de control: 
secuenciales, condicionales (if, if-else, switch), 
repetitivas (while, do-while,for), el teorema propuesto por Böhm-Jacopini, 
demuestra que con estas tres instrucciones de control se pueden escribir 
programas y aplicaciones posibles. 
 
Entre ventajas de la programación estructurada puede citarse a las siguientes: 
• Los programas pueden ser leídos de forma secuencial, sin necesidad de 
rastrear saltos de línea entre bloques de código. 
• Se optimiza la fase de prueba y depuración. 
 
1.2 ESTRUCTURA REPETITIVAS 
 
En programación es común encontrar operaciones que 
deben ejecutarse una cantidad de veces, estas operaciones 
devuelven un valor distinto pero el procedimiento es la 
misma. Podríamos tomar como ejemplo un programa que 
solicite las notas de estudiantes para indicar cuantos de 
ellos están aprobados o reprobados, el procedimiento se 
repetirá n veces que el usuario lo indique. 
 
Varios de estos procedimientos pueden realizarse con líneas de códigos 
secuenciales, pero en operaciones grandes o repetitivas, es necesario utilizar una 
estructura que permita el uso de bucles o ciclos. 
En programación encontraremos los siguientes tres ciclos: 
• Ciclo While. 
• Ciclo Do-While 
• Ciclo For 
 
 
 
 
 
8
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Características 
 
 
 
 
1.2.1 Funcionamiento de un ciclo 
Un ciclo funciona de la siguiente manera: 
• Se evalúa la condición 
o Si la condición es verdadera: se realiza la 
acción o bloque de acciones. 
• Se vuelve a evaluar la condición 
• Cuando la condición es falsa, se sale del ciclo y 
continua con las demás líneas de código del 
programa. 
9
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
1.2.2 Contador 
Es una variable que debe ser declarado como tipo de dato 
entero (int) que ayudará a contabilizar el número de 
ejecuciones o repeticiones que realizará el ciclo, esta variable 
deberá tener un incremento durante al proceso de ejecución 
dentro del bucle o ciclo. 
Un contador tiene las siguientes características: 
• Valor inicial: es el valor con el cual se la declara al inicio del programa, 
generalmente se lo inicializa en 0 o 1, la asignación de estos valores puede 
realizarse de igual manera cuando se declara la variable. 
• Valor Final: una vez ejecutado el programa, el valor del contador ira 
cambiando a lo largo del programa, el valor que tendrá al finalizar el 
programa dependerá si esta tiene un incremento positivo o negativo. 
• Incremento: es el valor constante el cual la variable será incrementado ya 
sea de manera positiva o negativa: ejemplo: i=i+1 ó i++ (positivo), 
i=i-1 ó i-- (negativo). 
• Variables tipo bandera: este tipo de variables son aquellas que dan como 
resultado dos valores: verdadero – falso, true o false. 
Dentro del ciclo debe haber una instrucci´on que modifique el valor del contador, 
su forma general es la siguiente: 
contador = contador + valorIncremento 
contador = contador - valorDecremento 
El valor a incrementar o decrementar, hace referencia a cualquier cantidad de tipo 
numerico, en la cual aumenta o disminuye su valor en cada iteraci´on del ciclo. Los 
valores a incrementar o decrementar son cantidades constantes. 
 
1.2.3 Acumulador 
Son variables a las cuales se las asigna valores que se necesita acumular, por 
ejemplo, cuando se necesita sumar números dentro de un bucle, estas variables 
pueden ser de tipo de dato entero (int) o tipo de dato real(float-double), ejemplo: 
suma= suma + i. 
 
Dentro del ciclo debe haber una instruccion que modifique el valor del acumulador, 
su forma general es la siguiente: 
acumulador = acumulador + valorIncremento 
acumulador = acumulador – valorDecremento 
El valor a incrementar o valor a decrementar se refiere a cualquier cantidad de tipo 
numerico, en la cual el acumulador aumenta o disminuysu valor en cada iteracion 
del ciclo. Los valores a incrementar o decrementar son cantidades variables. 
 
 
10
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
1.3 ENTORNO DE DESARROLLO INTEGRADO (IDE) 
 
1.3.1 PSEINT 
PSeInt es principalmente un intérprete de pseudocódigo. El proyecto nació como 
trabajo final para la cátedra de Programación I de la carrera Ingeniería en 
Informática de la Universidad nacional del Litoral, razón por la cual el tipo de 
pseudocódigo que interpreta está basado en el pseudocódigo presentado en la 
cátedra de Fundamentos de Programación de dicha carrera. Actualmente incluye 
otras funcionalidades como editor y ayuda integrada, 
generación de diagramas de flujo o exportación a código C++ 
(en etapa experimental). El proyecto se distribuye como 
software libre bajo licencia GPL. 
Para descargarlo o conseguir actualizaciones visite: 
http://pseint.sourceforge.net 
 
1.3.2 DEV C++ 
Dev-C++ es un entorno de desarrollo integrado (IDE) con todas las funciones para 
C/C++ lenguaje de programación. Como IDE similares, ofrece al programador una 
herramienta simple y unificada para editar, compilar, vincular y depurar programas. 
También proporciona apoyo para la gestión de los archivos de un programa en 
"proyectos" que contienen todos los elementos necesarios para producir un 
programa ejecutable. 
 
Dev-C++ usa el puerto Mingw de GCC (GNU Compiler Collection) 
como compilador. Puede crear nativo Ejecutables Win32, ya sea 
consola o GUI, así como DLL y bibliotecas estáticas. 
Dev-C++ es un Software Libre distribuido bajo los términos de la 
Licencia Pública General GNU (GPL). El IDEse puede descargar 
aquí: 
https://sourceforge.net/projects/orwelldevcpp/files/latest/download 
 
1.3.3. NETBEANS 
NetBeans es un IDE muy completo para programar en varios lenguajes, aunque 
se especializa principalmente en Java. se puede usar también en C++, PHP, 
HTML y una larga lista de etcétera. Maneja una estructura para trabajar con los 
programas de java que te permitirán organizar tu trabajo. NetBeans IDE es 
GRATUITO, de código abierto, y tiene una comunidad mundial de usuarios y 
desarrolladores. 
 
Instalacion de Netbeans IDE 10. Ir al sitio de 
descarga de Netbeans disponible en: 
11
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
Aclaración: 
Se debe tener especial cuidado en la inicialización del 
acumulador cuando se trabaje con multiplicaciones, su 
valor inicial no puede ser 0, debido a que todas las 
operaciones realizadas con ´el darían como resultado 0. 
De igual manera si se trabaja con divisiones, la variable 
valorDecremento por ningún motivo podría tomar el valor 
de 0, la división entre 0 no está definida. 
 
https://netbeans.apache.org/download 
Instalación de Java Development Kit (JDK) 1. Ir al sitio de descarga del JDK 
disponible en: https://www.oracle.com/java/technologies/downloads/ 
 
1.3.4. PROGRAMA EN LÍNEA 
Replit (rep-lit) anteriormente repl.it es un IDE online (Entorno de desarrollo 
integrado) Su nombre proviene del acrónimo REPL, que significa "bucle de lectura-
evaluación-impresión". Amjad Masad, Faris Masad y Haya Odeh cofundaron la 
empresa en 2016. 
Características, Replit permite a los usuarios escribir 
código y crear aplicaciones y sitios web mediante un 
navegador. El sitio también tiene varias funciones de 
colaboración, incluida la capacidad de edición 
multiusuario en tiempo real con una fuente de chat en 
vivo. Admite lenguajes de programación y marcado 
como Java , Python y HTML , lo que permite a los 
usuarios crear aplicaciones y sitios web, pero puede 
ejecutar cualquier lenguaje existente usando Nix . El 
sitio está integrado con GitHub , una plataforma de alojamiento de código, que 
proporciona una forma de importar y ejecutar proyectos desde GitHub. Los 
usuarios también pueden importar proyectos desde Glitch, que brinda un servicio 
similar a Replit. Disponible en: https://replit.com/languages/c 
 
 
13
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
CAPITULO II 
LENGUAJES DE PROGRAMACIÓN 
2.1. DEFINICIÓN 
 
2.1.1. Lenguaje 
El lenguaje es el principal medio de comunicación que los 
seres humanos poseemos, es la que nos permite interactuar 
con otros humanos mediante diferentes elementos como: 
palabras, señas o sonidos, que por sí misma no tendrían 
significado, pero existen normativas que regular la manera en 
que las mismas pueden utilizarse para que estas puedan ser 
entendibles en un idioma propio. 
 
2.1.2. Lenguaje de Programación 
Es la forma de comunicación entre el usuario y la 
computadora o algún dispositivo digital, al igual que el 
lenguaje de comunicación entre los seres humanos, los 
lenguajes de programación tienen reglas semánticas como 
sintácticas que los programadores utilizan para codificar 
instrucciones de un programa o algoritmo. 
Existen una variedad de lenguajes de programación y cada una tiene un propósito 
en específico, se utilizan para crear programas, aplicaciones, sistemas operativos, 
interpretar datos y resolver problemas. Cada lenguaje de programación tiene su 
propia semántica y sintaxis. 
 
2.1.3. Ejemplos de lenguajes de programación 
A continuación, nombramos algunos de lenguajes de programación más 
conocidos: 
• Basic: es una familia de lenguajes de 
alto nivel, su versión más actual es 
Visual Basic. NET. 
• Lenguaje C: Fue creado como 
evolución al lenguaje B, es uno de los 
lenguajes más populares para crear 
softwares de sistemas operativos y 
aplicaciones. 
• Lenguaje C++: es un lenguaje 
estructurado estándar que permite un 
trabajo más cercado al hardware, C++ 
14
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
es una extensión de C, está orientada a Objetos y recurre a librerías. 
• Lenguaje C#: Es la evolución del Lenguaje C++, la misma fue creada como 
competencia al lenguaje más popular en su momento como java, el 
lenguaje C# está orientada al uso de framerk.NET. 
• JAVA: Es un lenguaje de programación orientado a objetos derivado de los 
lenguajes C y C++. 
2.1.4. Componentes 
La composición general de un programa es: 
• Directivas de Procesamiento. 
• Función Principal Main 
• Declaración de Variables. 
• Funciones definidas por el usuario. 
• Comentarios para entender el funcionamiento del programa. 
 
2.2. LENGUAJE C 
 
Es un lenguaje de programación considerado como uno de los 
más importantes, con el cual es posible es desarrollo de 
aplicaciones y sistemas operativos, el aprendizaje de este 
lenguaje es base para otros lenguajes como Java, C++ o C#. 
Las características del lenguaje C son las siguientes: 
• Es un lenguaje estructurado. 
• Es considerado como un lenguaje de programación de nivel medio lo cual 
significa que tiene ventajas de la programación de alto y bajo nivel. 
• Es uno de los lenguajes más utilizados, gracias a ello se lo considera como 
un lenguaje flexible. 
• No depende del hardware por lo cual puede migrarse a otros sistemas. 
Otra de las características importantes es el uso de librerías que facilitan el uso de 
diversas funciones ya definidas que facilitan al desarrollo de la programación. 
 
2.3. LENGUAJE JAVA 
 
Es un lenguaje que se diseño para ser parecido a C++, pero 
reduciendo las características menos usadas y añadiendo 
características más útiles. 
Las características del lenguaje JAVA son las siguientes: 
 
• Es un lenguaje simple, ofrece la funcionalidad del lenguaje C y C++. 
• Orientado a objetos, incorpora la resolución dinámica de métodos y trabaja 
con librerías dinámicas DLLs. 
15
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
• Distribuido, ofrece la capacidad de acceder a librerías para interactuar con 
protocolos TCP/IP, lo cual permite acceder a la información en red. 
• Robusto, porque realiza verificaciones en busca de problemas tanto en la 
compilación como en la ejecución del programa, esto ayuda a detectar 
errores durante el desarrollo de programas. 
 
La programación en lenguaje Java tiene objetivos principales: 
• Esta enfocado en el desarrollo orientado a objetos. 
• Los programas desarrollados en este lenguaje deben permitir su ejecución 
en diversos sistemas operativos. 
• Las aplicaciones desarrolladas en Java deben tener soporte de red 
integrado. 
• Debe configurarse para ejecutar el código en fuentes de forma segura. 
• Las aplicaciones desarrolladas en este lenguaje deben ser de fácil uso para 
el usuario. 
Una vez terminado el programa en Java, estas se convierten en ByteCode de 
Java, el cual es leído por la maquina virtual de java el que se encarga de traducir 
el código en lenguaje máquina, lo cual esto significa que los dispositivos que 
quieran ejecutar el programa necesitan de una máquina virtual de Java para que 
pueda ejecutarse, con lo cual esto indica que un código de java puede ser 
ejecutando en distintos dispositivos y ser traducidos para su ejecución. 
 
17
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
CAPITULO III 
CICLO WHILE (mientras) 
 
3.1. DEFINICIÓN 
 
El ciclo while es una estructura que permite ejecutar operaciones 
de manera repetitiva sin la necesidad de tener un valor inicial, una 
característica del ciclo while es que su condicional no dependen de 
un valor entero sin de una variable bandera o booleana, es decir 
que el ciclo se ejecutará mientras la condición sea verdadera. 
 
3.2. SINTAXIS 
 
La sintaxis del ciclo while es 
simple y legible, ya que solo 
debe declararse una condición 
el cual controle el ciclo para su 
ejecución.A continuación, vemos la 
sintaxis del ciclo while: 
 
Línea 1: en esta línea vemos la declaración del ciclo while en letras azules en la cual 
sigue entre paréntesis la condición para finalizar el ciclo, mientras la condición sea 
verdadera, ingresara al bucle para ejecutar las operaciones o el proceso indicado. 
Línea 2: en la línea 2 se observa una llave de apertura “{“, lo cual indica que allí es el 
inicio de las instrucciones del ciclo que será ejecutado mientras la condicional será 
verdadera. 
Línea 3-7: estas líneas representan el proceso que se ejecutaran mientras la condicional 
sea verdadera. 
Línea 8: esta última línea se observa una llave cerrada "}", el cual indica que allí termina 
el proceso del ciclo while. Una vez que la condición será falsa el bucle termina en esa 
línea de código y continua con la ejecución del resto del programa. 
EJEMPLO: 
PSEUDOCODIGO DIGRAMA DE FLUJO LENGUAJE C LENGUAJE JAVA 
 
 
Mientras n > c Hacer 
 Leer num 
 m <- m * num 
 c <- c + 1 
Fin Mientras 
 
 while (n>c) 
{ 
 printf("Ingrese un numero 
= "); 
 scanf("%d", & num); 
 m=m*num; 
 c=c+1; 
} 
 
while(n > c) 
{ 
 System.out.println("Ingrese 
un numero = "); 
num = dato.nextByte(); 
m = m*num; 
c++; 
} 
18
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
Aclaración: 
Del anterior análisis se puede establecer que, de acuerdo a 
la inicialización de la variable que controlará la ejecución 
del ciclo, se debe prestar especial cuidado en elegir 
correctamente el operador relacional que hará parte de la 
condición del Mientras. En los segmentos de algoritmos 
analizados se pudo observar lo siguiente: 
numero = 0 se utiliza el operador < 
numero = 1 se utiliza el operador <= 
 
3.3. REPRESENTACIÓN CICLO WHILE EN DIAGRAMA DE FLUJO 
La instrucción Mientras ejecuta una secuencia de 
instrucciones mientras una condición sea verdadera. 
 Mientras <condición> Hacer 
<instrucciones> 
FinMientras 
En el diagrama se puede observar la manera en que es 
representado el ciclo while en un diagrama de flujo. 
EL funcionamiento del ciclo while, mientras la condición 
sea verdadera, ingresa al ciclo y se ejecutan los 
procesos, el ciclo termina cuando la condiciona sea 
falso. Em este ciclo, puede darse el caso de que no 
ingrese al proceso ni una sola vez si la condición es 
falsa. 
 
 
 
 
 
 
 
 
19
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
 EJEMPLO 01 
1. REALIZAR UN DIAGRAMA DE FLUJO QUE MUESTRE N VECES LA PALABRA 
“SISTEMAS” 
2. ANÁLISIS: Para el problema se necesita un dato de entrada N para mostrar por pantalla la cantidad de N 
veces la palabra “SISTEMAS” 
Algoritmo ejercicio1 
 Leer n 
 c <-1 
 Mientras c <= n Hacer 
 Escribir "SISTEMAS LA MEJOR" 
 c <- c + 1 
 Fin Mientras 
FinAlgoritmo 
3. DIAGRAMA DE FLUJO 
 
4. PRUEBA DE ESCRITORIO 
VARIABLES 
MOSTRAR N C 
5 1 SISTEMAS 
 2 SISTEMAS 
 3 SISTEMAS 
 4 SISTEMAS 
 5 SISTEMAS 
 6 
4. CODIFICACIÓN DEV-C++ 5.2.0.1 
/* 1. REALIZAR UN DIAGRAMA DE FLUJO QUE MUESTRE N VECES LA 
PALABRA "SISTEMAS LA MEJOR" */ 
#include <cstdio> 
int main(){ 
 int n, c; 
 c=1; 
 printf("Introduzca en valor para n: 
"); 
 scanf("%d", & n); 
 while (c <= n) 
 { printf("\n SISTEMAS LA 
MEJOR\n"); 
 c=c+1; 
 } 
 return 0; 
} 
5. SALIDA EN C: 
 
 
 
 
 
20
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
6. CODIFICACIÓN JAVA 
 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 int n; 
 Scanner dato = new Scanner(System.in); 
 System.out.print("Ingresa un numero para n = "); 
 n = dato.nextInt(); 
 int c = 1; 
 while(c <= n){ 
 System.out.print("SISTEMAS\n"); 
 c++; 
 } 
 } 
} 
 
7. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
 
 
 
 
EJEMPLO 02 
1. DADO UN NÚMERO ENTERO Y POSITIVO IMPRIMIR LOS PRIMEROS N NÚMEROS 
IMPARES. 
2. ANÁLISIS 
•• Para el problema se necesita un dato de entrada N entero (int) y positivo. 
•• Ingresado el numero N, procedemos a mostrar por pantalla los números impares,1,3,5,.., 
para ello, utilizaremos un contador c=1 y procedemos a sumar +2 para generar la serie de 
números impares. 
Algoritmo ejercicio2 
 Leer n 
 c <-1 
 Mientras c <= n Hacer 
 Escribir c 
 c <- c + 2 
 Fin Mientras 
FinAlgoritmo 
21
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
3. DIAGRAMA DE FLUJO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. PRUEBA DE ESCRITORIO 
VARIABLES 
MOSTRAR n c 
5 1 1 
 3 3 
 5 5 
 7 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/* 2. DADO UN NÚMERO ENTERO Y POSITIVO IMPRIMIR LOS 
PRIMEROS N NÚMEROS IMPARES */ 
#include <cstdio> 
int main(){ 
 int n, c; 
 c=1; 
 printf("Introduzca en valor para n: "); 
 scanf("%d", & n); 
 while (c <= n) 
 { 
 printf("\n %d \n", c); 
 c = c + 2 ; 
 } 
 return 0; 
} 
 6. SALIDA EN C: 
 
 
7. CODIFICACIÓN JAVA 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 int n; 
 Scanner dato = new Scanner(System.in); 
 System.out.print("Ingres un numero ="); 
 n = dato.nextInt(); 
 int c = 1; 
 System.out.print("Numeros Impares\n"); 
 while(c <= n){ 
 System.out.print(c+"\n"); 
 c+=2; 
 } 
 } 
} 
22
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
 
 
 
 
EJEMPLO 03 
1. REALIZAR UN ALGORITMO QUE PERMITA MULTIPLICAR (N) NÚMEROS 
INTRODUCIDOS POR TECLADO. 
2. ANÁLISIS: 
▪ Para el problema se necesita un dato de entrada N el cual se utilizará para solicitar datos 
por pantalla. 
▪ Se utilizará un contador C para realizar la multiplicación con los datos ingresados por 
pantalla. 
Algoritmo Ejercicio3 
 Leer n 
 c <-0 
 m <-1 
 Mientras n > c Hacer 
 Leer num 
 m <- m * num 
 c <- c + 1 
 Fin Mientras 
 Escribir m 
FinAlgoritmo 
23
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
3. DIAGRAMA DE FLUJO 4. PRUEBA DE ESCRITORIO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
VARIABLES 
MOSTRAR n c n num 
3 0 1 2 30 
 1 2 3 
 2 6 5 
 3 30 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*3. REALIZAR UN ALGORITMO QUE PERMITA MULTIPLICAR (N) 
NÚMEROS INTRODUCIDOS POR TECLADO. */ 
 
 
#include <cstdio> 
int main(){ 
 int n, c, m, num; 
 c=0; 
 m=1; 
 printf("Introduzca en valor para n: "); 
 scanf("%d", & n); 
 while (n>c) 
 { 
 printf("Introduzca en valor para 
num: "); 
 scanf("%d", & num); 
 m=m*num; 
 c=c+1; 
 } 
 printf("\n %d \n", m); 
 return 0; 
} 
6. SALIDA EN C: 
 
7. CODIFICACIÓN JAVA 
 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
24
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 public static void main(String[] args) { 
 int n,c,m,num; 
 Scanner dato = new Scanner(System.in); 
 System.out.print("Ingres un numero para n = "); 
 n = dato.nextInt(); 
 c = 0; 
 m = 1; 
 while(n > c){ 
 System.out.println("Ingrese un numero para num = "); 
 num = dato.nextInt(); 
 m = m*num; 
 c++; 
 } 
 System.out.println("Resultado" + m + "\n"); 
 } 
} 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
 
 
 
EJEMPLO 04 
1. OBTENER LA SUMA DE LOS PRIMEROS N NÚMEROS NATURALES POSITIVOS. 
2. ANÁLISIS 
• Para el problema se necesita un dato de entrada N. 
• Utilizaremos un contador C para realizar la suma de la misma mientras el contador sea 
menor o igual al dato de entrada N. 
Algoritmo Positivos 
 Leer n 
 c <-1 
 s <-0 
 Mientras c <= n Hacer 
 s <- s + c 
 c <- c + 1 
 Fin Mientras 
 Escribir s 
FinAlgoritmo 
 
 
 
 
 
 
25
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓNC / JAVA
VOLUMEN 2
 
 
3. DIAGRAMA DE FLUJO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. PRUEBA DE ESCRITORIO 
 
 
 
VARIABLES 
MOSTRAR n c s 
5 1 0 15 
 2 1 
 3 3 
 4 6 
 5 10 
 6 15 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*4. OBTENER LA SUMA DE LOS PRIMEROS N NÚMEROS NATURALES 
POSITIVOS. */ 
#include <cstdio> 
int main(){ 
 int n, c, s; 
 c=1; 
 s=0; 
 printf("Introduzca en valor para n: 
"); 
 scanf("%d", & n); 
 while (c<=n) 
 { 
 s= s+c; 
 c=c+1; 
 } 
 printf("%d", s); 
 return 0; 
} 
6. SALIDA EN C: 
 
7. CODIFICACIÓN JAVA 
 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int n,c,s; 
 System.out.print("Ingrese un numero = "); 
 n = dato.nextInt(); 
 c =1; 
 s = 0; 
 while(c <= n){ 
 s = s+c; 
26
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 c = c+1; 
 } 
 System.out.println("la suma es "+s); 
 } 
} 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
EJEMPLO 05 
1. HACER UN DIAGRAMA DE FLUJO QUE PIDA NÚMEROS AL USUARIO Y SUME 
LOS MÚLTIPLOS DE 5. EL PROGRAMA TERMINARÁ CUANDO EL USUARIO 
INTRODUZCA 0 
2. ANÁLISIS 
▪ Para el problema necesitamos ingresar valores N. 
▪ El programa finalizará una vez que el usuario ingrese 0, mientras esta condición sea cierta, 
se procederá a la operación condicional, si el valor ingresado N es múltiplo de 5, en caso 
de ser cierto, se realizara la suma de los elementos múltiplos de 5. 
Algoritmo Ejemplo5 
 n <-1 
 s <-0 
 Mientras n!= 0 Hacer 
 Leer n 
 Si n % 5==0 Entonces 
 s =s + n 
 Fin Si 
 Fin Mientras 
 Escribir "Suma = ", s 
FinAlgoritmo 
27
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
3. DIAGRAMA DE FLUJO 4. PRUEBA DE ESCRITORIO 
VARIABLES MOSTRAR 
N S 
1 0 SUMA=20 
1 5 
3 15 
5 20 
7 20 
9 
10 
5 
0 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/* 5. HACER UN DIAGRAMA DE FLUJO QUE PIDA NÚMEROS AL USUARIO 
Y SUME LOS MÚLTIPLOS DE 5. EL PROGRAMA TERMINARÁ CUANDO EL 
USUARIO INTRODUZCA 0*/ 
#include <cstdio> 
int main(){ 
int N, s; 
N=1; 
s=0; 
while (N!=0) 
 { 
 printf("Introduzca en valor para 
n:"); 
 scanf("%d", & N); 
 if(N % 5 == 0) 
 { 
 s= s+N; 
 } 
 } 
 printf("La suma es :%d", s); 
 return 0; 
} 
6. SALIDA EN C: 
 
 
7. CODIFICACIÓN JAVA 
 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 int N=1, s= 0; 
28
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 Scanner dato = new Scanner(System.in); 
 while( N!=0){ 
 System.out.print("Ingrese un valor para n = "); 
 N = dato.nextInt(); 
 if(N % 5 == 0){ 
 s = s+N; 
 } 
 } 
 System.out.println("La suma es = " + s); 
 } 
} 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
EJEMPLO 06 
1. HACER EL DIAGRAMA DE FLUJO PARA SUMAR LOS N PRIMEROS IMPARES 
QUE NO SEAN MÚLTIPLOS DE 5 
2. ANÁLISIS 
▪ Para el problema necesitamos un dato de entrada N. 
▪ Necesitamos identificar los números que no sean múltiplos de 5 para realizar la suma de 
los elementos. 
 Algoritmo Ejemplo6 
 Leer n 
 cont <-0 
 s <-0 
 i <- 1 
 Mientras cont < n Hacer 
 
 Si (i % 2 <>0 && i%5 <> 0) Entonces 
 s =s + i 
 cont = cont +1 
 Fin Si 
 i<- i+1 
 Fin Mientras 
 Escribir "Suma = ", s 
 FinAlgoritmo 
 
 
 
29
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
3. DIAGRAMA DE FLUJO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. PRUEBA DE ESCRITORIO 
 
 
 
VARIABLES MOSTRAR 
N i Cont S 
7 1 0 0 SUMA=61 
 2 1 1 
 3 2 4 
 4 3 11 
 5 4 20 
 6 5 31 
 7 6 44 
 8 7 61 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*6. HACER EL DIAGRAMA DE FLUJO PARA SUMAR LOS 
N PRIMEROS IMPARES QUE NO SEAN MÚLTIPLOS DE 
5*/ 
#include <stdio.h> 
#include <conio.h> 
int main(){ 
 int N, s, cont, i; 
 i=1; 
 cont=0; 
 s=0; 
 printf("Introduzca en valor para n: "); 
 scanf("%d", & N); 
while (cont < N) 
 { 
 if(i%2 != 0 && i % 5 !=0) 
 { 
 s= s+i; 
 cont = cont +1; 
 } 
 i=i+1; 
 } 
 printf("La suma es :%d", s); 
 return 0; 
} 
6. SALIDA EN C: 
 
 
 
30
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2 
 
 
7. CODIFICACIÓN JAVA 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int N; 
 int s=0, cont = 0, i=1; 
 System.out.print("Ingrese un valor para n = "); 
 N = dato.nextInt(); 
 while(cont < N){ 
 if(i % 2 != 0 && i % 5 != 0){ 
 s = s+i; 
 cont=cont+1; 
 } 
 i++; 
 } 
 System.out.println("La suma es =" + s); 
 } 
} 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
EJEMPLO 07 
1. DADO UN NÚMERO, DETERMINAR CUÁNTOS DÍGITOS PARES, DÍGITOS 
IMPARES Y DÍGITOS CEROS TIENE. 
2. ANÁLISIS 
N =120345 ⇒ 2 dígitos pares, 3 dígitos impares, 1 digito cero 
Algoritmo ejercicio7 
 Definir n, dig, conPar, conImpar, conCero Como Entero 
 Leer n 
 conPar <- 0 
 conImpar <-0 
 conCero <- 0 
 dig<-0 
 Mientras n > 0 Hacer 
 dig <- n % 10 
 Si (dig % 2 = 0) Entonces 
 Si dig <> 0 Entonces 
 conPar<-conPar +1 
 SiNo 
 conCero <-conCero + 1 
 Fin Si 
 SiNo 
31
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
 conImpar<- conImpar + 1 
 Fin Si 
 n <- n / 10 
 Fin Mientras 
 Escribir conCero 
 Escribir conImpar 
 Escribir conPar 
FinAlgoritmo 
3. DIAGRAMA DE FLUJO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. PRUEBA DE ESCRITORIO 
VARIABLES MOSTRAR 
n conPar conImpar connCero 
120345 0 0 0 2, 3, 1 
12034 1 1 1 
1203 2 2 
120 3 
12 
 
1 
0 
32
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2 
 
 
 
 
 
 
 
 
 
 
 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*7. DADO UN NÚMERO, DETERMINAR CUÁNTOS DÍGITOS PARES, DÍGITOS IMPARES Y DÍGITOS CEROS TIENE*/ 
#include <stdio.h> 
#include <conio.h> 
int main(){ 
 int N, conPar,conImpar,conCero,dig; 
 conPar=0; 
 conImpar=0; 
 conCero=0; 
 
 printf("Introduzca en valor para N: "); 
 scanf("%d", & N); 
 while (N > 0) 
 { 
 dig= N % 10; 
 if(dig % 2==0) 
 { 
 if(dig != 0) 
 { 
 conPar=conPar + 1; 
 } 
 else 
 { 
 conCero=conCero + 1; 
 } 
 } 
 else 
 { 
 conImpar=conImpar +1; 
 } 
 N=N/10; 
 } 
 printf("\n Digitos Pares :%d \n", conPar); 
 printf("\n Digitos Impares :%d \n", conImpar); 
 printf("\n Digitos Cero :%d \n", conCero); 
 return 0; 
} 
6. SALIDA EN C: 
 
 
7. CODIFICACIÓN JAVA 
package pkgwhile; 
import java.util.Scanner; 
33
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int n; 
 System.out.print("Ingrese un numero para N= "); 
 n = dato.nextInt(); 
 int conPar =0, conImpar=0,conCero=0; 
 int dig=0; 
 while(n > 0){ 
 dig = n % 10; 
 if(dig % 2 == 0){ 
 if(dig != 0){ 
 conPar++; 
 }else{ 
 conCero++; 
 } 
 }else{ 
 conImpar++; 
 } 
 n = n/10; 
 } 
 System.out.println("DígitosPares: " + conPar 
 +" \nDígitos Impares: "+conImpar 
 +" \nDígitos cero: "+conCero); 
} 
8. SALIDA EN JAVA: 
 
 
 
EJEMPLO 08 
1. LA EMPRESA DE EMAPA TIENE CONTRATADOS A N VENDEDORES. CADA UNO 
HACE TRES VENTAS A LA SEMANA. SU POLÍTICA DE DE PAGOS ES QUE UN 
VENDEDOR RECIBE UN SUELDO BASE, Y UN 10% EXTRA POR COMISIONES DE 
SUS VENTAS. EL GERENTE DE SU EMPRESA DESEA SABER CUÁNTO DINERO 
OBTENDRÁ EN LA SEMANA CADA VENDEDOR POR CONCEPTO DE 
COMISIONES POR LAS TRES VENTAS REALIZADAS, Y CUANTO TOMANDO EN 
CUENTA SU SUELDO BASE Y SUS COMISIONES. 
2. ANÁLISIS 
Algoritmo ejercicio8 
 Escribir "Introduzca el valor para N" 
 Leer n 
 c <- 1 
 Mientras c <= n Hacer 
 Leer sb, v1, v2, v3 
 tventa <- v1+ v2+ v3 
34
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 com <- tventa * 0.10 
 tpag<-sb + com 
 Escribir tpag 
 Escribir com 
 Fin Mientras 
FinAlgoritmo 
3. DIAGRAMA DE FLUJO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. PRUEBA DE ESCRITORIO 
 
VARIABLES MOSTRAR 
n c SB V1 V2 V3 TVENTA COM TPAG 
4 1 1000 20 30 40 90 9.0 1009.0 9, 109 
 2 1200 10 15 25 50 5.0 1205.0 5,125 
 3 800 20 25 30 75 7.5 807.5 8,88 
 4 1300 50 80 90 220 22.0 1322.0 22,152 
 5 
 
 
 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*8. LA EMPRESA DE EMAPA TIENE CONTRATADOS A N VENDEDORES. CADA UNO HACE TRES VENTAS A LA SEMANA. SU 
POLÍTICA DE DE PAGOS ES QUE UN VENDEDOR RECIBE UN SUELDO BASE, Y UN 10% EXTRA POR COMISIONES DE SUS 
VENTAS. EL GERENTE DE SU EMPRESA DESEA SABER CUÁNTO DINERO OBTENDRÁ EN LA SEMANA CADA VENDEDOR POR 
CONCEPTO DE COMISIONES POR LAS TRES VENTAS REALIZADAS, Y CUANTO TOMANDO EN CUENTA SU SUELDO BASE Y 
SUS COMISIONES*/ 
#include <stdio.h> 
#include <conio.h> 
int main(){ 
 int N, c, SB, V1,V2,V3,COM, TVENTA, TPAG; 
 c=1; 
 printf("Introduzca en valor para N: "); 
 scanf("%d", & N); 
 while (c<=N) 
 { 
 printf("Introduzca en valor para Sueldo Base: "); 
35
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
 scanf("%d", & SB); 
 printf("Introduzca en valor de la Venta 1: "); 
 scanf("%d", & V1); 
 printf("Introduzca en valor de la Venta 2: "); 
 scanf("%d", & V2); 
 printf("Introduzca en valor de la Venta 3: "); 
 scanf("%d", & V3); 
 
 TVENTA = V1 + V2 + V3; 
 COM = TVENTA * 0.10; 
 TPAG=SB + COM; 
 c= c+1; 
 
 printf("\n Total Pagado :%d \n", TPAG); 
 printf("\n Comision :%d \n", COM); 
 } 
 return 0; 
} 
6. SALIDA EN C: 
 
 
 
 
 
 
 
 
 
 
7. CODIFICACIÓN JAVA 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int n, c = 1 ; 
 int sb, v1,v2,v3; 
 double Tventa,com,Tpag; 
 System.out.print("Ingrese un numero para N = "); 
 n = dato.nextInt(); 
 while(c<=n){ 
 System.out.print("Ingrese valor suelo base="); 
 sb = dato.nextInt(); 
 System.out.print("Ingrese valor venta 1="); 
 v1 = dato.nextInt(); 
 System.out.print("Ingrese valor venta 2 = "); 
 v2 = dato.nextInt(); 
 System.out.print("Ingrese valor venta 3 = "); 
 v3 = dato.nextInt(); 
 Tventa = v1 + v2 + v3; 
 com = Tventa * 0.10; 
 Tpag = sb + com; 
36
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 c++; 
 System.out.println("Total Pagado: " + Tpag); 
 System.out.println("Comisión:" + com); 
 } 
 } 
} 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
EJEMPLO 09 
1. LEER UN NÚMERO MAYOR A 100 E INDICAR CUANTOS NÚMEROS PARES, 
IMPARES E IGUALES A CERO TIENE. 
2. ANÁLISIS 
Algoritmo ejercicio9 
 Escribir "Introduzca el valor para N" 
 Leer n 
 nn <- n, ceros <- 0, par <- 0, impar <- 0 
 Mientras nn > 0 Hacer 
 d<-nn%10 
 nn<-nn/10 
 Si d==0 Entonces 
 ceros<-ceros + 1 
 SiNo 
 Si d % 2== 0 Entonces 
 par<-par + 1 
 SiNo 
 impar<-impar +1 
 Fin Si 
 Fin Si 
 Escribir ceros 
 Escribir par 
 Escribir impar 
 Fin Mientras 
FinAlgoritmo 
37
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
3. DIAGRAMA DE F 4. PRUEBA DE ESCRITORIO 
 
 
 
 
 
 
VARIABLES MOSTRAR 
n nn ceros p
a
r 
impar d 
4507 4507 0 0 0 7 1 
450 1 1 1 0 1 
45 
 
2 5 2 
4 
 
4 
0 
 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*9. LEER UN NÚMERO MAYOR A 100 E INDICAR CUANTOS NÚMEROS 
PARES, IMPARES E IGUALES A CERO TIENE*/ 
 
#include <stdio.h> 
#include <conio.h> 
int main(){ 
 int n, nn, ceros, par, impar,d; 
 nn=n; 
 ceros=0; 
 par=0; 
 impar=0; 
 printf("Introduzca en valor para N: "); 
 scanf("%d", & n); 
 while (nn > 0) 
 { 
 d= nn % 10; 
 nn=nn / 10; 
 if(d == 0) 
 { 
 ceros = ceros +1; 
 } 
 else 
 { 
 if(d % 2 == 0) 
 { 
 par = par +1; 
 } 
 else 
 { 
6. SALIDA EN C: 
 
38
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 impar= impar +1; 
 } 
 } 
 } 
 printf("\n Total ceros :%d \n", ceros); 
 printf("\n Total par :%d \n", par); 
 printf("\n Total impar :%d \n", impar); 
 return 0; 
} 
7. CODIFICACIÓN JAVA 
 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int n; 
 System.out.print("Ingrese un número mayor a 100 = "); 
 n = dato.nextInt(); 
 int nn=n, ceros = 0, par = 0, impar=0,d=0; 
 while(nn > 0){ 
 d = nn % 10; 
 nn = nn/10; 
 if(d == 0){ 
 ceros++; 
 }else{ 
 if(d % 2 == 0){ 
 par++; 
 }else{ 
 impar++; 
 } 
 } 
 } 
 System.out.println("Total pares = "+par 
 +"\nTotal impares = "+impar 
 +"\nTotal ceros = "+ceros); 
 } 
} 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
 
 
 
 
39
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
EJEMPLO 10 
1. LEER UN NÚMERO MAYOR A 100 E INDICAR SI ES CAPICÚA O NO. 
2. ANÁLISIS 
Algoritmo ejercicio9 
 Definir n, nn, ndig Como entero 
 Escribir "Introduzca el valor para N" 
 Leer n 
 nn <- n, dig <- 0 
 Mientras nn > 0 Hacer 
 dig<-nn mod 10 
 nn<- trunc (nn/10) 
 ndig<-ndig * 10 + dig 
 Fin Mientras 
 Si ndig == n Entonces 
 Escribir "ES CAPICUA" 
 SiNo 
 Escribir "NO ES CAPICUA" 
 Fin Si 
FinAlgoritmo 
3. DIAGRAMA DE FLUJO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. PRUEBA DE ESCRITORIO 
 
 
 
 
 
 
VARIABLES MOSTRAR 
n nn ndig dig 
676 676 0 6 ES 
CAPICUA 
67 6 7 
6 67 6 
0 676 
 
 
506 506 0 6 NO ES 
CAPICUA 
50 6 0 
5 60 5 
0 605 
 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*10. LEER UN NÚMERO MAYOR A 100 E INDICAR SI ES CAPICÚA O 
NO.*/ 
#include <stdio.h> 
#include <conio.h> 
int main(){ 
 int n, nn, ndig, dig; 
 ndig=0; 
 printf("Introduzca en valor para 
N:"); 
6. SALIDA EN C: 
 
 
40
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 scanf("%d", & n); 
 nn=n; 
 while (nn > 0) 
 { 
 dig= nn % 10; 
 nn= nn / 10; 
 ndig= ndig*10+dig; 
 } 
 if(ndig == n) 
 { 
 printf("ES CAPICUA"); 
 } 
 else 
 { 
 printf("NO ES CAPICUA"); 
 } 
 return 0; 
} 
 
7. CODIFICACIÓN JAVA 
 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int n ; 
 System.out.print("Ingreseun numero para N = "); 
 n = dato.nextInt(); 
 int dig=0,nn = n, ndig=0; 
 while(nn > 0){ 
 dig = nn%10; 
 nn = nn/10; 
 ndig=ndig*10+dig; 
 } 
 if(ndig == n){ 
 System.out.println("ES CAPICÚA\n"); 
 }else{ 
 System.out.println("NO ES CAPICÚA\n"); 
 } 
 } 
} 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
 
41
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
EJEMPLO 11 
1. LEER UN NÚMERO MAYOR A 100, CALCULARA LA SUMATORIA DE SUS 
DÍGITOS. 
2. ANÁLISIS 
Algoritmo ejercicio9 
 Definir n, nn, s Como entero 
 Escribir "Introduzca el valor para N" 
 Leer n 
 nn <- n 
 s <- 0 
 Mientras nn > 0 Hacer 
 dig<-nn mod 10 
 nn<- trunc (nn/10) 
 s<-s + dig 
 Fin Mientras 
 Escribir s 
FinAlgoritmo 
 
3. DIAGRAMA DE FLUJO 
 
 
 
4. PRUEBA DE ESCRITORIO 
 
 
VARIABLES MOSTRAR 
n nn s dig 
87094 87094 0 4 28 
8709 4 9 
870 13 0 
87 13 7 
8 20 8 
0 28 
 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*11. LEER UN NÚMERO MAYOR A 100, CALCULARA LA SUMATORIA DE 
SUS DÍGITOS..*/ 
#include <cstdio> 
int main(){ 
int n, nn, s, dig; 
s=0; 
printf(“Introduzca en valor para N: “); 
scanf(“%d”, & n); 
nn=n; 
6. SALIDA EN C: 
 
 
42
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
while (nn > 0) 
 { 
 dig= nn % 10; 
 nn= nn / 10; 
 s= s + dig; 
 } 
printf(“La suma de los dígitos es:%d”, 
s); 
return 0; 
} 
 
7. CODIFICACIÓN JAVA 
package pkgwhile; 
import java.util.Scanner; 
import javax.swing.JoptionPane; 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int n ; 
 System.out.print(“Ingrese un numero mayor a 100 = “); 
 n = dato.nextInt(); 
 int nn = n, s=0, dig; 
 while(nn > 0){ 
 dig = nn % 10; 
 nn = nn/10; 
 s = s+dig; 
 } 
 System.out.println(“La suma de los dígitos es = “+s); 
 } 
} 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
 
EJEMPLO 12 
1. DADO UN NÚMERO N ENTERO POSITIVO MAYOR O IGUAL A 10, CONTAR LOS 
DÍGITOS NULOS, CONTAR LOS DÍGITOS IMPARES DEL NÚMERO Y 
DESPLEGAR LOS RESULTADOS. 
2. ANÁLISIS 
Entradas: n =405037 
Salidas: cantNul es 2 y cantImp es 3 
Algoritmo ejercicio12 
 Definir n, cantNul, cantImp Como entero 
 cantNul<- 0 
 cantImp <- 0 
 Repetir 
43
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
 Escribir "Introduzca el valor para N" 
 Leer n 
 Hasta Que n < 10 
 Mientras n <> 0 Hacer 
 dig<-n mod 10 
 Si dig == 0 Entonces 
 cantNul<-cantNul + 1 
 Fin Si 
 Si dig % 2 <> 0 Entonces 
 cantImp<-cantImp + 1 
 Fin Si 
 n<- trunc (n/10) 
 Fin Mientras 
 Escribir "Cantidad Impares", cantImp 
 Escribir "Cantidad Nulos", cantNul 
FinAlgoritmo 
3. DIAGRAMA DE FLUJO 4. PRUEBA DE ESCRITORIO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
VARIABLES MOSTRAR 
N canNul cantImp dig 
405037 0 0 7 2 3 
40503 1 1 3 
4050 2 2 0 
405 3 5 
40 0 
4 4 
0 
44
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*12. DADO UN NÚMERO N ENTERO POSITIVO MAYOR O IGUAL A 10, CONTAR LOS DÍGITOS NULOS, CONTAR LOS DÍGITOS 
IMPARES DEL NÚMERO Y DESPLEGAR LOS RESULTADOS.*/ 
#include <cstdio> 
int main(){ 
 int n, cantNul, cantImp, dig; 
 cantNul=0; 
 cantImp=0; 
 do 
 { 
 printf("Introduzca en valor para N: "); 
 scanf("%d", & n); 
 }while (n<10); 
 
 while(n!=0) 
 { 
 dig= n % 10; 
 if(dig==0) 
 { 
 cantNul=cantNul + 1; 
 } 
 if(dig %2 == 0) 
 { 
 cantImp= cantImp + 1; 
 } 
 n=n/10; 
 } 
 printf("\n La cantidad de digitos nulos:%d", cantNul); 
 printf("\n La cantidad de digitos impares es:%d", cantImp); 
 return 0; 
} 
6. SALIDA EN C: 
 
 
7. CODIFICACIÓN JAVA 
package pkgwhile; 
import java.util.Scanner; 
import javax.swing.JOptionPane; 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int n; 
 int dig, canImpar=0, canNull=0; 
 do{ 
 System.out.println("Ingrese un numero = "); 
 n = dato.nextInt(); 
 }while(n<10); 
 
 while(n != 0){ 
45
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
 dig = n%10; 
 if(dig == 0){ 
 canNull++; 
 } 
 if(dig % 2 == 0){ 
 canImpar++; 
 } 
 n=n/10; 
 } 
 System.out.println("Digitos Nulos = "+canNull 
 + "\nDigitos Impares = "+ canImpar); 
 } 
} 
 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
EJEMPLO 13 
1. LEER N DÍGITOS (CONTROLAR CON DO WHILE QUE SE INTRODUZCA MAYOR 
O IGUAL A 0 Y MENOR O IGUAL A 9) Y ARMAR UN NUEVO NÚMERO CON LOS 
DÍGITOS PRIMOS INTRODUCIDOS. 
 
2. ANÁLISIS 
Si n=4 
 dig =2; dig=3; dig=5 ; dig=8 
 Aplicando la formula nx=nx+d*p →→ nx=532 
3. DIAGRAMA DE FLUJO 4. PRUEBA DE ESCRITORIO 
 
 
46
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 
 
 
 
 
 
 
 
 
VARIABLES 
MOSTRAR n p nx cont dig c i 
4 1 0 0 2 0 1 532 
 10 2 1 3 1 2 
 100 32 2 5 2 3 
 1000 532 3 8 0 1 
 4 1 2 
 2 3 
 0 4 
 1 1 
 2 2 
 0 3 
 1 4 
 2 5 
 3 6 
 4 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*13. LEER N DÍGITOS (CONTROLAR CON DO WHILE QUE SE INTRODUZCA MAYOR O IGUAL A 0 Y MENOR O IGUAL A 9) Y 
ARMAR UN NUEVO NÚMERO CON LOS DÍGITOS PRIMOS INTRODUCIDOS.*/ 
#include <cstdio> 
int main(){ 
 int n, c, dig, nx, p, i, cont; 
 p=1; 
 nx=0; 
 printf("Introduzca en valor para N: "); 
 scanf("%d", & n); 
 cont=0; 
 while(cont<n) 
47
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
 { 
 do 
 { 
 printf("Introduzca un Digito: "); 
 scanf("%d", & dig); 
 }while (dig>9 || dig<0); 
 c=0; 
 for (i=1; i <= dig; i++) 
 { 
 if(dig%i==0) 
 { 
 c=c+1; 
 } 
 } 
 if(c==2) 
 { 
 nx=nx + dig*p; 
 p=p*10; 
 } 
 cont=cont + 1; 
 } 
 
 printf("\n el nuevo numero con los digitos primos es:%d", nx); 
 return 0; 
} 
6. SALIDA EN C: 
 
 
 
7. CODIFICACIÓN JAVA 
 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int n, c,dig,nx=0,p=1; 
 System.out.print("Ingrese valor para N = "); 
 n = dato.nextInt(); 
 int cont = 0; 
 while(cont<n){ 
 do{ 
 System.out.print("Ingresa un digito = "); 
 dig = dato.nextInt(); 
 }while(dig>9 || dig<0); 
 c = 0; 
48
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 for(int i = 1; i<=dig;i++){ 
 if(dig % i == 0){ 
 c++; 
 } 
 } 
 if(c==2){ 
 nx = nx+dig*p; 
 p=p*10; 
 } 
 cont++; 
 } 
 System.out.println("El nuevo numero con los dígitos es "+nx); 
 } 
} 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
 
 
 
EJEMPLO 14 
1. INTERCAMBIAR LOS DÍGITOS DE LOS EXTREMOS. ANÁLISIS, SI EL NÚMERO 
ES 2019, SOLO LOS EXTREMOS 2 Y 9 DEBE MOSTRAR 9012. 
2. ANÁLISIS 
Algoritmo ejercicio14 
 Definir x, i,e,d,pd, res Como entero 
 Escribir "Introduzca el valor para X=" 
 Leer xres<- 0 
 i <- 1 
 e <- 1 
 Mientras x >= 10 Hacer 
 d<-x mod 10 
 x<- trunc (x/10) 
 Si i == 1 Entonces 
 pd<- d 
 SiNo 
 res<-res + (d*e) 
 Fin Si 
 i<- i +1 
 e<- e *10 
 Fin Mientras 
 res<-res + (pd * e) + x 
 Escribir "El numero es:", res 
FinAlgoritmo 
49
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
3. DIAGRAMA DE FLUJO 
 
4. PRUEBA DE ESCRITORIO 
 
VARIABLES MOSTRAR 
X res I e D Pd 
2023 0 1 1 3 3 3022 
202 10 2 10 2 
20 10 3 100 0 
2 3012 4 1000 2 
0 
 
 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*14. INTERCAMBIAR LOS DÍGITOS DE LOS EXTREMOS. ANÁLISIS, SI 
EL NÚMERO ES 2023, SOLO LOS EXTREMOS 2 Y 3 DEBE MOSTRAR 
3022.*/ 
#include <cstdio> 
int main(){ 
 int x, res,i,e,d,pd; 
 res=0; 
 i=1; 
 e=1; 
 printf("Introduzca en valor para X: 
"); 
 scanf("%d", & x); 
 while(x>=10) 
 { 
 d=x%10; 
 x=x/10; 
 if(i==1) 
 { 
 pd=d; 
 } 
 else 
6. SALIDA EN C: 
 
 
 
50
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 { 
 res= res + (d*e); 
 } 
 i=i+1; 
 e=e*10; 
 } 
 res=res+(pd*e)+x; 
 printf("\n el nuneroes:%d",res); 
 return 0; 
} 
 
7. CODIFICACIÓN JAVA 
 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int x,res=0,i=1,e=1,d,pd=0; 
 System.out.print("Ingrese valor para X = "); 
 x = dato.nextInt(); 
 while(x >= 10){ 
 d = x%10; 
 x = x/10; 
 if(i == 1){ 
 pd=d; 
 }else{ 
 res=res+(d*e); 
 } 
 i++; 
 e = e*10; 
 } 
 res = res+(pd*e)+x; 
 System.out.println("EL numero es : "+res); 
 } 
} 
8. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
EJEMPLO 15 
1. ORDENAR LOS DÍGITOS IMPARES A LA IZQUIERDA Y LOS PARES A LA 
DERECHA. ANÁLISIS, SI EL NÚMERO ES 72149 EL ORDEN SERÁ: 71924. 
2. ANÁLISIS 
Algoritmo ejercicio15 
51
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
 Definir num, nn, parr, imp, ep, ei, cp, ci, d Como entero 
 Escribir "Introduzca el valor para Num=" 
 Repetir 
 Leer num 
 Hasta Que num >=10 
 nn<- num, parr <- 0, imp <- 0, ep<- 1, ei <- 1, cp <- 0, ci <- 0 
 Mientras nn > 10 Hacer 
 d<-nn mod 10 
 nn<- trunc (nn/10) 
 Si d mod 2 == 0 Entonces 
 par <- par + (d * ep) 
 ep<-ep * 10 
 cp <- cp + 1 
 SiNo 
 imp<-imp + (d * ei) 
 ei<-ei*10 
 ci<-ci +1 
 Fin Si 
 num<- imp * (10 ^ cp) 
 num<- num + parr 
 Fin Mientras 
 Escribir "El numero es:", num 
FinAlgoritmo 
3. DIAGRAMA DE FLUJO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. PRUEBA DE ESCRITORIO 
VARIABLES 
MOSTRAR num nn par imp ep ei cp ci d 
72149 72149 0 0 1 1 0 0 9 71924 
9 7214 4 9 10 10 1 1 4 
9 721 24 19 100 100 2 2 1 
52
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
90 72 719 1000 3 2 
94 7 7 
 190 0 
 194 
 1900 
1924 
71900 
71924 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*15. oODENAR LOS DÍGITOS IMPARES A LA IZQUIERDA Y LOS PARES A LA DERECHA. ANÁLISIS, SI EL NÚMERO ES 72149 EL 
ORDEN SERÁ: 71924.*/ 
#include <cstdio> 
int main(){ 
 int num, nn, par, imp, ep, ei, cp, ci, d; 
 do 
 { 
 printf("Introduzca en valor: "); 
 scanf("%d", & num); 
 }while(num<= 10); 
 nn=num, par=0, imp=0, ep=1, ei=1, cp=0, ci=0; 
 while(nn > 0) 
 { 
 d=nn%10; 
 nn=nn/10; 
 if(d % 2 ==0){ 
 par= par + (d*ep); 
 ep=ep*10; 
 cp=cp +1; 
 } 
 else{ 
 imp=imp+(d*ei); 
 ei=ei*10; 
 ci=ci+1; 
 } 
 num= imp * (10 ^cp); 
 num = num + par; 
 } 
 printf("\n El nuevo numero es:%d",num); 
 return 0; 
} 
6. CODIFICACIÓN JAVA 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int num, nn, par, imp, ep, ei, cp, ci,d; 
 do{ 
53
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
 System.out.print("Introduzca en valor: "); 
 num = dato.nextInt(); 
 }while(num <=10); 
 nn = num; 
 par = 0; 
 imp = 0; 
 ep=1; 
 ei=1; 
 cp=0; 
 ci=0; 
 while(nn > 0){ 
 d = nn %10; 
 nn=nn/10; 
 if(d % 2 == 0){ 
 par = par + (d*ep); 
 ep = ep * 10; 
 cp = cp+1; 
 }else{ 
 imp = imp+(d*ei); 
 ei=ei*10; 
 ci=ci+1; 
 } 
 num = imp+(int)Math.pow(10, cp); 
 num = num + par; 
 } 
 System.out.println("\nEl nuevo numero es "+num); 
 } 
} 
7. SALIDA EN JAVA: 
 
 
 
 
 
 
 
 
 
EJEMPLO 16 
1. DADO UN NÚMERO X, SUMAR CADA DOS DÍGITOS, SI LA SUMA ES DE DOS 
DÍGITOS VOLVER A SUMAR LOS DÍGITOS DEL RESULTADO HASTA QUE SEA UN 
SOLO DIGITO, SI EN EL NÚMERO QUEDA UN DIGITO SE DEBE MANTENER, CON 
LOS RESULTADOS OBTENIDOS FORMAR UN NÚMERO DONDE EL RESULTADO 
DE LA PRIMERA SUMA VIENE A SER EL DIGITO MÁS SIGNIFICATIVO, 
DESPLEGAR EL NUEVO NÚMERO 
2. ANÁLISIS 
Algoritmo ejercicio16 
 Definir x, d1,d2,s,nx,p Como entero 
 Escribir "Introduzca el valor para X =" 
 Leer x 
 nx<- 0, p<- 1 
54
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 Mientras x > 9 Hacer 
 d1<-x mod 10 
 x <- trunc (x/10) 
 d2<-x mod 10 
 x <- trunc (x/10) 
 s<-d1+ d2 
 Si s >= 10 Entonces 
 m <- s mod 10 
 n <-trunc (s/10) 
 s <- m+n 
 Fin Si 
 nx<- nx * p +s 
 p <- p *10 
 Fin Mientras 
 Si x>0 Entonces 
 nx <- nx * 10 + x 
 Fin Si 
 Escribir "El numero es:", nx 
FinAlgoritmo 
3. DIAGRAMA DE FLUJO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. PRUEBA DE ESCRITORIO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
VARIABLES 
MOSTRAR X NX P D1 D2 S M N 
47835 0 1 5 3 8 5 1 864 
4783 8 10 8 7 15 
478 86 100 6 
47 864 
4 
 
55
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*16. DADO UN NÚMERO X, SUMAR CADA DOS DÍGITOS, SI LA SUMA ES DE 
DOS DÍGITOS VOLVER A SUMAR LOS DÍGITOS DEL RESULTADO HASTA QUE 
SEA UN SOLO DIGITO, SI EN EL NÚMERO QUEDA UN DIGITO SE DEBE 
MANTENER, CON LOS RESULTADOS OBTENIDOS FORMAR UN NÚMERO 
DONDE EL RESULTADO DE LA PRIMERA SUMA VIENE A SER EL DIGITO MÁS 
SIGNIFICATIVO, DESPLEGAR EL NUEVO NÚMERO*/ 
#include <cstdio> 
int main(){ 
 int x, nx, p, d1,d2,s,m,n; 
 printf("Introduzca en valor X: "); 
 scanf("%d", & x); 
 nx=0; 
 p=1; 
 while(x > 9) 
 { 
 d1=x % 10; 
 x= x / 10; 
 d2=x % 10; 
 x= x / 10; 
 s= d1+ d2; 
 if(s >= 10) 
 { 
 m= s % 10; 
 n= s / 10; 
 s= m + n; 
 } 
 nx= nx *p + s; 
 p = p*10; 
 } 
 if(x>0) 
 { 
 nx = nx *10 + x; 
 } 
 printf("\n El nuevo numero es:%d",nx); 
 return 0; 
} 
 
6. SALIDA EN C: 
 
 
 
7. CODIFICACIÓN JAVA 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int x, nx, p, d1, d2, s, m, n; 
 System.out.print("Ingresa un valor para X = "); 
 x = dato.nextInt(); 
 nx = 0; 
 p = 1; 
 while(x > 9){ 
 d1 = x%10; 
 x = x/10; 
 d2 = x % 10; 
 x = x/10; 
56
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 s = d1 +d2; 
 if(s >= 10){ 
 m = s % 10; 
 n = s / 10; 
 s = m + n; 
 } 
 nx = nx * p + s; 
 p = p*10; 
 } 
 if(x > 0){ 
 nx = nx * 10 + x; 
 } 
 System.out.println("El numero es = "+nx); 
 } 
} 
8. SALIDA EN JAVA: 
 
 
 
57
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
 CAPITULO IV 
CICLO DO-WHILE (hacer - mientras) 
 
4.1. DEFINICIÓN 
 
El ciclo while es una estructura que permite ejecutar operaciones de 
manera repetitiva sin la necesidad de tener un valor inicial, una 
característica del ciclo while es que su condicional no dependen de 
un valor entero sin de una variable bandera o booleana, es decir que 
el ciclo se ejecutará mientras la condición sea verdadera. 
A diferencia del ciclo while, el ciclo do while permite ejecutar al 
menos una vez el ciclo incluso si la condición es falsa. 
 
4.2. SINTAXIS 
La sintaxis del ciclo Do While es un tanto larga a diferencia del ciclo while, pero no 
significa que esta sea compleja de leer, a diferencia del ciclo while, Do While lleva la 
condición al final de su sintaxis. 
A continuación, vemos la sintaxis del ciclo do - while: 
 
 
 
 
 
 
 
 
 
Línea 1: Esta línea no evalúa ninguna expresión, esta línea da el paso a la ejecución del 
ciclo y luego permite la valoración de la condición. 
Línea 2: en la línea 2 se observa una llave de apertura “{“, lo cual indica que allí es el 
inicio de las instrucciones del ciclo que será ejecutado mientras la condicional será 
verdadera. 
Línea 3-7: estas líneas representan el proceso que se ejecutaran mientras la condicional 
sea verdadera. 
Línea 8: esta última línea se observa una llave cerrada "}", el cual indica que allí termina 
el proceso del ciclo while. Una vez que la condición será falsa el bucle termina en esa 
línea de código y continua con la ejecución del resto del programa. 
Línea 9: en esta línea vemos la declaración del ciclo do while en letras azules en la cual 
sigue entre paréntesis la condición para finalizar el ciclo, mientras la condición sea 
verdadera, retorna al bucle para ejecutar las operaciones o el proceso indicado. 
EJEMPLO: 
58
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
Aclaración: 
El bloque de instrucciones o cuerpo del ciclo 
Repetir-HastaQue, se ejecutar´a por lo menos 
una vez. 
 
PSEUDOCODIGO DIGRAMA DE FLUJO LENGUAJE C LENGUAJE JAVA 
 
 
Repetir 
 f <- f * c 
 c <- c + 1 
Hasta Que c > n 
 do 
 { 
 f = f * c; 
 c = c + 1; 
 }while(c <= n); 
do 
{ 
 f = f*c; 
 c++; 
 }while( c <= n); 
 
 
4.3. REPRESENTACIÓN CICLO DO-WHILE EN DIAGRAMA DE FLUJO 
 
La instrucción Repetir-Hasta Que ejecuta una secuencia de 
instrucciones hasta que la condición sea verdadera. 
 
Repetir 
<instrucciones> 
Hasta Que <condición> 
 
 
 
En el diagrama se puede observar la manera en que es representado 
el ciclo Do - While en un diagrama de flujo. 
 
El funcionamiento del ciclo Do-While: 
En este ciclo se ejecutará al menos una vez el bucle, aunque la 
condición sea falsa, finalizado el proceso se evalúa la condición y si 
la misma es verdadera, retorna al inicio del ciclo para ejecutarse el 
proceso, una vez que la condición sea falsa sale del ciclo para continuar con el programa. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
59
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
Aclaración: 
Tanto el ciclo Mientras-FinMientras y Repetir-
HastaQue se ejecutan mientras la evaluación de 
la condición arroje un resultado verdadero. 
El Mientras-FinMientras evalúa la condición al 
comienzo, el Repetir-HastaQue la evalúa al final. 
 
 
 
 
 
60
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
EJEMPLO 17 
1. REALIZAR UN ALGORITMO QUE OBTENGA LA FACTORIAL DE UN NÚMERO. 
2. ANÁLISIS 
Algoritmo ejercicio17 
 Escribir "Introduzca el valor para N =" 
 Leer N 
 f<- 1 
 c<- 1 
 Repetir 
 f <- f * c 
 c <- c + 1 
 Hasta Que c > n 
 Escribir "La factorial es:", f 
FinAlgoritmo 
 
3. DIAGRAMA DE FLUJO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. PRUEBA DE ESCRITORIO 
 
 
 
 
 
 
 
VARIABLES 
MOSTRAR 
n f c 
5 1 1 120 
 1 2 
 2 3 
 6 4 
 24 5 
 120 6 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*17. REALIZAR UN ALGORITMO QUE OBTENGA LA FACTORIAL DE UN 
NÚMERO.*/ 
#include <cstdio> 
int main(){ 
 int n, f, c; 
 printf("Introduzca en valor N: "); 
 scanf("%d", & n); 
 f=1; 
 c=1; 
 do 
 { 
 f=f*c; 
 c = c+1; 
6. SALIDA EN C: 
 
 
61
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
 }while(c <= n); 
 printf(" La factorial de un numero 
es:%d",f); 
 return 0; 
} 
 
7. CODIFICACIÓN JAVA 
 
package pkgDowhile; 
import java.util.*; 
public class DoWhile { 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int n, f,c; 
 System.out.print("Ingresa un numero para N= "); 
 n = dato.nextInt(); 
 f=1; 
 c=1; 
 do{ 
 f = f*c; 
 c++; 
 }while(c<=n); 
 System.out.println("La factorial del número="+f); 
 } 
} 
8. SALIDA EN JAVA: 
 
EJEMPLO 18 
1. INGRESAR POR TECLADO N NÚMEROS ENTEROS Y CALCULAR CUÁNTOS 
SON POSITIVOS, NEGATIVOS Y NEUTROS. 
2. ANÁLISIS 
Algoritmo ejercicio18 
 Escribir "Introduzca el valor para N =" 
 Leer N 
 pos<- 0, neg<- 0, neu<- 0, c<- 1 
 Repetir 
 Escribir "Introduzca un Numero =" 
 Leer num 
 Si num==0 Entonces 
 neu<- neu + 1 
 SiNo 
 Si num < 0 Entonces 
 neg<-neg + 1 
 SiNo 
62
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 pos<-pos + 1 
 Fin Si 
 Fin Si 
 c <- c + 1 
 Hasta Que c > n 
 Escribir "Neutro:", neu 
 Escribir "Negativo:", neg 
 Escribir "Positivo:", pos 
FinAlgoritmo 
3. DIAGRAMA DE FLUJO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. PRUEBA DE ESCRITORIO 
 
 
 
 
 
 
 
 
VARIABLES MOSTRAR N pos neg neu c num 
6 0 0 0 1 -1 2,2,2 
 1 1 1 2 -30 
 2 2 2 3 3 
 4 35 
 5 0 
 6 0 
 7 
 
63
ESTRUCTURAS REPETITIVAS 
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
VOLUMEN 2
 
 
5. CODIFICACIÓN DEV-C++ 5.2.0.1 
/*18. INGRESAR POR TECLADO N NÚMEROS ENTEROS Y CALCULAR CUÁNTOS SON POSITIVOS, NEGATIVOS Y 
NEUTROS.*/ 
#include <cstdio> 
int main(){ 
 int n, pos, neg, neu, c, num; 
 printf("Introduzca en valor N: "); 
 scanf("%d", & n); 
 c=1, pos=0, neg=0, neu=0; 
 do 
 { 
 printf("Introduzca un Numero: "); 
 scanf("%d", & num); 
 if(num == 0) 
 { 
 neu = neu +1; 
 } 
 else 
 { 
 if(num < 0) 
 { 
 neg= neg + 1; 
 } 
 else 
 { 
 pos= pos +1; 
 } 
 } 
 c = c+1; 
 }while(c <= n); 
 printf(" \nNumeros Positivos:%d",pos); 
 printf(" \nNumeros Negativos:%d",neg); 
 printf(" \nNumeros Neutros:%d",neu); 
 return 0; 
} 
6. SALIDA EN C: 
 
 
 
 
 
 
 
 
 
 
 
 
7. CODIFICACIÓN JAVA 
package pkgwhile; 
import java.util.Scanner; 
public class While { 
64
INTRODUCCIÓN A LA PROGRAMACIÓN C / JAVA
ESTRUCTURAS REPETITIVAS 
VOLUMEN 2
 
 
 public static void main(String[] args) { 
 Scanner dato = new Scanner(System.in); 
 int n, pos, neg, neu, c, num; 
 System.out.print("Introduzca en valor N: "); 
 n = dato.nextInt(); 
 c=1; 
 pos=0; 
 neg=0; 
 neu=0; 
 do 
 { 
 System.out.print("Introduzca un Numero: "); 
 num=dato.nextInt(); 
 if(num == 0) 
 { 
 neu = neu +1; 
 } 
 else 
 { 
 if(num < 0) 
 { 
 neg= neg + 1; 
 } 
 else 
 {