CursoComputaciónModelos

Curso de computación utilizando modelos mentales
Objetivo
Sincronizar los elementos mentales de una solución de un problema, con las características
funcionales de un computador y obtener así un algoritmo.
Dentro de los pasos de solución de problemas está la descripción del problema, el cual tiene que
ser entendible y claro, y se determina que un problema a solucionar se lo entiende perfectamente,
cuando se da un ejemplo de una solución.
Elaborar un ejemplo, significa que se conoce todos los conceptos para su solución.
De lo anterior podemos concluir que, una solución a un problema por computador es posible, si y
solo si mentalmente se puede dar un ejemplo de una solución, esto significaría que se conocen
todos los conceptos necesarios para el planteamiento de una solución.
Características de un ejemplo de una solución mental a un problema.

- Debe tener claro todos los conceptos que van a intervenir en la solución de un problema.
- Con los conceptos claros se construye el ejemplo solución de arriba hacia abajo y si es
necesario de izquierda a derecha.
- Incluir pocos datos, con el concepto de que lo que se hace para unos pocos es lo mismo
que se hace para muchos.
- En el ejemplo se debe detallar todo los elementos que interviene en la solución, no se
deben dar resultados por hecho.
- Describa en forma genérica las acciones que se realizan.
- Seguir un orden lógico, el cual generalmente se la obtiene con los siguientes pasos
genéricos:
Entrada
Proceso
Salida
En donde:
Entrada, se refiere a todos los datos que se necesitan para llegar a la solución del problema.
Proceso, acciones que transforman datos para obtener los resultados esperados. En este proceso
pueden aparecer nuevos datos y se incluyen todas las expresiones aritméticas y lógicas que se
pueden presentar
Salida. Se refiere a los resultados que se obtienen durante el proceso, generalmente son los
resultados de transformar datos de entrada.
Ejemplo de un modelo mental.
Hallar el área de un triángulo.
Conceptos claros.
Se debe conocer la fórmula del Área- de un triángulo
Area = Base*altura
2
Con este concepto claro se plantea el ejemplo
Para resolver este ejercicio, se necesita tener la base y la altura del triángulo, el ejemplo planteado
es el siguiente:
Base 5
Altura 6
Area = 5*6 = 15
2
Area = 15
Este ejemplo plantea que si se puede llegar a la solución del problema y se ha avanzado en la
descripción de todos los elementos que intervienen en la solución mental.
Con este ejemplo se llega al segundo paso que es el análisis del problema, en donde se deben
identificar todos los elementos y sus relaciones.
El ejemplo anterior ya ha avanzado bastante en este aspecto, lo que se debe hacer ahora, es
agregarle a los elementos participantes las características computacionales para que se conviertan
en elementos computacionales, ya que la solución es para el computador.
Conceptos que se deben tener bien claro para ampliar los presentes en el modelo solución mental:
- Representación de un dato en la memoria del computador

- Manejo de entradas de datos del exterior al computador
- Manejo de expresiones aritméticas en el computador, que producen cálculos y resultados
- Manejo de salidas del computador al exterior
Para agregarle las características computacionales al ejercicio mental se debe tener los conceptos
de:
Representación de un dato en la memoria del computador, que permite definir el concepto de

variable y constante.
Todo dato aparece en la memoria de un computador como variable o como constante
Instrucciones que permiten manipular los datos.
Estas instrucciones se resumen en las siguientes

Instrucciones secuenciales
- Instrucción de entrada
- Instrucción de salida
- Instrucción de asignación
Instrucciones de decisión
Instrucciones repetitivas
Representación de un dato en la memoria del computador

Conceptos:
- Todo dato para poder ser procesado debe estar en la memoria del computador
- Un dato puede ser numérico, alfanumérico o booleano
- Un dato aparece en la memoria como variable o como constante
- Variable: Campo de memoria que va a tomar valores diferentes durante la ejecución de un
programa, tiene un único nombre descriptivo y un tipo de dato asociado, que puede ser
numérico (entero o real), alfanumérico o booleano
Constante: Campo de memoria que va a permanecer constante durante la ejecución de un
programa, puede aparecer en las instrucciones o se les puede asignar un nombre y un tipo
de dato
Instrucciones que permiten manipular datos
Instrucción de entrada
Esta acción permite que lleguen datos del exterior a la memoria principal del computador. La
instrucción representativa es leer y su formato es:
Leer Lista de variables
La acción de leer se la debe tomar desde la posición del computador y asocia por defecto el
teclado.
Con esta instrucción, el computador lee lo que el usuario le ha digitado en el teclado y lo almacena
en los campos de memoria especificados en la lista de variables.
Ejemplos
Leer A
Se entiende:
- El computador espera que el usuario digite un valor en el teclado
- El dato digitado es leído por el computador y lo almacena en el campo de memoria con
nombre A.
También se puede tener
Leer A,B,C
Se entiende
- Se espera que se digiten tres valores.
- Cada valor digitado se almacena en los campos de memoria A,B y C respectivamente.
La instrucción anterior también puede ser:
Leer A
Leer B
Leer C
cin >>A;
cin >>B;
Y lo que ocurre internamente es que el dispositivo de entrada (teclado por defecto), transforma en
ceros y unos el dato tecleado, el cual es leído y llevado a las direcciones de memoria
correspondientes a las variables A , B y C respectivamente.
Instrucción de Salida
Es la acción que le permite sacar información almacenada en la memoria principal a un dispositivo

externo, en donde la pantalla es la más utilizada.
La instrucción es la siguiente
Escribir Lista de variable o constantes alfanuméricas
Ejemplo
Escribir “Valor de variable A es “,A
cout <<”Valor de variable a es”<<A;
Elementos
“Valor de variable A es “ es una constante alfanumérica y sirve para especificar lo que se va a

mostrar
A es una variable y lo que hace es, traer el valor almacenado (ceros y unos) y mostrarlo en pantalla
en formato normal (traducido. Realizado por los dispositivos de salida) .
Si el valor de A es 20, la ejecución de la instrucción mostrará lo siguiente:
Valor de variable A es 20
Lo que está entre comillas dobles aparece tal cual y lo que no está entre comillas, se considera
como variable y muestra su valor, en este caso 20
La instrucción de salida también puede tener solo constantes alfanuméricas y sirven para mostrar
mensajes, que combinados con una acción de entrada se puede tener lo siguiente
Escribir “Digitar un valor numérico ==> “

Leer A
cout<<”Digitar un valor numérico ->”;

cin >>A;
Donde su ejecución sería
Digitar un valor numérico ==>

_
Esto puede orientar una entrada cuando se trabaja con materiales educativos computacionales
como PsInt
Instrucción de Asignación
Permite modificar el valor de una variable con el resultado de una expresión que puede ser
numérica, alfanumérica o lógica.
Esta instrucción tiene mucha importancia, ya que es la única que permite que los valores de una
variable cambien y por tanto se obtenga una información.
El formato es el siguiente
Variable  Expresión
Donde  es el operador de asignación
Esta acción se entiende que la variable va a cambiar con el resultado de la expresión
Ejemplos
A 20
A B
A B+50
C  true
Nombre  “Carlos”
Lo anterior muestra que Expresión puede ser una constante, una variable o el resultado de una
expresión.
Importante
La instrucción de asignación tiene dos tiempos, determinados estos por el operador de asignación.
Tiempo 1: Derecha del operador  correspondiente a la Expresión. Esta debe ejecutarse primero.
Tiempo 2: Izquierda del operado  Correspondiente a la variable. La variable recibe el resultado
de la expresión.
El operador  es el que determina que el resultado de la expresión se lleve a la variable del lado
izquierdo.
Los dos tiempos de la asignación, permite tener instrucciones como las siguientes, que son
situaciones muy utilizadas en la programación.
AA+1
AA+C
Donde A aparece en los dos lados de la instrucción de asignación, en donde, primero se hace lo de
la derecha. El valor de A aparece en ambos lados y al final cambia.
Anotaciones acerca de la asignación

Variable  Expresión
- Toda variable que aparezca a la derecha de un enunciado de asignación debe estar definido
- En un enunciado de asignación la variable de la izquierda es la única que cambia de valor
- Las variables que están a la derecha de la asignación conservan su valor después de ejecutarse
la instrucción.
- Si la variable del lado izquierdo se encuentra también en el lado derecho esta al final cambia
de valor
Ejercicios con Instrucciones secuenciales
Ejercicio secuenciales 1
Hallar el área de un triángulo
Hasta el momento se tiene el modelo mental con el cual se realiza lo siguiente:
Solución mental + Características computacionales = Solución computacional
De lo anterior se concluye que, la solución mental y la computacional son los mismos, en

diferentes contextos.
Características computacionales a adicionar
Variables y constantes
Entradas
Asignaciones
Salidas
Modelo mental
Datos de entrada
Base 5
Altura 6
Area = 5*6 = 15
2
Resultado Area = 15
Los datos se convierten en variables o constantes:
Recordemos las reglas que se van definiendo acerca de los datos en el computador:
- Todo dato para poder ser procesado debe estar en la memoria principal.
- Todo dato en la memoria debe estar como variable o como constante.
- Si esta como variable, debe tener un único nombre y un tipo de dato asociado.
Continuación ejemplo del triángulo

Base 5
Altura 6
Area = 5*6 = 15
2
Area = 15
En el ejemplo se tienen los datos 5,6,2 y 15 , los cuales todos deben aparecer en la memoria.
Campos variables 5,6 y 15
Campo constante 2
Nombres de variables:
B numérico entero para base

A numérico entero para altura
Area numérico real para el Area
Entonces el modelo con nombres queda
Modelo mental con nombres
inicio
int B,A;
float Area;
B
Base 5 cin >>B;
A
Altura 6 cin>>A;
Area
Area = B*A = 15 Area=(B*A)/2;
2
Area
“Area =” 15 cout<<”Area = “<<Area;
Fin
Importante, En todo modelo mental, ningún dato debe quedar sin nombre, excepto las constantes
numéricas y alfanuméricas, en el ejemplo el número 2 y “Area = “
Determinación de los valores de las variables. La determinación de valores de las variables ya

implica acciones computacionales.
Para esta determinación se tiene en cuenta que, todo valor de una variable aparece por dos
formas, por una acción de entrada (leer ) o por resultados de una acción de asignación ().
Para determinar si un dato es constante o una variable, se debe entender muy bien la definición
del problema, en el ejemplo el programa puede ser para cualquier triángulo, por lo que la base y la
altura puede ser cualquier valor y el 2 es una constante.
Valores a variables por entrada:
ByA
Las acciones serían:
Leer B
Leer A
O
Leer B,A
Valores a variables por asignación.

Area, con valor 15
La acción sería:
Area  B*A/2
Acciones de Salida.
Del ejemplo se tiene que el resultado es:
Area = 15
Para obtener esto se tiene la siguiente acción de salida:
Escribir “Area = ”,Area
Construcción del algoritmo
El siguiente paso es establecer las acciones de acuerdo al orden que tiene el modelo mental, y se
lo toma de arriba hacia abajo y de izquierda a derecha, teniendo en cuenta si es entrada o
asignación.
Todas las acciones conforman el algoritmo y se demarca con un inicio y con un fin.
Inicio
Leer B
Leer A
Area  B*A/2
Escribir “Area = ”,Area
Fin
De lo anterior se concluye que el modelo resultante no debe involucrar valores presentes en el

modelo mental, solo deben aparecer nombres de variables, si hay valores, deben corresponder a
las constantes.
Programa en lenguaje C++
#include <iostream>
using namespace std;
int main(){
int a,b;
float area;
cout<<”Digitar base -> ”;
cin>>b;
cout<<”Digitar altura -> ”;
cin>>a;
area=(float)a/b; // se coloca (float) para que se tenga en cuenta los decimales
cout <<”Area = “<<area;
return 0;
}
Ejemplo secuenciales 2
Realizar un algoritmo para las operaciones aritméticas de suma, resta, multiplicación y división de
dos números.
Concepto a manejar en el modelo mental
número
suma, resta, multiplicación y división
Ejemplo solución
Datos numéricos
10 y 5
Operaciones básicas
Suma 10+5 = 15 suma = 15

Resta 10-5 = 5 resta = 5
Multiplicación 10*5 =50 multiplicación = 50
División 10/5 =2 división = 2
Resultados
Suma=15
Resta=5
Multiplicación= 50
División=2
Construcción del modelo computacional

Conceptos a manejar
- Variable int,float,double nombre(único)

- Constante
- Acción de Entrada (Leer ) (cin)
- Acción de Asignación ( ) (=)
- Acción de Salida (Escribir ) (cout)
El modelo computacional debe quedar con estos elementos únicamente.
Los datos del modelo mental soportan las variables
Numéricos
Variables
10,5,15,5,50 y 2
Nombres de variables
Numero 1 N1 10
Numero 2 N2 5
Suma SUM 15
Resta RES 5
Multiplicación MUL 50
División DIV 2
Modelo con nombres de variables
Datos numéricos
10 y 5
Operaciones básicas
Suma 10+5 = 15
Resta 10-5 = 5
Multiplicación 10*5 =50
División 10/5 =2
Resultados
Suma=15
Resta=5
Multiplicación= 50
División=2
Definición de datos - Toda variable para poder ser procesada debe estar definida.
Una variable antes de ser utilizada debe tener un dato almacenado.
Instrucción de definición
Formato
Tipo_dato lista_de_variables=valor;
int,short,byte,long,float,double,char
int N1,N2;
N1 N2
10 5 cin>> N1; cin>>N2;
N1 + N2 = SUM
Suma 10 + 5 = 15 Variable = Expresión SUM=N1+N2;
N1 N2 = RES
Resta 10 - 5 = 5
N1 N2 = MUL MUL=N1*N2;
Multiplicación 10 * 5 = 50
N1 N2 = DIV
División 10 / 5 = 2
SUM cout<<”Suma = “<<SUM;

“Suma= “,15
RES cout <<”Resta = “<<RES;
“Resta= “,5
MUL
“Multiplicación= ”, 50
DIV
“División=”, 2
Determinación de valores de variables
Por entradas
N1 N2
10 5
Acciones
Leer N1
Leer N2
Por asignación
SUM RES MUL DIV
15 5 50 2
Acciones
SUM  N1+N2
RES  N1-N2
MUL  N1*N2
DIV  N1/N2
Determinación de salidas o resultados
Se utiliza la acción escribir, teniendo en cuenta que lo siguiente es lo que va a mostrar
SUM
“Suma= “,15
RES
“Resta= “,5
MUL
“Multiplicación= ”, 50
DIV
“División=”, 2
De aquí se tienen las siguientes acciones:
Escribir “Suma = “,SUM

Escribir “Resta= “,RES
Escribir “Multiplicación= ”, MUL
Escribir “División= ”, DIV
Algoritmo resultante
lo toma de arriba hacia abajo y de izquierda a derecha, teniendo en cuenta si es entrada,
asignación o salida.
Algoritmo
Inicio
Definir N1,N2,SUM,MUL,RES como entero
Definir DIV como real
Leer N1
Leer N2
SUM  N1+N2
RES  N1-N2
MUL  N1*N2
DIV  N1/N2
Escribir “Suma = “
Escribir “Resta= “,RES
Escribir “Multiplicación= ”, MUL
Escribir “División= ”, DIV
Fin
#include <iostream>
int main(){
int n1,n2,sum,res,mul;
float divi;
cout<<”Digitar dato 1 -> ”;

cin>>n1;
cin>>n2;
sum=n1+n2;
res=n1-n2;
mul=n1*n2;
divi=(float)n1/n2;
// resultados
cout<<”\nSuma = “<<sum;
cout<<”\nResta = “<<res;
cout<<”\nMultiplicación = “<<mul;
cout<<”\nDivisión = “<<divi;
return 0;
}
Ejemplo secuenciales 3
Hallar el promedio de 3 valores numéricos
Ejemplo- Solución mental
La importancia del modelo mental radica en que se obliga al estudiante a dar un ejemplo de la
solución con datos reales, para ser utilizado como base para la construcción del algoritmo.
Tres valores
Datos de entrada 5, 7 y 12
El promedio es
SUM
5+7+12 = 24 /3 = 8
3
Sum=n1+n2+n2
Resultado Promedio = 8
El anterior es un modelo mental

Cómo se sabe si el dato es una constante o una variable?
La definición del problema es la que determina si es constante o variable, en el ejemplo se plantea

que son tres datos numéricos, pero no indica cuales, o sea, puede ser cualquier valor, el (3) tres es
constante porque la definición así lo plantea.
int n1,n2,n3;
float prom;
n1 n2 n3
Datos de entrada 5, 7 y 12 cin>>n1; cin>>n2; cin>>n3;
El promedios es
n1 n2 n3 prom
5 + 7 + 12 = 8 prom=(n1+n2+n3)/3
3
prom
Resultado “Promedio =” , 8 cout <<”Promedio = “<<prom;
Los nombres que están en cada valor numérico indica el nombre de las variables y el valor es lo
que almacenaría en un momento específico como el ejemplo.
El siguiente punto es establecer como llega el valor a la variable, el cual puede ser por entrada o
por asignación.
Según lo anterior los valores 5,7 y 12 son por entrada y el 8 por asignación.
Por lo que quedaría así:
Leer n1
Leer n2
Leer n3
Leer n1,n2,n3
La representación de las acciones solo utilizan nombres.
Cuando un dato es por asignación se debe establecer cual es la expresión que lo modifica. En este
caso es:
Prom(n1+n2+n3)/3
lo toma de arriba hacia abajo y de izquierda a derecha, teniendo en cuenta si es entrada,
asignación o salida.
Las acciones son

Inicio
Definir n1,n2,n3 como entero
Definir Prom como real
Leer n1
Leer n2
Leer n3
Prom  (n1+n2+n3)/3
Escribir “Promedio = “,Prom
Fin
#include <iostream>
int main(){
int n1,n2,n3;
float prom;

cin>>n1;
cin>>n2;
cin>>n3;
prom=(float)(n1+n2+n3)/3;
cout<<”Promedio = “<<prom;
return 0;
}
Ejercicios propuestos.
1.Calcular el sueldo de un empleado que tiene lo siguiente:
Número de horas trabajadas

Valor de la hora
Descuento del 10%
2. calcular el sueldo de dos empleados que tienen por cada uno

Valor de la hora
Número de horas
Descuento
3. Calcular el perímetro de un rectángulo y de un cuadrado

4. Calcular el perímetro de un triángulo equilátero
5. Calcular el área de una circunferencia y su perímetro
1.Calcular el sueldo de un empleado que tiene lo siguiente:

Valor de la hora
Descuento del 10%
Ejemplo
int nh,vh,st;
float des,sn;
nh
Numero de horas 20 cin >>nh;
vh
Valor hora 15000 cin>>vh;
Nh vh st
Sueldo total 20*15000= 300000 st=nh*vh;
St des
Descuento 300000*10/100=30000 des=st*10/100;
St des sn
Sueldo Neto 300000-30000 = 270000 sn=st-des;
sn
Sueldo Neto = 270000 cout<<”Sueldo neto = “<<sn;
Identificar variables
NH //entrada
Numero de horas 20
VH // entrada
Valor hora 15000
NH VH ST // asignación STNH*VH
Sueldo total 20 * 15000= 300000
ST DES // asignación DES  ST*10/100 DES ST*0,1

Descuento 300000*10/100=30000
ST DES SN // asignación SN ST-DES

Sueldo Neto 300000-30000 = 270000
SN // salida
“Sueldo Neto = “, 270000
Definir de donde vienen los valores (entrada o asignación)
Inicio
Definir NH,VH,ST como entero
Definir DES,SN como real
Leer NH
Leer VH
STNH*VH
DESST*10/100
SN  ST-DES
Escribir “Sueldo Neto =”,SN
Fin
El programa resultante en lenguaje C++ incluyen diseño de entradas y salida
#include <iostream>
int main(){
int nh,vh,st;
float desc,sn;
cout<<”Numero de horas trabajadas -> ”;

cin>>nh;
cout<<”Valor de la hora -> ”;
cin>>vh;
st=nh*vh;
desc=st*10/100;
sn=st-desc;
cout<<”Sueldo neto = “<<sn;
return 0;
}
Identificar acciones de decisión.
En el desarrollo de soluciones a problemas por computador muchas veces se pueden presentar

situaciones de excepción, agrupación o comparación, con el objetivo de aclarar o conocer alguna
circunstancia en particular. La toma de decisiones de acuerdo a algunas comparaciones, son muy
comunes en la solución de problema, esto hace que la solución sea flexible y se ajuste a todas las
posibilidades o alternativas que pueda presentarse en un momento dado. De aquí la necesidad de
hacer comparaciones y tomar decisiones.
La instrucción de decisión lógica es utilizada para seleccionar la ruta que debe tomar la ejecución
cuando se presentan tomas de decisiones.
Una acción de decisión en un modelo mental solución, se presenta cuando dentro de los pasos hay
preguntas que indagan acerca de la situación de uno o varios campos de memoria, con el
propósito de realizar acciones específicas de acuerdo al resultado.
Dentro de un ejercicio se pueden encontrar diferentes tipos de indagación como las siguientes.
Comparación de valores.
La comparación de valores se presenta mucho dentro de la solución de problemas y se la realiza

con operadores relacionales ( >,<,<=,>=,=,<> o !=).
Una acción de decisión es muy utilizada para comparar dos valores que pueden ser nombres de
campos de memoria o constantes o la combinación de estas, en donde se puede presentar que un
valor sea mayor, menor o igual al otro. La instrucción de decisión tiene una condición como las
siguientes:
¿Edad > 20?

¿Edad <= 20?
¿SueldoTotal < SueldoNeto?
¿Num > 30?
¿Num1 < Num2?
¿Num1 <= Num2 && num2>num3?
Si o No
Estas condiciones que involucran un solo operador relacional, se denominan condiciones simples y
su resultado puede ser verdadero o falso.
La instrucción de decisión se complementa con las acciones a realizar por uno de dos caminos
(camino por verdadero y camino por falso).
Ejemplo
¿Edad > 60?

Si entonces es viejo
No entonces es joven // < o =
Se concluye que es viejo si la condición es verdadera

Se concluye que es joven si la condición es falsa
Según lo anterior se establece que es joven o es viejo, no las dos situaciones, por lo tanto una
instrucción de decisión es excluyente, es decir excluye una de las dos, si es joven, no es viejo o si
es viejo, no es joven.
Instrucción de decisión
Mentalmente cuando hay una pregunta, en el algoritmo hay una instrucción de decisión la cual va
a tener el siguiente formato:
Formato para Seudocódigo
Si ( condición ) // condición es una expresión lógica

Entonces // condición verdadera
Acciones por verdadero
[Sino // condición es falsa
Acciones por falso]
Fin si
Formato en lenguaje C++
if (condición) [ { ]
acciones por verdadero
[}]
[else [{]
Acciones por falso
[}]
Lo que esta entre corchetes ( [ ] ) es opcional, lo que indica que los llaves van o no van.
Las llaves ({ , }) son obligatorias si las acciones por verdadero o por falso son más de una.
Las llaves siempre van a agrupar un conjunto de instrucciones.
Sino y else también están entre corchetes, lo que indica que es opcional que la acción vaya.
Ejemplos de decisiones mentales
¿Edad > 60?

Si entonces es viejo
No entonces es joven // < o =
Si edad > 60
Entonces
Escribir “ Es viejo”
Sino
Escribir “ Es joven “
Fin si
En lenguaje C++
if (edad>60) {
cout<<”Es viejo “;
}
else {
cout <<”Es joven”;
}
Condición. Es un expresión lógica (su resultado es verdadero o falso) y puede ser simple o
compuesta.
Condición simple. La expresión lógica utiliza un solo operador relacional
ej: A>B
C >= D
Condición compuesta. La expresión lógica, incluye al menos un operador lógico (and, or):
ej: A>B and B>C

A>B y C>=D
ej: A>B or B>C

A>B o C>=D
En lenguaje C++
a>b && b>c

a>b || b>c
El resultado de la expresión se relaciona con las tablas de decisión
Acciones por verdadero se ejecutan si la condición es verdadera y pueden ser cualquier

instrucción incluyendo la de decisión, si es más de una acción, en lenguaje C++ obliga a la
colocación de las llaves, para indicar que es un bloque de acciones.
Acciones por falso se ejecutan si la condición es falsa, si es más de una acción, en lenguaje C++
obliga a la colocación de las llaves, para indicar que es un bloque de acciones.
Ejercicio decisión 1
Realizar un algoritmo que permita comparar dos valores y mostrar su resultado
Conceptos a tener en cuenta
Cuando se compara dos valores se tiene las siguientes situaciones:
Primer valor mayor que el Segundo Valor

Primer valor menor que el Segundo Valor
Primer valor igual al segundo valor
Para la comparación de dos valores se puede utilizar cualquier operador relacional (<,>,<=,>=,==,!
=).
El operador relacional inicial determina el camino.
Este ejercicio debe dar la posibilidad de los tres casos, lo que implica lo siguiente:
Modelo mental
Números dados 17 y 10
¿ 17 > 10 ?
Si
Respuesta 17, “ mayor que”, 10
Datos 5 y 5
¿5 > 5?
No
¿5=5?
Si
Respuesta 5 es igual a 5
Datos 2 y 5
¿2 > 5?
No
¿2=5?
No
Respuesta 2 es menor que 5
Variables 17 y 10
Nombres n1 y n2
n1 n2
Números dados 17 y 10
n1 n2
¿ 17 > 10 ?
Si
n1 n2
Respuesta 17, “ mayor que”, 10
El modelo mental anterior tan solo me da una posibilidad de 3, entonces, se debe establecer en
los datos las posibilidades que se pueden presentar para especificar los caminos.
Determinación de valores
17 y 10 son por entrada
En el momento en que se le da nombres a los valores del modelo mental, se generaliza el

modelo, lo que implica que los valores se generalizan lo cual obliga a tener todas las
posibilidades.
Decisión
Si (n1 > n2)

Si
n1 es mayor que n2
No //hay dos posibilidades n1<n2 y n1=n2
Si(n1=n2)
si
n1 igual a n2
No
n1 es menor que n2
Algoritmo
Inicio
Leer n1,n2
Si (n1>n2)
Entonces
// Estrictamente n1 es mayor que n2
Escribir n1, “Mayor que ”, n2
Sino
// pudo haber ocurrido falso por dos posibilidades, que n1= n2 o n1<n2 por lo tanto
// se debe condicionar para esto, así:
Si ( n1 < n2)
Entonces
// Por la historia n1 es estrictamente menor que n2
Escribir n1, “Menor que “, n2
Sino
// Esto significa que n1 no es mayor que n2 y que n1 no es menor
Escribir n1, “ igual a “, n2
Fin si
Fin si
Fin
#include <iostream>
int main() {
int n1,n2;
//Entrada de datos
cout<<”Digitar valor 1 -> “;
cin>>n1;
cout<<”Digitar valor 2 -> ”;
if (n1>n2) {
cout<<n1<<” es mayor que “<<n2;
}
else {
//hay dos posibildades
If (n1<n2)
else
}
return 0;
}
El siguiente algoritmo compara los valores n1 y n2 iniciando con la comparación con el operador
<=, lo cual da una lógica de solución diferente.
Inicio
Leer n1,n2
Si (n1<=n2)
Entonces
// Se presenta que n1 puede ser menor o igual n2, hay dos posibilidades
Si ( n1 < n2)
Entonces
// n1 es estrictamente menor que n2
Escribir n1, “Menor que “, n2
Sino
// n1 igual a n2
Escribir n1, “ igual a “, n2
Fin si
Sino
// Estrictamente n1 es mayor que n2
Escribir n1, “Mayor que ”, n2
Fin si
Fin

#include <iostream>
int n1,n2;
//Entrada de datos
cin>>n1;
cin>>n2;
if (n1<=n2)
// por verdadero hay dos posibilidades
if (n1<n2)
//n1 es estrictamente menor que n2
cout<<n1<<” es menor que “<<n2;
else
cout<<n1<<” es igual a “<<n2;
else
//n1 es estrictamente mayor que n2
return 0;
}
Decisiones anidadas
Una decisión anidada se presenta cuando por las acciones de una instrucción de decisión ya sea
por falso o verdadero hay otra instrucción de decisión.
Los ejercicios anteriores tienen decisiones anidadas.

De acuerdo con lo anterior y como se tienen seis (6) operadores relacionales, va a ver seis formas
de estructurar el algoritmo que van a dar como resultado diferentes anidamientos. Lo importante
es entender que al comparar dos valores se va a tener tres posibilidades.
Cuando hay decisiones anidadas se debe tener bien claro la historia que le define un camino,
para no volver hacer preguntas innecesarias.
Ejercicio decisiones 3
Determinar el mayor de 3 valores dados
Ejemplo
Valores 5 8 3
Según esto el mayor es 8

Para concluir que 8 es el mayor se debe comparar este valor, con los datos 5 y 3
Modelo más detallado. Utilizando condiciones simples ( Solo dos datos a la vez)
Datos 5 8 3
¿5>8?
Si
No
¿8>3?
Si
Mayor 8
no
Adicionar nombres a variables
Variables a,b,c
a b c
Datos 5 8 3
a b
¿ > ?
Si
¿a>c?
Si
Mayor es a
No
Mayor es c
No
b c
¿ > ?
Si
b
Mayor
No
Mayor c
Determinar valores
5 8 3 son por entrada
Esto es lo que se hace mentalmente para un caso específico, pero cuando hay decisiones, se
deben evaluar todas las posibilidades.
El modelo mental me da un camino, pero deja planteado otros caminos que hay que completar,
teniendo en cuenta que toda acción de decisión tiene verdadero y falso. Aquí se dejan planteado
dos preguntas y las dos deben completarse.
Algoritmo en seudocódigo
inicio
Leer a,b,c
Si (a>b) Entonces
Si (a>c) Entonces
Escribir ' mayor = ',a
SiNo
Escribir ' mayor = ',c
FinSi
SiNo
Si (b>c) Entonces
Escribir ' mayor = ',b
SiNo
Escribir ' mayor = ',c
FinSi
FinSi
Fin
#include <iostream>
int main(){
int a,b,c;
//Entrada de datos
cin>>a;
cin>>b;
cin>>c;
if (a>b)
if (a>c)
cout<<a<< “ es el mayor “;
else
cout<<c<< “ es el mayor “;
else
if (b>c)
cout<<b<< “ es el mayor “;
else
cout<<c<< “ es el mayor “;
return 0;
}
Hallar el mayor de cuatro datos
Ejemplo
Datos 5 8 3 15
Según estos datos, el mayor es 15
Para llegar a este resultado se debe realizar varias comparaciones como las siguientes. Las
preguntas son condiciones simples, esto es, que solo puede comparar dos datos a la vez.
¿5>8?
No
¿8>3?
Si
¿8>15?
No
Mayor 15
Con esto anotación se continua con la solución

Modelo mental con nombres de variables y especificación de acciones
Variables a,b,c,d
a b c d // entrada
Datos 5 8 3 15
a b
¿ 5 > 8 ? // decisión
No
b c
¿ 8 > 3 ? // decisión
Si
b d
¿8>15? // decisión
No
d
Mayor 15 // salida
a b c d // entrada
Datos
a b
¿ > ? // decisión
Si
¿a>c?
Si
No
No
b c
¿ 8 > 3 ? // decisión
Si
b d
¿8>15? // decisión
No
d
Mayor 15 // salida
Determinar valores para variable

Los valores 5 8 3 15 son por entrada
La acción asociada es
Leer a,b,c,d
Esto es lo que se hace mentalmente para un caso específico, pero cuando hay decisiones, se
deben evaluar todas las posibilidades.
Al igual que el ejercicio anterior, el modelo mental me da un camino, pero deja planteado otros
caminos que hay que completar, teniendo en cuenta que toda acción de decisión tiene verdadero
y falso. Aquí se dejan planteado tres preguntas y las tres deben completarse, teniendo en cuenta
que al contestarlas pueden aparecer otras preguntas.
La dinámica de las decisiones anidadas exige que por cada camino que se vaya se debe tener en
cuenta la historia, para no repetir preguntas que van a ser innecesarias
Algoritmo
Seudocódigo
Inicio
Leer a,b,c,d
Si (a>b) Entonces
Si (a>c) Entonces
Si (a>d) Entonces
Escribir " Mayor ",a
SiNo
Escribir " Mayor ",d
FinSi
SiNo
si (c>d) Entonces
Escribir " Mayor ",c
SiNo
FinSi
FinSi
SiNo
Si (b>c) Entonces
Si (b>d) Entonces
Escribir " Mayor ",b
SiNo
FinSi
SiNo
si (c>d) Entonces
Escribir " Mayor ",c
SiNo
FinSi
FinSi
FinSi
Fin
#include <iostream>
int main() {
int a,b,c,d;
//Entrada de datos
cin>>a;
cin>>b;
cin>>c;
cin>>d;
if (a>b)
if (a>c)
if (a>d)
cout<< " Mayor "<<a;
else
cout<< " Mayor "<<d;
else
if (c>d)
cout<< " Mayor " <<c;
else
cout<< " Mayor "<<d;
else
if (b>c)
if (b>d)
cout<< " Mayor "<<b;
else
cout<<" Mayor "<<d;
else
if (c>d)
cout<< " Mayor "<<c;
else
cout<<” Mayor “<<d;
return 0;
}
Realizar un algoritmo donde se tienen tres valores numéricos, mostrarlos en orden ascendente (de
menor a mayor). Utilizar solo decisiones con condiciones simples.
Ejemplo mental solución
Valores
7 9 2
Resultado
2 7 9
Esto demuestra que se tiene claro que es lo que se pide con un solo caso. Según los números que
entren, puede haber muchas posibilidades
Ahora se determina como la mente llega a este resultado.

Para establecer un orden, necesariamente se deben comparar valores, pero estas deben hacerse
con condiciones simples, es decir comparando de dos en dos, lo cual va a dar como resultado,
decisiones anidadas, lo que implica que se debe tener bien claro la historia de las decisiones
anteriores.
Datos de entrada 7 9 2
Como se llega a 2 7 9
Un camino
¿7<9?
Si // indica que es 7 está antes que el 9, ahora se va a compara el 9 con el 2
¿9<2?
No // 2 está antes que el 9, pero no se sabe si el 2 está antes del 7 se debe comparar con este
¿2<7?
Si // por historia ya se tiene la salida para este
Salida 2 7 9
Esto es lo que realmente hace la mente con este caso específico
Identificación de variables
a b c
Datos 7 9 2 // entrada
a b
¿7 < 9? // decisión
Si // indica que es 7 está antes que el 9, ahora se va a compara el 9 con el 2
b c
¿9 < 2?
No // 2 está antes que el 9, pero no se sabe si el 2 está antes del 7 se debe comparar con este
c a
¿2 < 7?
c a b
Salida 2 7 9
Dejando solo variable se tiene
¿a < b?
Si // indica que es a está antes que el b, ahora se va a compara el b con el c
¿b < c?
Si salida a, b, c
No // c está antes que el b, pero no se sabe si c está antes que a se los debe comparar
¿c < a?
Salida c a b
No
Salida a c b
Al dejar solo variables el ejercicio se generaliza y lo que se debe hacer ahora es, completar los
caminos de Si y No de cada condición o pregunta que no ha sido tratado con el modelo mental.
El ejercicio se complementa con diagrama y seudocódigo
Seudocódigo
inicio
Leer a,b,c
Si (a<b) Entonces
Si (b<c) Entonces
Escribir ' ',a, " ", b, " ", c
SiNo
Si (c<a ) Entonces
Escribir ' ',c, " ", a, " ", b
SiNo
Escribir ' ',a, " ", c, " ", b
FinSi
FinSi
SiNo
Si (a<c) Entonces
Escribir ' ',b, " ", a, " ", c
SiNo
si (c<b) Entonces
Escribir ' ',c, " ", b, " ", a
SiNo
Escribir ' ',b, " ", c, " ", a
FinSi
FinSi
FinSi
Fin
#include <iostream>
int main( ) {
int a,b,c;
cout<< " Digitar valor 1 -> ";
cin >>a;
cout <<" \n Digitar valor 2 -> ";
cin>>b;
cout <<" \n Digitar valor 2 -> ";
cin>>c;
if (a<b)
if (b<c)
cout<<a<<" "<<b<<" "<<c;
else
if (c<a)
cout<<c<<" "<<a<<" "<<b;
else
cout<<a<<" "<<c<<" "<<b;
else
if (a<c)
cout<<b<<" "<<a<<" "<<c;
else
if (c<b)
cout<<c<<" "<<b<<" "<<a;
else
cout<<b<<" "<<c<<" "<<a;
return 0;
}
Completar las decisiones faltantes, se logra llevando la dinámica de cada una de éstas, que lo
obliga a tener en cuenta las acciones de verdadero o falso faltantes, para lo cual se debe tener
muy en cuenta la historia de ese momento.
Realizar un algoritmo que permita calcular el sueldo de dos empleados que tiene:
Numero de horas trabajas, valor de la hora y se realiza un descuento así:
Si el sueldo total es mayor que 200.000 se hace un descuento del 10% y si es menor o igual
200.000 el 5%
Ejemplo
Empleado 1
Numero de horas 15
Valor hora 20000
Empleado 2
Numero de horas 10
Valor hora 15000
Sueldo total empleado 1 15*20000 = 300000

Descuento
Descuento ¿300000>200000?
Si
Descuento 300000*10/100=30000
Sueldo Neto = 300000-30000=270000
Resultado. Sueldo empleado 1 = 270000
Sueldo total empleado 2 10*15000 = 150000

Descuento ¿150000>200000?
No
Descuento 150000*5/100 = 7500
Sueldo Neto = 150000-7500 = 142500
Resultado. Sueldo Empleado 2 = 142500
Determinación de variables y nombres y de donde viene su valor por entrada o por asignación.
Empleado 1
NH1 // entrada
Número de horas 15
VH1 // entrada
Valor hora 20000
Empleado 2
NH2 // entrada
Número de horas 10
VH2 // entrada
Valor hora 15000
Descuento
NH1 VH1 ST1 // asignación
Sueldo total empleado 1 15 * 20000 = 300000
ST1
Descuento ¿300000>200000? // decisión
Si
ST1 DES1 // asignación
Descuento 300000*10/100=30000
ST1 DES1 SN1 // asignación

Sueldo Neto = 300000-30000 = 270000
SN1
“Sueldo empleado 1 =”, 270000 // salida
NH2 VH2 ST2 //asignación
Sueldo total empleado 2 10 * 15000 = 150000
ST2
Descuento ¿150000>200000? // decisión
No
ST2 DES2 // asignación
Descuento 150000*5/100 = 7500
ST2 DES2 SN2 // asignación

Sueldo Neto = 150000 - 7500 = 142500
SN2
“Sueldo Empleado 2 =”, 142500 // salida
El modelo mental anterior, describe en la parte superior las variables, aquellos valores que no
tienen nombres son constantes, las cuales son:
200000 que es el valor base para el descuento

10/100 que es el 10% de descuento
5/100 que es el 5% del descuento
Estos valores son constantes así lo determina la definición del problema.
Por entrada son

NH1, VH1, NH2, VH2
Por Asignación
ST1, ST2,DES1,DES2,SN1,SN2
El ejercicio anterior muestra con los comentarios (// comentario ) la acción especifica a realizar.
Las acciones a realizar ya no deben involucrar valores excepto las constantes (200000, 0,1 y 0,05)
El orden de las acciones de arriba hacia a bajo da un orden lógico y se puede construir el
algoritmo.
Construcción del algoritmo
Seudocódigo
Inicio
Leer NH1
Leer VH1
Leer NH2
Leer VH2
ST1 <- NH1*VH1
SI (ST1>200000)
Entonces // si es verdadero descuento del 10%
DES1 <- ST1*10/100
Sino // Es falso descuento del 5%
DES1 <- ST1*5/100
Fin si
SN1 <- ST1-DES1
Escribir “Sueldo empleado 1 = “, SN1
ST2 <- NH2*VH2
SI (ST2>200000)
Entonces // si es verdadero descuento del 10%
DES2 <- ST2*10/100
Sino // Es falso descuento del 5%
DES2 <- ST2*5/100
Fin si
SN2 <- ST2-DES2

Escribir “Sueldo empleado 1 = “, SN2
Fin
#include <iostream>
int main(){
int nh1,vh1,nh2,vh2;
float des1,des2,sn1,sn2;
cout <<”Numero de horas empleado 1 -> ”;

cin>>nh1;
cout <<”Valor hora empleado 1 -> ”;
cin>>vh1;
cout <<”Numero de horas empleado 2 -> ”;
cin>>nh2;
cout <<”Valor hora empleado 2 -> ”;
cin>>vh2;
st1=nh1*vh1;
if (st1>200000)
des1=st1*10/100;
else
des1=st1*5/100;
sn1=st1-des1;
cout <<”Sueldo empleado 1 = “<<sn1;
St2=nh2*vh2;
if (st2>200000)
des2=st2*10/100;
else
des2=st2*5/100;
Sn2=st2-des2;
cout <<”Sueldo empleado 2 = “<<sn2;
return 0;
}
Ejercicio planteado
Realizar un algoritmo donde se tienen 3 valores numéricos correspondientes a tres lados de un
triángulo, determinar que tipo de triángulo es de acuerdo a sus lados.
Operador Residuo – modulo – mod - %
Operador residuo ( mod o % ). Este operador es un operador aritmético que entrega el residuo de
una división
Ejemplo
7 mod 2 = 1 // entrega el residuo de la división

8 mod 2 = 0
23 mod 5 = 3
25 mod 5 = 0
7 % 2 = 1 // entrega el residuo de la división

8%2=0
23 % 5 = 3
25 % 5 = 0
Porque 7 / 2 = 3 y el residuo es 1
En una división hay
Dividendo que es 7
Divisor que es 2
Cociente que es 3
Residuo que es 1
Si se tiene 7 mod 2 hace referencia al residuo, o sea 1
Este operador es muy útil dentro de la programación y sirve para especificar si un número dado es
múltiplo de otro.
Normalmente si queremos saber si 21 es múltiplo de 3

Se divide 21/3 = 7 y el residuo es 0
Con mod o % se tendría
21 mod 3 = 0
21 % 3 = 0
Y en una decisión sería lo siguiente:
If ( 21 % 3 == 0) con variable sería if (nro % 3 == 0)
En toda división si el residuo es cero y el cociente es mayor o igual que 1 se dice que el divisor es
múltiplo del dividendo.
Entonces en el ejemplo 21 es múltiplo de 3 porque el residuo es 0 y el cociente es mayor o igual

que 1.
Directamente se puede plantear lo siguiente:
Determinar si un número dado es par o es impar.
Concepto
Un número es par si y solo si es múltiplo de 2 de lo contrario es impar
Ejemplo
Para este ejemplo se hace uso del operador residuo así:
7 dividido entre 2 da 3 y residuo es 1 . El operador residuo me da el valor de 1, entonces el modelo

mental cambia
Modelo mental
Número dado 7
¿7 es par?
1
¿7 % 2 = 0?
No
7 es impar
0
¿8 % 2 = 0?
Si
8 es par
Nombres de variables, constantes y acciones para valores

NRO
Numero dado 7 // Entrada
NRO
¿7 % 2 = 0? // Decisión
No
NRO
7 es impar // Salida
Algoritmo
Inicio
Leer NRO
Si (NRO mod 2 = 0)
Entonces
Escribir NRO, “ Es par “
Sino
Escribir NRO, “ Es impar “
Fin si
Fin
#include <iostream>
int main(){
int nro;
cout <<”Digitar Numero -> ”;

cin>>nro;
if (nro % 2 == 0)
cout <<nro<<” Es numero par “;
else
cout <<nro<<” Es numero impar “;
return 0;
El anterior ejercicio tiene la estructura para determinar si un número es múltiplo de un valor
Para múltiplos de 5
Inicio
Leer NRO
Si ( NRO mod 5 = 0)
Entonces
Escribir NRO, “ Es múltiplo de 5 “
Sino
Escribir NRO, “ no es múltiplo de 5 “
Fin si
Fin
#include <iostream>
int main(){
int nro;
cout <<”Digitar Numero -> ”;

cin>>nro;
if (nro % 5 == 0)
cout <<nro<<” Es multiplo de 5 “;
else
cout <<nro<<” no es múltiplo de 5 “;
return 0;
Ejercicio
Se leen dos números, determinar si un número es múltiplo de otro se tiene el siguiente algoritmo.
Este ejercicio es la generalización de los dos anteriores
Inicio
Leer NRO1,NRO2
Si ( NRO1 mod NRO2 = 0)
Entonces
Escribir NRO1, " MULTIPLO DE ",NRO2
Sino
Escribir NRO1, " NO ES MULTIPLO DE ",NRO2
Fin si
Fin
Programa en C++
#include <iostream>
int main(){
int nro1,nro2;
cout <<”Digitar primer numero -> ”;

cin>>nro1;
cout <<”Digitar segundo numero -> ”;

cin>>nro1;
if (nro1 % nro2 == 0)
cout <<nro1<<” Es multiplo de “<<nro2;
else
cout <<nro1<<” no es múltiplo de <<nro2 “;
return 0;
Introducción a contadores y acumuladores
Los siguientes ejercicios permiten analizar donde se presenta un contador y un acumulador, para
llegar a definirlas a partir de su funcionamiento identificado en el análisis.
Se tienen 4 valores numéricos, determinar la cantidad números pares.
Modelo mental
Valores dados 6 7 8 10
Respuesta Cantidad de pares 3
Esto demuestra que si se entiende lo que nos piden. Pero este modelo no representa todo lo que
mente hace, para determinar estos pasos se adiciona una nueva regla.
Trabajar con un dato a la vez y mirar que hace la mente y el dato se lo toma de izquierda a
derecha.
Primero con el 6
Pregunta si el 6 es par, si es par, lo cuenta en la mente ( va 1)
Segundo con el 7
Pregunta si el 7 es par, no es par, no hace nada
Tercero con el 8
Pregunta si el 8 es par, si lo es, por lo tanto lo cuenta en la mente (van 2)
Cuarto con el 10
Pregunta si el 10 es par, si lo es, por lo tanto lo cuenta en la mente(van 3)
Como ya no hay mas datos muestra el resultado
Resultado cantidad de pares 3
Que es lo que había almacenado en la mente a medida que llegaban los números pares, y su
variación durante el ejercicio fue 1, 2 y 3
Es importante entender de donde sale el 3, el cual representa la cantidad de pares que se fue
incrementando cada vez que se encontraba un par
Un modelo mental mas claro es el siguiente
Se debe establecer que es lo que hace con un dato a la vez
Valores dados 6 7 8 10
¿6 es par?
Si
Va 1 = 0 +1
7 es par?
No
8 es par?
Si
Van 2 = 1+1
10 es par?
Si
Van 3 = 2+1
Este modelo mental ya es más claro y sobre este se sigue el proceso para construir el modelo
computacional
Agregar nombres a las variables y determinar acciones
A B C D
Valores 6 7 8 10 // Entrada
A
¿6 es par? // Decisión
Si
CP
Va 1 // Asignación
B
7 es par? // Decisión
No
C
Si
CP // Asignación
Van 2
D
Si
CP // Asignación
Van 3
CP
Después de colocar los nombres a las variables se tiene la variable CP es la que lleva la cuenta de
los pares, en donde su variación no es explicita, pero su funcionamiento si lo es, porque cada vez
que identifica un numero par se incrementa en 1.
Obtener la variación de CP
Para obtener la variación de CP se tiene en cuenta dos variaciones consecutivas en el modelo

mental y se obtiene el patrón de variación.
Tomamos la variación de 2 a 3
El 3 va a ser el resultado de 2 mas 1
32 + 1
Con los nombres de variables se encuentra que el 3 es CP, el 2 también es CP pero en el tiempo
anterior, y el 1 es una constante que indica en que valor cambio CP. Entonces colocando los
nombres se tiene
CP = CP + 1
3  2 + 1
Entonces el patrón de variación de CP es:
CP  CP +1
Esta variación debe cumplirse en todos los momentos, por lo que en el primer momento cuando
CP vale 1 se tendría
CP  CP + 1
1  0 +1
3 1 7 1
Por lo que CP antes de iniciar el proceso de averiguación tiene que valer 0

Dentro de la lógica, indica que antes de que se llegue a evaluar los números, la cuenta de números
pares vale 0.
Esto demuestra que todas las acciones se encuentran en la mente, solo hay que profundizar en
ella para obtenerlas.
Para las preguntas que se realizan para averiguar si un número es par, se utiliza el operador
residuo ( % ) de tal forma que la pregunta
A
¿6 es par?
Se transforma en la condición
A
¿6 % 2 = 0?
¿A % 2 = 0 ?
El modelo mental con estas anotaciones queda:
A B C D
Valores 6 7 8 10 // Entrada
CP
0
A
¿6 % 2 = 0? // Decisión
Si
CP  CP +1
Va 1  0 + 1 // Asignación
B
7 % 2 = 0? // Decisión
No
C
8 % 2 = 0? // Decisión
CP  CP +1 // Asignación
Van 2  1 + 1
D
10 % 2 = 0? // Decisión
Si
CP  CP +1 // Asignación
Van 3  2 + 1
CP
Respuesta “Cantidad de pares”, 3
Seudocódigo
Inicio
Leer A,B,C,D
CP <- 0
Si ( A mod 2 = 0)
Entonces
CP <- CP +1
Fin si
Si ( B mod 2 = 0)
Entonces
CP <- CP +1
Fin si
Si ( C mod 2 = 0)
Entonces
CP <- CP +1
Fin si
Si ( D mod 2 = 0)
Entonces
CP <- CP +1
Fin si
Escribir “Cantidad de pares “, CP
Fin
#include <iostream>
int main(){
int a,b,c,d,cp;

cin>>a;

cin>>b;
cout <<”Digitar tercer numero -> ”;
cin>>c;
cout <<”Digitar cuarto numero -> ”;

cin>>d;
cp=0;
if (a%2==0)
cp=cp+1;
if (b%2==0)
cp=cp+1;
if (c%2==0)
cp=cp+1;
if (d%2==0)
cp=cp+1;
cout<<”Cantidad de pares “<<cp;
return 0;
}
Realizar un algoritmo donde se tienen 4 valores numéricos, que determine la suma de los pares y
los impares
Modelo mental
Valores 5 7 4 9
Suma de impares 5+7+9 = 21

Suma de pares 4
Resutado suma impares = 21

Suma pares = 4
Este es el primer modelo solución del problema que se presenta, y demuestra que si cumple con el
objetivo. Pero no es un modelo computacional.
Para esto se retoma la regla de un dato a la vez.

Entonces el modelo solución es el siguiente:
A B C D //entrada
Valores 5 7 4 9
SUI=0
SUP=0
A
¿5 es par? //decisión
Si
SUP=SUP+A
No // entonces es impar
SUI = SUI +A
5 = 0 + 5
B
¿7 es par?
No
SUI = SUI + B
12 = 5 + 7
C
¿4 es par?
Si
SUP = SUP + C
4 = 0 +4
D
¿9 es par?
No
SUI = SUI + D
21 = 12 +9
Respuesta
Suma de Impares = 21
Suma de pares = 4
Mentalmente se toma cada valor y por cada valor se toma decisiones por pares y por impares, y
en la memoria según la condición, se van llevando dos sumas una para los impares y otra para los
pares, para llegar al 21 y el 4 respectivamente.
Modelo mental con nombres de variables
A B C D
Valores 5 7 4 9 // entrada
SUI
0
SUP
0
A
¿5 es par? // decisión
No
SUI // asignación
5 <- 0 +5
B
No
SUI // asignación
12
C
Si
SUP // asignación
4
D
No
SUI <- SUI + D // asignación
21 <- 12 + 9
Respuesta
SUI // salida
SUP // salida
Suma de pares = 4
Definición de variables
A, B, C, D : Campos numéricos que reciben los cuatro valores.

SUI : Campo numérico que lleva la suma de Impares
SUP : Campo numérico que lleva la suma de pares
Los valores de SUI y SUP están definidos por una acción de asignación y en el modelo no es clara
su variación, pero si se sabe que llevan sumas mentalmente. Del modelo mental salen las
variaciones de cada variable.
Para SUI. Se toma el valor 21 y se determina de donde sale. 21 es el resultado de sumar 12 y 9
21  12 + 9
En donde 12 es SUI y 9 es D entonces queda
SUI  SUI + D
21  12 + 9
El hecho de que SUI aparezca en el lado derecho y en el lado izquierdo, hace que se vayan
acumulando los valores y se lo interpreta asi:
El valor actual, es, lo que tenía antes más un valor variable.
Es importante anotar que pasa con el primer valor que se suma en los impares que es 5 y que
corresponde al valor A. Debe cumplirse lo mismo que se definió como variación para SUI, es decir
SUI  SUI + A
5  0 + 5
Esto determina que SUI inicialmente debe tener un valor de 0,
Es decir
SUI  0
Y lo mismo para SUP. Se toma el valor de 4 correspondiente a C y se determina que los valores que
definen el según la variación anterior sería:
SUP  SUP + C
4 0 +4
Entonces SUP debe iniciar en 0
Según esto SUI y SUP deben iniciar en 0 antes de comenzar a evaluar las condiciones de si es par o
es impar
Dentro de la lógica tiene razón, que tanto SUI como SUP inicien en 0, antes de iniciar a evaluar los
números, porque si ningún número es impar SUI debe ser 0 y de igual forma con los pares.
Entonces el modelo mental se lo determina de la siguiente forma:
A B C D
Valores 5 7 4 9 // entrada
SUI
0
SUP
0
A
No
SUI <- SUI + A // asignación
5 <- 0 + 5
B
No
SUI <- SUI + B // asignación
12 <- 5 + 7
C
Si
SUP <- SUP + C // asignación
4 <- 0 + 4
D
No
SUI <- SUI + D // asignación
21 <- 12 + 9
Respuesta
SUI // salida
SUP // salida
Suma de pares = 4
Instrucción de decisión
Las condiciones de las decisiones que mentalmente se las trabaja como:
¿A es par?
Computacionalmente se convierte en
¿A mod 2 = 0?
Y como es una pregunta entonces hay una decisión y A puede ser Par o Impar, por lo que la
decisión genérica con su verdadero (Entonces) y falso (sino ) queda:
Si ( A % 2= 0)
Entonces
SUP  SUP + A
Sino
SUI  SUI + A
Fin si
Lo mismo debe ocurrir para B, C Y D
Algoritmo Resultante:
Seudocódigo
Inicio
Leer A,B, C, D
SUI <- 0
SUP <- 0
Si ( A mod 2= 0)
Entonces
SUP <- SUP + A
Sino
SUI <- SUI + A
Fin si
Si ( B mod 2= 0)
Entonces
SUP <- SUP + B
Sino
SUI <- SUI + B
Fin si
Si ( C mod 2= 0)
Entonces
SUP <- SUP + C
Sino
SUI <- SUI + C
Fin si
Si ( D mod 2= 0)
Entonces
SUP <- SUP + D
Sino
SUI <- SUI + D
Fin si
Escribir “ Suma Impares = “, SUI
Escribir “ Suma pares = “, SUP
Fin
#include <iostream>
int main(){
int a,b,c,d,sp,si;

cin>>a;

cin>>b;
cout <<”Digitar tercer numero -> ”;

cin>>c;
cout <<”Digitar cuarto numero -> ”;

cin>>d;
sp=0;
si=0;
if (a%2==0)
sp=sp+a;
else
si=si+a;
if (b%2==0)
sp=sp+b;
else
si=si+b;
if (c%2==0)
sp=sp+c;
else
si=si+c;
if (d%2==0)
sp=sp+d;
else
si=si+d;
cout<<”Suma de pares “<<sp;

cout<<”Suma de impares “<<si;
return 0;
}
En los dos ejercicios anteriores se encontraron las variables CP, SUI Y SUP las cuales realizaban lo
siguiente
CP Contador de pares
SUI Sumador de Impares
SUP Sumador de Pares
Cuyas variaciones fueron las siguientes
CP  CP + 1
SUI  SUI + Variable
SUP  SUP + Variable
En donde las variaciones de CP representan la secuencia 1 2 y 3, es decir un contador de 1 en 1

Y SUI y SUP van llevando sumas de varios valores.
Para SUI según el ejemplo tuvo las variaciones
5 12 21
Para SUP
4
Estos dos tipos de variables según su variación se convierten en contador (CP ) y sumador (SUI y
SUP), muy utilizadas dentro de la computación, las cuales se definen de la siguiente forma:
Variable Contador
Es una variable cuya variación permite generar secuencias de valores con variaciones constantes.
Estas secuencias generan números como:
1 2 3 4 5 6...
2 4 6 8 ...
20 18 16 14 . . .
Que en términos prácticos, son contadores.
Formato general
VariableContador  VariableContador + o – constante
VariableContador = VariableContador + o – constante;
cp=cp+1;
Ejemplo
CP  CP + 1
CP = CP + 1;
En el ejemplo CP llevó la cuenta de los números pares
C5  C5 + 5
C5 = C5 + 5
Esta acción puede generar una secuencia de 5 en 5
5 10 15 20 25
CON  CON - 3
CON = CON - 3
Puede generar secuencias como
30 27 24 21 . . .
Las variaciones pueden generar secuencia de 1 en 1 para CP, iniciando desde 0, de 5 en 5 para C5,
iniciando desde 0 y para CON una secuencia con variación de -3 iniciando desde 30.
Variable Sumador o acumulador
Es un campo de memoria cuya variación permite llevar una suma de varios valores durante la
ejecución de un programa.
Formato
VariableSumador  VariableSumador + Variable

VariableSumador = VariableSumador + Variable
Ejemplo
SUI  SUI + Variable

SUP  SUP + Variable
SUI = SUI + Variable

SUP = SUP + Variable
PR=PR*variable
Para el ejemplo planteado se tiene que SUI lleva la suma de todos los valores impares y SUP la
suma de todos los valores pares
Este tipo de variable es muy utilizado dentro de la computación, sobre todo en aquellos
problemas que exigen totales.
Tanto la variable contador como sumador deben tener un valor inicial el cual generalmente
pueden ser 0 como en los ejercicios planteados, pero pueden haber situaciones donde un
contador puede iniciar en otro valor y decrementarse.
Ejemplo
Esta acción permitiría decrementarse de dos en dos

CON  CON – 2
CON = CON – 2
Pero debe indicarse el inicio. Ejemplo
CON  22
CON entonces podría tener los valores de
22 20 18 16 . . .
Estos dos tipos de variables según su funcionamiento son muy utilizados en computación y es muy
importante conocer su manejo.
Se tienen 4 valores numéricos determinar la cantidad números pares, utilizando para la entrada
de datos un solo campo.
Este ejercicio se lo planteó y se lo desarrollo en ele ejercicio 8, donde se tenían los cuatro datos en
la memoria, en las variables A, B, C, D y su solución se hizo de la siguiente forma:
Inicio
Leer A,B,C,D
CP  0
Si ( A mod 2 = 0)
Entonces
CP  CP +1
Fin si
Si ( B mod 2 = 0)
Entonces
CP  CP +1
Fin si
Si ( C mod 2 = 0)
Entonces
CP  CP +1
Fin si
Si ( D mod 2 = 0)
Entonces
CP  CP +1
Fin si

Fin
La solución del ejercicio anterior, exige que los datos se almacenen en los campos A, B, C, D, ahora
solo se va a tener un campo para la entrada.
Ejemplo
Valores 6 7 8 10
Resultado cantidad de pares = 3
El modelo mental es igual al anterior, pero, teniendo en cuenta que los datos van a entrar uno a
uno, no los cuatro a la vez, por lo tanto, el modelo mental general es el siguiente:
Datos de entrada 6, 7, 8, 10
Estos datos van a entrar a un solo campo que se va a denominar NUM, según esto el modelo
queda
NUM // entrada
Valor 6
NUM
¿6 es par? // Decisión
Si
CP
Va 1 // Asignación
NUM // entrada
Valor 7
NUM
No
NUM // entrada
Valor 8
NUM
CP // Asignación
Van 2
NUM // entrada
Valor 10
NUM
Si
CP // Asignación
Van 3
El valor se va a leer en el campo con el nombre NUM.
El algoritmo resultante es:
Inicio
CP <- 0
Leer NUM
Si ( NUM mod 2 = 0)
Entonces
CP <- CP +1
Fin si
Leer NUM
Si ( NUM mod 2 = 0)
Entonces
CP <- CP +1
Fin si
Leer NUM
Si ( NUM mod 2 = 0)
Entonces
CP <- CP +1
Fin si
Leer NUM
Si ( NUM mod 2 = 0)
Entonces
CP <- CP +1
Fin si

Fin
Programa en lenguaje C.
#include <iostream>
int main(){
int a,b,c,d,cp,num;
cp=0;
cout <<”Digitar numero -> ”;

cin>>num;
if (num%2==0)
cp=cp+1;

cin>>num;
if (num%2==0)
cp=cp+1;

cin>>num;
if (num%2==0)
cp=cp+1;

cin>>num;
if (num%2==0)
cp=cp+1;
cout <<”Cantidad de pares <<cp;
return 0;
}
Del ejercicio anterior se puede observar lo siguiente:

El bloque es el mismo para los cuatro números
Leer NUM
Si ( NUM mod 2 = 0)
Entonces
CP  CP +1
Fin si

cin>>num;
if (num%2==0)
cp=cp+1;
Este bloque de instrucciones se repite cuatro veces
Cuando se tiene un solo campo para la entrada, el dato que entra remplaza al anterior, lo cual
indica que solo se va a tener un dato a la vez. No hay historia de los anteriores.
El utilizar un solo campo para la entrada de datos, abre el espacio para procesar gran cantidad de
valores como en este caso.
En el ejercicio planteado se podría trabajar cualquier cantidad de números sin necesidad de crear
varios campos de memoria, por ejemplo 100 números, lo que implicaría tener 100 bloques de
instrucciones como el anterior, aspecto que no es recomendable. Para evitar esto, en la
programación existe las instrucciones de repetición, que permiten controlar las veces en que se
puede repetir un bloque de instrucciones como el anterior, aspecto que se va a mirar a
continuación.
Instrucciones de repetición o ciclo
Permiten repetir un conjunto de acciones un número condicionado de veces, donde la condición

es la que va a determinar las veces que se deben repetir las acciones. La condición es una
expresión lógica que va a tener como resultado verdadero o falso, en donde las acciones a repetir
se van a ejecutar siempre que la condición sea verdadera y van a dejar de ejecutarse si la
condición es falsa. La forma como se maneje la condición determina los tipos de ciclos existentes.
La utilización de los ciclos en la programación son de gran utilidad, ya que van a permitir procesar
grandes cantidades de datos utilizando un solo grupo de acciones que se van repetir varias veces,
dependiendo estas de una condición de control.
Mentalmente la acción de ciclo no está implementado, pero, si se puede obtener los elementos
necesarios para implementar un ciclo, lo que debemos conocer es que elementos se deben buscar
en el ejemplo. Para poder identificar elementos, debemos conocer los tipos diferentes de ciclos y
sus elementos.
Tipos de Ciclos
Ciclo Mientras
Ciclo Para
Ciclo hacer Mientras
Ciclo while
Ciclo for
Ciclo do – while
Ciclo Mientras: Ejecuta un conjunto de instrucciones en forma repetitiva, mientras una condición
sea verdadera.
Formato
Seudocódigo
Mientras ( condición ) hacer
Acciones a repetir
Fin mientras
while (condición) {
Acciones a repetir
}
do{
acciones a repetir
}while(condición);
Mientras la condición sea verdadera Hacer las siguientes acciones

Acciones a repetir
Fin mientras
Si la condición es falsa no se ejecutarán las acciones
Características
- Las acciones a repetir se van a ejecutar mientras (while) la condición sea verdadera.
- Cuando se plantea un ciclo mientras (while), lo primero que se ejecuta es la evaluación de la
condición. Esto indica que si la condición es falsa la primera vez, las acciones a repetir no se
ejecutarían ni una sola vez, ya que saltaría el control a las instrucciones después del fin
mientras.
- Dentro de las instrucciones debe haber una acción o acciones que permitan que la condición
que controla el ciclo se vuelva falsa, de lo contrario el ciclo se vuelve infinito porque siempre
sería verdadero.
- Siempre que se alcance el Fin Mientras ( } ) el control de ejecución, regresa a evaluar la
condición, si es verdadera continua dentro del ciclo, pero si es falso el control de ejecución
salta a la instrucción siguiente al fin mientras.
- En el diagrama del PseInt no se encuentra fin mientras, este se presenta cuando la condición
es falsa, entonces el flujo continúa como lo especifica el diagrama.
Cómo se establece la condición que controla un ciclo.
Ejercicio ciclo 1
Se tienen 4 valores numéricos determinar la cantidad números pares. Realizarlo con ciclo.
Retomamos el ejercicio anterior y sobre este se analiza la condición que va a controlar el ciclo.
Para poder realizar este ejercicio, se necesita que los datos entren uno a la vez, por lo que se
utiliza una sola variable.
El siguiente algoritmo muestra esta característica. En donde se puede apreciar que un bloque de
acciones se repite 4 veces
Inicio
CP  0
Leer NUM // primer dato
Si ( NUM mod 2 = 0)
Entonces
CP  CP +1
Fin si
Leer NUM // segundo dato

Si ( NUM mod 2 = 0)
Entonces
CP  CP +1
Fin si
Leer NUM // tercer dato

Si ( NUM mod 2 = 0)
Entonces
CP  CP +1
Fin si
Leer NUM // cuarto dato

Si ( NUM mod 2 = 0)
Entonces
CP  CP +1
Fin si

Fin
Este es el algoritmo sin ciclo, con ciclo se tendría algo parecido a lo siguiente:
Inicio
CP  0
Repetir 4 veces
Leer NUM
Si ( NUM mod 2 = 0)
Entonces
CP  CP +1
Fin si

Fin
Pero Repetir 4 veces no es una acción valida dentro de la computación, para eso se necesita
aplicar una instrucción ciclo, como mientras.
Elemento a buscar en el modelo mental para implementar un ciclo mientras
- El ciclo mientras tiene los siguientes elementos

Condición de control
Bloque de instrucciones a repetir
Incluir acciones para que el ciclo no se vuelva infinito
- Para esto se tiene en cuenta, que cada vez que la definición del problema plantea que se
tienen cierta cantidad de datos, normalmente se utiliza un contador que controla la cantidad
de esos datos, y este contador se lo utiliza para controlar el ciclo.
- Generalmente la definición del problema plantea la posibilidad de utilizar ciclos.
Para el ejemplo se están planteando 4 datos numéricos por lo que la mente espera recibir
únicamente 4 datos y trabajarlos como se planteó, uno a la vez
Modelo mental
Datos de entrada
4 6 9 8
Estos datos entran uno a uno hasta completar y la mente controla está entrada, es decir, no va a
permitir que entre un quinto dato.
El siguiente modelo muestra un comportamiento de los cuatro tiempos y las acciones mentales
que se hacen en cada uno.
cd=0 0<4? 2<=4? 3<=4? 4<=4?

1cd=cd+1 2cd 3cd 4cd
4 num 6 9 8
4 es par? 6 es par? 9 es par? 8 es par?

Si Si No Si
1 cp 2 3
2 cd=cd+1
En la mente se presenta como está especificado aquí, en donde aparece una secuencia de 1 hasta
4, in
dicando que son solo 4 datos los que van a ser procesados
Colocar nombres y acciones que la soportan, del modelo queda:
Asignación Asignación Asignación Asignación

CD CD CD CD
1 2 3 4
Entrada Entrada Entrada Entrada
Num Num Num Num
4 6 9 8
Decisión Decisión Decisión Decisión

Num Num Num Num
Si Si No Si
Asignación Asignación Asignación
CP CP CP
1 2 3
CP
Cantidad de pares = 3 // Salida
Donde se obtienen las siguientes variables
CD :contador de números que entran

CP :contador de números pares
Num :Variable que recibe los datos a procesar
CD está soportado en la memoria, por que la definición indica cuatro datos que van a llegar, y cada
vez que llega uno a la mente, esta lo cuenta. Si no ha llegado ninguno la mente no lo cuenta y la
cuenta ira en 0. Según lo anterior, entonces CD toma los valores de 0 1 2 3 4, el 5 no porque solo
indica 4 valores
En programación se tiene que las acciones de asignación para CD Y CP corresponden a dos

contadores, ambos de 1 en 1 y generan en su variación secuencias con variaciones constantes.
Estas son:
CD  CD +1
CP  CP + 1
Se debe considerar aquí, que al ser contadores deben tener un inicio, en este caso son en 0 (cero )
Entonces
CD  0
CP  0
Y deben ir antes de empezar a leer los datos.
El modelo mental mas completo es el siguiente:
CD 0 ¿CD<4? ¿CD<4? ¿CD<4? ¿CD<4?

CP 0 CD CD+1 CD CD+1 CD CD+1
CD CD+1 2 3 4
1
Leer Num Leer Num Leer Num Leer Num
4 6 9 8
Num mod 2=0? Num mod 2=0? Num mod 2=0? Num mod 2=0?
Si Si No Si
CPCP+1 CPCP+1 CPCP+1
1 2 3
CP
Cantidad de pares = 3 // Salida
El ejercicio se lo va a desarrollar con un ciclo mientras, por lo que se debe buscar en el modelo
mental los siguientes elementos
Condición de control de ciclo
Bloque de instrucciones a repetir
Acciones para que el ciclo no se vuelva infinito que deben estar dentro de las acciones a
repetir
Condición de control está fundamentada en la definición de problema que solo son 4 datos y la
variable que lleva este valor es CD por tanto la condición será:
¿CD<4?
Esta condición debe ir al inicio acompañando a la palabra mientras
Mientras ( CD < 4 ) hacer while(cd<4) {
Bloque de instrucciones a repetir esta en el modelo mental y son:
CD CD + 1
Leer NUM
Si ( NUM mod 2 = 0)
Entonces
CP  CP +1
Fin si
Donde se tiene incluida la instrucción
CD  CD + 1
que garantiza que el ciclo no se vuelva infinito
cd=0;
cp=0;
while( cd<4) {
cd=cd+1;
cout<<”Digitar numero “;
cin>>num;
if (num%2==0)
cp=cp+1;
}
Cout<<”Digite la cantidad de números”;

cin>>cn;
cd=1;
cp=0;
while( cd<=cn) {
cout<<”Digitar numero “;
cin>>num;
if (num%2==0)
cp=cp+1;
cd=cd+1;
}
Ciclo controlado por un contador
El bloque total del ciclo mientras queda:
Mientras ( CD < 4 ) hacer

CD CD + 1
Leer NUM
Si ( NUM mod 2 = 0)
Entonces
CP  CP +1
Fin si
Fin mientras
Cuando se trabaja con un ciclo se complementa indicando las condiciones iniciales antes del ciclo y
las acciones después del ciclo, que están especificadas en el modelo mental. Entonces el algoritmo
queda
Inicio
CD<- 0 // valor inicial del CD
CP<- 0 // valor inicial de CP
Mientras ( CD < 4 ) hacer
CD<- CD + 1
Leer NUM
Si ( NUM mod 2 = 0)
Entonces
CP <- CP +1
Fin si
Fin mientras
Escribir “Cantidad de pares = “,CP
Fin
#include <iostream>
int main(){
int num,cp,cd;
cp=0;
cd=0; // va a controlar la cantidad de datos
while (cd<4 ) {
cd=cd+1;
cin>>num;
if (num%2==0)
cp=cp+1;
}
cout <<”Cantidad de números pares “<<cp;
return 0;
}
Programa iniciando el contador en 1
#include <iostream>
int main(){
int num,cp,cd;
cp=0;
while (cd<=4 ) {

cin>>num;
if (num%2==0)
cp=cp+1;
cd=cd+1;
}
return 0;
}
Programa generalizando la cantidad de datos. En los ejercicios anteriores la cantidad de datos es

constante, en el siguiente programa la cantidad de datos es variable y se la define con la variable
cn, cuyo valor es digitado.
Programa en lenguajes C++
#include <iostream>
int main(){
int num,cp,cd,cn;
cout<<”Digite la cantidad de números”;

cin>>cn;
cp=0;
while (cd<=cn ) {

cin>>num;
if (num%2==0)
cp=cp+1;
cd=cd+1;
}
return 0;
}
Ciclos controlados por un contador
Un ciclo controlado por un contador hacer parte de el esquema cuantitativo para controlar un
ciclo, el contador es el resultado de una expresión aritmética.
El ejercicio anterior especifica claramente, como un ciclo puede ser controlado por un contador,
esto se presenta mucho dentro de la programación y sobre todo cuando se conoce un número
especifico de casos, como en el ejemplo, que planteaba para 4 datos.
Cuando se tiene un ciclo controlado por un contador se debe tener presente lo siguiente:
- El inicio del contador, esto depende de la descripción del problema y el análisis que se le haga
al mismo. Generalmente este contador inicia en 0 o en 1, depende del análisis que se haga.
- La variación. En el contador la variación es constante, generalmente es de 1 en 1, el cual va
aumentando hasta alcanzar el valor tope, pero, hay problemas que exige otras variaciones, en
donde pueden ser hasta negativas.
- El valor tope o valor frontera. Indica hasta donde va a llegar el contador. Esta frontera según
la definición del problema puede ser constante o variable, lo más general es que sea variable.
El ejercicio planteado es solo para un valor constante de 4, si fuera variable sería para
cualquier cantidad de datos.
Contador<=valorTope?
Ejercicio ciclo 2
Se tiene una cantidad dada de datos numéricos, determinar la cantidad de números pares que se
presentan.
Este ejercicio tiene las mismas características del que se acaba de resolver. La variación está en
que los datos ya no van a ser 4, sino, una cantidad dinámica de datos, depende de una variable, la
cual indica el valor, al cual debe llegar el contador.
Para el modelo mental lo primero que va a hacer es solicitar la cantidad de datos que se van a
procesar y este va a ser el limite.
Ejemplo
Cantidad de datos 6
Datos que van a entrar 10, 7, 8, 4, 5, 20
Respuesta cantidad de datos pares = 4
Según esto en el modelo mental hay un nuevo dato 6, el cual indica la cantidad de datos a entrar y
debe ser variable, el modelo anterior se complementa con:
CNE // entrada
Cantidad de datos 6
Y como es variable se debe leer
Leer CNE
Datos que van a entrar 10, 7, 8, 4, 5, 20

Donde CNE, sería la Cantidad de Números de Entrada
CD Y CP funcionan igual
La condición ahora del ciclo mientras sería:
CD<CNE?
CD<=CNE?
El algoritmo en seudocódigo sería el siguiente:
Inicio
Leer CNE // Entrada de la cantidad de números
CD 0 // valor inicial del CD
CP 0 // valor inicial de CP
Mientras ( CD < CNE ) hacer
CD CD + 1
Leer NUM
Si ( NUM mod 2 = 0)
Entonces
CP  CP +1
Fin si
Fin mientras
Escribir “Cantidad de pares = “,CP
Fin
#include <iostream>
int main(){
int nro,cp,cd,cne;
cout <<”Cantidad de números “;

cin >>cne; //Especifica cuantos números van a entrar
cp=0;
while (cd<cne ) {
cd=cd+1;
cin>>nro;
if (a%2==0)
cp=cp+1;
}
return 0;
}
Este programa funciona para cualquier cantidad de datos, es decir queda genérico.
Ejercicio para reforzar los conceptos de contador, acumulador y ciclo mientras controlado por un
contador.
Ejercicio ciclo 3
Se tiene una cantidad dada de datos numéricos, hallar el promedio de los números que sean
múltiplos de 5.
Modelo mental
Primer modelo mental
Cantidad de datos 6
Datos 3 10 12 20 5 15
Promedio múltiplos de 5 10+20+5+15 = 50 = 12,5

4 4
Este modelo indica que si se puede desarrollar el problema. Pero no es un modelo apropiado para
encontrar los elementos computacionales que se necesitan, ya que se está mirando todos los
datos a la vez, aspecto que no hace el modelo computacional.
El objetivo del ejercicio es llegar a 12,5 y para esto, se debe buscar el 50 que es un sumador o
acumulador y el 4 que es un contador.
Regla Trabajar un dato a la vez y determinar que es lo que hace la mente con ese dato de
acuerdo a la solución
Numero de datos 6
DATO 1 2 3 4 5 6
3 10 12 20 5 15
3 mul de 5? 10 mul de 5? 12 mul de 5? 20 mul de 5? 5 es mul de 15 mul de 5?

5?
No Si No Si Si Si
10 30 50
1 2 35 4
3
Promedio múltiplo de 5 = 50/4 = 12,25

Resultado
Promedio múltiplos de 5 = 12,25
El modelo mental anterior, es lo que realmente hace la mente en términos genéricos se lo mira
así.
La mente recibe la cantidad de datos que va a procesar

Por cada dato que va recibir realiza:
Cuenta el dato que va a recibir
Recibe el dato valido
Determina si el dato es múltiplo de 5
Si es múltiplo de cinco lo suma y lo cuenta
Después de leer los seis datos calcula el promedio con la suma y la cuenta
Muestra el promedio
Determinar variables y constante del modelo
CDN
Numero de datos 6
CN CN CN CN CN CN
1 2 3 4 5 6
NUM NUM NUM NUM NUM NUM
3 10 12 20 5 15
3 mul de 5? 10 mul de 5? 12 mul de 5? 20 mul de 5? 5 es mul de 15 mul de 5?
5?
No Si No Si Si Si
S5 S5 S5 S5
10 30 35 50
C5 C5 C5 C5
1 2 3 4
S5 C5 PROM5
Promedio múltiplo de 5 = 50 / 4 = 12,25
PROM5
“Promedio múltiplo de 5 =”, 12,5
Definición variables
CDN :Cantidad de números: entero

CN :Contador de números : entero
NUM :Númerico, recibe todos los números : entero
S5 :Sumador de Múltiplos de 5 : entero
C5 :Contador de múltiplos de 5 : entero
PROM5 : Promedio de los múltiplos de 5 : Real
Determinación de acciones
CDN // entrada
Numero de datos 6
Asignació ¿0<6? ¿1<6? Asignación Asignación Asignación Asignación
n Asignación Asignación CN CN CN CN
CN CN CN 3 4 5 6
0 1 2
Entrada Entrada Entrada Entrada Entrada Entrada
3 10 12 20 5 15
Decisión Decisión Decisión Decisión Decisión Decisión
¿3 mul de 5? ¿10 mul de 5? ¿12 mul de ¿20 mul de ¿5 es mul de ¿15 mul de 5?
5? 5? 5?
No Si Si
No Si Si
Asignació Asignación Asignación
S5 Asignación Asignación S5
n
10 S5 S5 50
S5
30 35
0
Asignació Asignación Asignación
C5 Asignación Asignación C5
n
1 C5 C5 4
C5
2 3
0
Asignación
S5 C5 PROM5
Promedio múltiplo de 5 = 50 / 4 = 12,25
Algoritmo promedio5
Definir CDN,CN,C5,S5 Como Entero
Definir PROM5 Como Real
Escribir "cantidad de datos "

leer CDN
CN<-0
C5<-0
S5<-0
Mientras ( CN < CDN ) hacer
CN<-CN+1
Leer NUM
Si ( NUM mod 5 = 0)
Entonces
S5<-S5+NUM
C5<-C5+1
Fin si
Fin mientras
PROM5 <- S5/C5
Escribir "Promedio de múltiplos de 5 = ",PROM5
FinAlgoritmo

#include <iostream>
int main(){
int cdn,cn,c5,s5,num;
float prom5;
cout <<”Cantidad de datos “;

cin >>cdn; //Especifica cuantos números van a entrar
cn=0;
c5=0;
s5=0;
while (cn<cdn ) {
cn=cn+1;
cin>>num;
if (num%5==0){
s5=s5 + num;
c5=c5+1;
}
}
prom5=(float)s5/c5;
cout <<”Promedio de múltiplos de 5 “<<prom5;
return 0;
}
Anotación importante para la división.
En computación es muy importante tener presente que la operación de división por cero es
indefinida.
Si en un programa se presenta división por cero este cancelará, por lo que se debe incluir en la
programación, instrucciones de validación de esta situación.
En el ejemplo que acabamos de especificar puede darse el hecho de que ningún dato numérico
sea múltiplo de 5, entonces según la lógica S5 y C5 quedan con el valor de cero (0) y al calcular el
promedio se presenta
PROM5  S5/C5 o sea 0 / 0 // en este caso el programa cancela
Para evitar esto se debe validar de la siguiente forma
Si ( C5 > 0 )
Entonces // Significa que por lo menos hay un múltiplo de 5
PROM5 <- S5 / C5
Escribir “ Promedio de 5 = “, PROM5
Sino
Escribir “ No hay múltiplos de 5 “
Fin si
Los algoritmos quedan:
Algoritmo Promedio5
Definir CDN,CN,C5,S5,Num Como Entero
Definir PROM5 Como Real
Escribir "cantidad de datos "

leer CDN
CN<-0
C5<-0
S5<-0
Mientras ( CN < CDN ) hacer
CN<-CN+1
Leer NUM
Si ( NUM mod 5 = 0)
Entonces
S5<-S5+NUM
C5<-C5+1
Fin si
Fin mientras
Si ( C5 > 0 )
Entonces // Significa que por lo menos hay un múltiplo de 5
PROM5 <- S5 / C5
Escribir " Promedio de 5 = ", PROM5
Sino
Escribir " No hay múltiplos de 5 "
Fin si
FinAlgoritmo
El bloque resaltado, determina la validación para evitar división por cero.

Hallar el valor promedio es muy utilizado, por lo que es importante el proceso de validación
#include <iostream>
int main(){
int cdn,cn,c5,s5,num;
float prom5;

cin >>cdn; //Especifica cuantos números van a entrar
cn=0;
c5=0;
s5=0;
while (cn<cdn ) {
cn=cn+1;
cin>>num;
if (num%5==0){
s5=s5 + num;
c5=c5+1;
}
}
if (c5>0) {
prom5=(float)s5/c5;
cout <<”Promedio de múltiplos de 5 “<<prom5;
}
else
cout<<”No hay múltiplos de 5”;
return 0;
}
Con los elementos planteados hasta el momento para los ciclo se presentan los siguientes
ejercicios, todos realizando los respectivos modelos mentales, teniendo en cuenta las reglas que
se han establecido.
Ejercicios planteados para ciclos

1. Sumar los números desde el 0 hasta un número dado
2. Sumar los números pares hasta un número dado
3. Hallar la tabla de multiplicar de un número dado
Ejercicio ciclo 4
Sumar los números desde el 0 hasta un número dado
Solución
Este ejercicio tiene un solo dato de entrada que es el límite hasta donde se deben sumar los datos.
Modelo mental inicial
Número dado 5
Suma 1+2+3+4+5 = 15
Respuesta Suma = 15
Esto demuestra que se entiende el objetivo pero no tiene características computacionales.
Para volverlo computacional se inicia con la regla de un dato a la vez
Modelo
Numero dado 5
1 2 3 4<-3+1 5 <- 4+1
1 3 6 10<-6+4 15<-10+5
Suma = 15
Observe que los datos son una secuencia de datos con variación de 1 en 1 y que esos datos se van
sumando
Pasos genéricos
Entrar un número
Generar los números desde 1 hasta el número dado
Por cada dato generado sumarlo
Mostrar el resultado de la suma
Regla. Colocar nombres y acciones
Nro // Entrada
Numero dado 5
Asignación Asignación Asignación Asignación Asignación

CON CON CON CON CON
1 2 3 4 5

SUM SUM SUM SUM SUM
1 3 6 10 15
SUM // salida
Suma = 15
Nro : Número límite tipo numérico entero
CON : Contador tipo numérico, genera la secuencia de 1 en 1 hasta Nro. Tipo numérico entero
SUM : Sumador o Acumulador, lleva la suma de los valores generados en CON. Tipo numérico
entero
Asignaciones:
Para CON CON CON +1

Para SUM
Sale del modelo mental, veamos para SUM en 15.
15 sale de la suma de 10 + 5 en donde 15 es SUM, 10 es SUM y 5 es CON, por lo que se tiene:
SUM SUM CON

15  10 + 5
Entonces la asignación de SUM es:
SUM  SUM + CON
Ahora CON y SUM tienen un valor inicial de Cero (0), antes de que lleguen los números, y se lo
establece con asignación y van antes del proceso de los números que se lo hace con un ciclo.
CON  0
SUM 0
El modelo entonces queda
Leer Nro
5

CON 0 CONCON+1 CONCON+1 CONCON+1 CONCON+1 CONCON+1
1<- 0+1 2 3 4 5

SUM0 SUMSUM+CON SUMSUM+CON SUMSUM+CON SUMSUM+CON SUMSUM+CON
1<- 0 + 1 3 6 10 15 <- 10 + 5
Escribir “Suma = “, SUM

15
Las instrucciones
CON  CON + 1
SUM  SUM + 1
Se repiten 5 veces, por lo que se va a utilizar un ciclo controlado por un contador, el contador es el
mismo que genera los números del 1 hasta el 5, es decir CON. Según esto la condición que
controla el ciclo es
CON < Nro donde Nro para el ejemplo es 5
Entonces el algoritmo queda:
Algoritmo sumarNumerosSerie
Definir Nro,CON,SUM como entero

Leer Nro
CON <- 0
SUM <- 0
Mientras (CON < Nro ) hacer
CON <- CON +1
SUM <- SUM + CON
Fin Mientras
Escribir "Suma = ", SUM
FinAlgoritmo
#include <iostream>
int main(){
int nro,con,sum,s5,num;
cout <<”Leer numero límite “;

cin >>nro; //Especifica cuantos números van a entrar
cn=0;
sum=0;
while (con<nro ) {
con=con+1;
sum=sum+con;
}
cout <<”Suma de números = “<<sum;
return 0;
}
El ejercicio anterior es importante, porque se sumaron varios números que no fueron entrados, se
generaron internamente con la variable CON que a su vez sirvió para controlar el ciclo.
Hay muchos ejercicios que tienen esta característica, con el análisis se los reconoce.
Ejercicio ciclo 6
Sumar los números pares desde el 0 hasta un número dado
Para este ejercicio se plantean dos soluciones
Solución 1. Esta solución tiene tendencia a aplicar los conceptos que se conocen. En este caso se
tiene el concepto de número par y se lo quiere asociar a la solución.
Modelo mental
Numero dado 13
2+4+6+8+10+12 = 42
Respuesta Suma de números pares hasta el 13 = 42
0 1 2 3 4
0 es par? 1 es par? ¿2 es par? ¿3 es par? ¿4 es par?
Si no Si
2 6
Algoritmo sumarNumerosSerie
Definir Nro,CON,SUM como entero

Leer Nro
CON <- 0
SUMP <- 0
Mientras (CON < Nro ) hacer
CON <- CON +1
Si CON mod 2 = 0
SUMP <- SUMP + CON
finSi
Fin Mientras
Escribir "Suma pares = ", SUMP
FinAlgoritmo
#include <iostream>
int main(){
int nro,con,sum,s5,num;

con=0;
sump=0;
while (con<nro ) {
con=con+1;
if (con%2==0)
sump=sump+con;
}
cout <<”Suma de números pares = “<<sump;
return 0;
}
Segunda solución.
Si el dato es 13
2+4+6+8+10+12 = 42
Para esta solución, no se necesita generar los números de 1 en 1 y preguntar si es par, tan solo se
genera el número con un contador de incremento 2 y se lo suma
Modelo mental con regla de un dato a la vez
Numero dado 13
2 4 6 8 10 12
2 6 12 20 30 42
Suma de pares menores que 13 = 42
Este es el planteamiento general de modelo mental que si es computacional. El análisis es el

mismo que se había planteado para el ejercicio anterior.
El modelo mental muestra una secuencia de 2, 4, 6, 8, 10, 12 que es un contador de dos en dos, y
cada valor par generado se lo suma.
Modelo general
Leer un valor limite

Generar los números pares desde el 2 hasta el valor límite // esto implica un ciclo
Cada valor generado sumarlo
Mostrar suma de valores pares
Modelo con nombres de variables
NRO
Numero dado 13
PAR PAR PAR PAR PAR PAR

2 4 6 8 10 12
SUMP SUMP SUMP SUMP SUMP SUMP
2 6 12 20 30 42
NRO SUMP
Suma de pares menores que 13 = 42
Determinación de los valores de variables (entrada, asignación).
Leer Nro PAR < NRO // condición control

13 12 < 13
Asignación Asignación Asignación Asignación Asignación Asignación

PAR 0 PARPAR+2 PARPAR+2 PARPAR+2 PARPAR+2 PARPAR+2 PARPAR+2
2 4 6 8 10 12

SUMP SUMPSUMP+PA SUMPSUMP+PAR SUMPSUMP+PA SUMPSUMP+PAR SUMPSUMP+PA SUMPSUMP+PAR
0 R 6 R 20 <- 12 + 8 R 42
2 12 30
Escribir “Suma = “, SUM

15
Variables
Nro : Valor numérico dado
PAR : Contador de pares
SUMP : Acumulador de pares
Como hay bloques de acciones que se repiten, se lo trabaja con un ciclo controlado por un
contador que es PAR.
Condición de control del ciclo PAR < Nro
Inicio
Leer Nro
PAR <- 0
SUMP <- 0
Mientras (PAR <= Nro ) hacer
PAR <- PAR +2
SUMP <- SUMP + PAR
Fin Mientras
Fin
La condición del ciclo es par<=nro-2
Se debe evaluar siempre la frontera para determinar que pasa con los últimos valores.
La evaluación de la frontera es determinar que pasa con el último dato. Muchas veces ocurre que trabaja uno más o uno
menos, por lo que hay que ajustar la condición.
El algoritmo queda
inicio
Leer Nro
PAR <- 0
SUMP <- 0
Mientras (PAR <= Nro-2 ) hacer
PAR <- PAR +2
SUMP <- SUMP + PAR
Fin Mientras
Fin
#include <iostream>
int main(){
int nro,par,sump;

par=0;
sump=0;
while (con<=nro-2 ) {
par=par+2;
sump=sump+par;
}
cout <<”Suma de números pares “<<”menores o iguales que “<< nro << “ = “ << sump;
return 0;
}
Con el manejo del contador PAR iniciando en 2 se tiene un mejor manejo en la frontera del dato
Inicio
Leer Nro
PAR <- 2
SUMP <- 0
Mientras (PAR <= Nro ) hacer
SUMP <- SUMP + PAR

PAR <- PAR +2
Fin Mientras
Fin
#include <iostream>
int main(){
int nro,par,sump;
par=2;
sump=0;
while (con<=nro ) {
sump=sump+par;
par=par+2;
}
cout <<”Suma de números mul de cinco “<<”menores o iguales que “<< nro << “ = “ <<
sump;
return 0;
}
Esta solución permite ver que el contador perfectamente puede iniciar su valor en un valor diferente de 0. En este caso
el valor inicia e 2 y la ultima instrucción es el incremento del contador.
Ejercicio
Sumar los múltiplos de 5 hasta un número dado
Numero dado 37
5 + 10 + 15 + 20 + 25 + 30 + 35 = 140
Algoritmo múltiplos5
Definir Nro,CIN,SUMC como entero
Leer Nro
CIN <- 5
SUMC <- 0
Mientras (CIN <= Nro ) hacer
SUMC <- SUMC + CIN

CIN <- CIN +5
Fin Mientras
Escribir "Suma múltiplos de cinco = ", SUMC
FinAlgoritmo
#include <iostream>
int main(){
int nro,cin,sumc;
cin=2;
sumc=0;
while (cin<=nro ) {
sumc=sumc+cin;
par=par+2;
}
cout <<”Suma de números pares = “<<”menores que “<< nro << “ = “ << sump;
return 0;
}
Los siguientes ejercicios van a recibir una cantidad dada de números, que van a ser trabajados con
una sola variable, como se trabajo en anteriores ejercicios.
Ejercicio ciclo propuestos
Se tiene una serie de números enteros determinados por una cantidad dada, determinar:
1. La cantidad de números mayores que 10
2. La cantidad de números mayores que un numero dado
3. El promedio de los números que están entre los valores 20 y 50
4. El promedio de los números que están entre dos valores dados
5. El promedio de los números pares que están entre dos valores dados
6. El número mayor
7. El número menor
8. El numero mayor y menor
Cada ejercicio es independiente
Ejercicio
Se tiene una cantidad dada de números y se solicita,
El promedio de los números pares que están entre dos valores dados
Se tiene una serie de números enteros determinados por una cantidad dada, determinar el
promedio de los números pares que están entre dos valores dados
Ejemplo
Valores dados
R1 R2
25 12
Validar R1>R2?
R1 R2 aux
12 25
cn
Cantidad de números 6
c c c
1 2 3
Nro Nro Nro
15 7 14 26 12 20
Sump promp
14 + 12 + 20 = 46/3 = 15,3
Cp
3
Pasos genéricos
Definir variables
Leer rango
Validar rango e intercambiar
Leer cantidad de datos
Leer los datos hasta la cantidad de datos
Por cada dato
Determinar si es par
Si es par determinar si está dentro del rango
Si esta dentro del rango sumarlo y contarlo
Después de los datos hallar el promedio con la suma y la cuenta
Mostrar promedio
Algoritmo RangoPares
Definir r1,r2,cd,Sp,Cp,C,Nro,aux como entero
Definir promp como real
Leer r1,r2 // para que el algoritmo funciones r2 tiene que ser >= que r1
// para garantizar valores en el rango se intercambia los valores
Si r1>r2 Entonces
aux<-r1
r1<-r2
r2 <-aux
FinSi
Leer cd
C<-1
Sp <-0
Cp<-0
Mientras C<=cd hacer
Leer Nro
Si Nro mod 2= 0 Entonces
Si Nro >= r1 y Nro<=r2 Entonces
Sp<- Sp+Nro
Cp<-Cp+1
Finsi
Finsi
C<-C+1
FinMientras
// controlar la división por cero
Si Cp > 0 Entonces
Promp<- Sp/Cp
Escribir " Promedio de pares en el rango ",promp
Sino
Escribir " No hay números pares en el rango "
Finsi
FinAlgoritmo
Algoritmo en lenguajes C++
#include <iostream>
int main(){
int r1,r2,cd,sp,cp,c,nro,aux;
float promp;
cout <<”Leer límite uno “;
cin >>r1; //Especifica cuantos números van a entrar
cout <<”Lee límite dos “;
cin >>r2; //Especifica cuantos números van a entrar
//validar rango
if ( r1>r2) {
aux=r1;
r1=r2;
r2 =aux;
}
cout <<”\nCantidad de datos “;
cin >>cd;
c=1;
sp=0;
cp=0;
while (c <=cd){
cout <<”\nDigitar dato “;
cin >>nro;
if (nro%2==0){
if(nro>=r1 && nro<=r2){
sp=sp+nro;
cp=cp+1;
}
}
c=c+1;
}
// controlar la división por cero
if ( cp > 0) {
promp=(float) sp/cp;
cout <<”Promedio de pares en el rango = “<<promp;
}
else
cout <<”No hay números pares en el rango “;
return 0;
}
Los siguientes ejercicio se los trabaja con ciclos y presentan otra forma de definir
1. Determinar si un número dado es múltiplo de 5 sin utilizar el operador residuo (mod)
2. Determinar si un número dado es múltiplo de otro sin utilizar el operador residuo (mod)
3. Hallar la multiplicación de dos números con sumas
4. Determinar para un número dado la cantidad de números que lo dividen exactamente
5. Determinar si un número dado es o no primo
Ejercicio ciclo 7
El siguiente ejercicio permite aplicar el operador residuo para determinar la cantidad de divisores
exactos que tiene un número dado.
Definición
Determinar para un número dado, la cantidad de números que lo dividen exactamente.
Para este ejercicio se deben tener claro el concepto de división exacta,

Un número divide exactamente a otro, cuando al hacer la división entera no hay residuo.
Concepto de residuo. Se trabaja con el operador mod (%) para encontrar el residuo de una
división.
Modelo mental
Numero dado 6
Mentalmente podríamos decir que los números que lo dividen exactamente son
1, 2, 3 y 6
O sea son 4.
Para el número 10 se tienen
1 2 5 10
Esto se pudo hacer porque el número es pequeño.
Que se hace mentalmente para llegar al 4
Se divide por todos los valores entre 1 y 6 y se pregunta si el residuo es 0, si es 0 se lo cuenta. Se

debe utilizar el operador mod para esto.
Un dato a la vez
Número dado 6
6 mod 1 = 0? si 1
6 mod 2 = 0? si 2
6 mod 3 = 0? si 3
6 mod 4 = 0? no
6 mod 5 = 0? no
6 mod 6 = 0? Si 4
6 % 1 = 0? si 1
6 % 2 = 0? si 2
6 % 3 = 0? si 3
6 % 4 = 0? no
6 % 5 = 0? no
6 % 6 = 0? Si 4
Esta es una forma de realizar un modelo mental.

En este modelo mental que se identifica.
6 que es el número dado

Secuencia del 1 al 6 que es un contador
Secuencia del 1 al 4 que es el contador de divisiones exactas y son variables
Modelo mental con Nombres de variables
NRO
Número dado 6
NRO CN CD
6 mod 1 = 0? si 1
CN CD
6 mod 2 = 0? si 2
CN CD
6 mod 3 = 0? si 3
CN
6 mod 4= 0? no
CN
6 mod 5 = 0? no
CN CD
6 mod 6 = 0? Si 4
CD
Respuesta Cantidad de divisores = 4
NRO Número dado entero

CN Contador de 1 en 1 que va hasta NRO
CD Contador de 1 en 1 cuenta las divisiones exactas
Este ejercicio se lo va a realizar con un ciclo controlado por un contador en donde, por cada
variación del contador CN se va a realizar lo siguiente:
Leer Nro
6
CN CN CN CN CN CN
1 2 3 4 5 6
NRO CN NRO CN NRO CN NRO CN NRO CN NRO CN
¿6 MOD 1 = 0? ¿6 MOD 2 = 0? ¿6 MOD 3 = 0? ¿6 MOD 4 = 0? ¿6 MOD 5 = 0? ¿6 MOD 6 = 0?
SI SI SI NO No SI
CD CD CD CD
1 2 3 4
Cantidad de divisores exactos , CD

4
Modelo mental con acciones computacionales
Las variaciones de CN y CD dentro del ciclo van a ser:

CN  CN + 1
CD  CD + 1
Por fuera del ciclo
CN  0
CD  0
La condición que controla el ciclo va a ser CN < NRO
Leer Nro
6
CN  0 Asignación Asignación Asignación Asignación Asignación Asignación

CNCN+1 CNCN+1 CNCN+1 CNCN+1 CNCN+1 CNCN+1
1 2 3 4 5 6
CD  0 Decisión Decisión Decisión Decisión Decisión Decisión
Si (NRO MOD CN =0) Si (NRO MOD CN =0) Si (NRO MOD CN =0) Si (NRO MOD CN =0) Si (NRO MOD CN =0) Si (NRO MOD CN =0)
Entonces Entonces Entonces Entonces Entonces Entonces
CD  CD + 1 CD  CD + 1 CD  CD + 1 CD  CD + 1 CD  CD + 1 CD  CD + 1
Fin si Fin si Fin si Fin si Fin si Fin si
Cantidad de divisores exactos , CD // salida

4
Con lo anterior se tiene que el algoritmo resultante es:
Inicio
Definir NRO,CN,CD como entero
Leer NRO
CN <- 0
CD <- 0
Mientras (CN < NRO ) Hacer
CN <-CN + 1
Si ( NRO MOD CN = 0)
Entonces
CD <- CD + 1
Fin si
Fin mientras
Escribir “Cantidad de divisores exactos =”, CD
Fin
Algoritmo en lenguajes C++
#include <iostream>
int main(){
int nro,cn,cd;
cout <<”Digitar numero “;

cin >>nro;
cn=0;
cd=0;
while (cn <nro){
cn=cn+1;
if (nro%cn==0)
cd=cd+1;
}
cout <<”cantidad de números “<<cd;
return 0;
}
Con el contador que controla el ciclo iniciando en 1 se tendría lo siguiente:
#include <iostream>
int main(){
int nro,cn,cd;

cin >>nro;
cn=1;
cd=0;
while (cn <=nro){
if (nro%cn==0)
cd=cd+1;
cn=cn+1;
}
cout <<”No hay números pares en el rango “;
return 0;
}
Ejercicio ciclo 8
El ejercicio anterior permite establecer si un número determinado es o no primo.
Determinar si un número dado es primo.
Conceptos que debe tener claro.

Número primo. Un número es primo si y solo si, es divisible exactamente por 1 y por el mismo.
División exacta. División entera con residuo 0, en computación para averiguar el residuo se utiliza
mod.
Con estos conceptos más los conceptos de las acciones, se puede dar un ejemplo
Número dado 7
Al 7 solo lo divide exactamente el 1 y el 7.
El 5 es primo
1 5
Por lo tanto es primo
Numero dado 6
Al 6 lo divide exactamente el 1, 2, 3 y 6 por lo tanto no es primo.
Esto es un ejemplo y cumple con el objetivo.
Mentalmente se puede hacer este análisis para números pequeños y establecemos la respuesta
directamente, pero computacionalmente debemos decirle al detalle que es lo que hace la mente.
Regla de un dato a la vez.
El 7 se tiene que dividir por todos los números del 1 al 7 para ver, si lo dividen exactamente
Número dado 7
7 mod 1 = 0? si 1
7 mod 2 = 0? no
7 mod 3 = 0? no
7 mod 4 = 0? no
7 mod 5 = 0? no
7 mod 6 = 0? no
7 mod 7 = 0? Si 2
Este es el comportamiento mental paso a paso para el 7.

El 7 es primo porque solo hay 2 números que lo dividen exactamente, el 1 y 7.
Para el numero 6 se tiene el siguiente modelo
Número dado 6
6 mod 1 = 0? si 1
6 mod 2 = 0? si 2
6 mod 3 = 0? si 3
6 mod 4 = 0? no
6 mod 5 = 0? no
6 mod 6 = 0? Si 4
No es primo porque hay 4 valores que lo dividen exactamente.
Entonces para determinar si un dato es primo, se utiliza el ejercicio anterior, el de determinar la

cantidad de números que lo dividen exactamente.
Pasos genéricos
Leer número a evaluar

Hallar la cantidad de números que lo dividen exactamente
Si la cantidad de número es igual a 2 el número es primo
De lo contrario no es primo
Entonces todo el análisis realizado para el ejercicio anterior sirve para determinar si es primo
Leer Nro
6
CN  0 Asignación Asignación Asignación Asignación Asignación Asignación

CNCN+1 CNCN+1 CNCN+1 CNCN+1 CNCN+1 CNCN+1
1 2 3 4 5 6
CD  0 Decisión Decisión Decisión Decisión Decisión Decisión
Si (NRO MOD CN =0) Si (NRO MOD CN =0) Si (NRO MOD CN =0) Si (NRO MOD CN =0) Si (NRO MOD CN =0) Si (NRO MOD CN =0)
Entonces Entonces Entonces Entonces Entonces Entonces
CD  CD + 1 CD  CD + 1 CD  CD + 1 CD  CD + 1 CD  CD + 1 CD  CD + 1
Fin si Fin si Fin si Fin si Fin si Fin si
Si ( CD = 2)
Entonces
Escribir NRO, “ Es primo “
Sino
Escribir NRO, “ No es primo “
Fin si
Después del ciclo se evalúa si el contador de divisores exactos es menor o igual a 2 ( CD <=2 ), si es
así, significa que el numero evaluado ( NRO ), si es primo, de lo contrario no los es.
Algoritmo.
Inicio
Definir NRO,CN,CD como entero
Leer NRO
CN  0
CD  0
CN CN + 1
Entonces
CD  CD + 1
Fin si
Fin mientras
Si ( CD = 2)
Entonces
Sino
Fin si
Fin
Se resalta la parte que se adiciona al ejercicio anterior para evaluar el contador de divisores, que
permite determinar si es o no primo.
Programa en lenguaje C++ con el contador cn iniciando en 1.
#include <iostream>
int main(){
int nro,cn,cd;

cin >>nro;
cn=1;
cd=0;
while (cn <=nro){
if (nro%cn==0)
cd=cd+1;
cn=cn+1;
}
If (cd==2)
cout <<nro<< ” es numero primo “;
else
cout <<nro<< ” no es numero primo “;
return 0;
}
Ejercicios
Determinar de una cantidad de números dada el promedio de los números primos - ciclos
anidados
Determinar de una cantidad de números dada, el número mayor.
Determinar de una cantidad de números, el número menor
Determinar el mayor y el menor de una cantidad dada de números
Determinar de una cantidad de números dada el primo mayor
Determinar de una cantidad de números dada el primo mayor y el primo menor
Determinar de una cantidad de números dada el factorial del primo mayor
Estos dos ejercicios son muy útiles, para identificar las características de un conjunto de datos que
es muy importante analizarlos.
Ejercicio ciclo 9
Determinar de una cantidad de números dada, el número mayor.
Solución 1
Primer modelo mental
Cantidad de datos 5
Datos 7 20 30 15 10
Resultado Dato mayor = 30
Con este ejemplo se tiene claro lo que se busca, pero no es un modelo con características
computacionales.
Para que sea computacional se trabaja un dato a la vez y por cada dato se analiza lo que hace la
mente.
Cantidad de datos 5
Dato 1 7
que hace la mente?
Se guarda como el mayor. Esto porque es el primero.
Dato 2 20
Cuando llega el 20 se compara con el valor mayor que se lleva
¿20>7?
Si
Ahora el mayor es 20
Dato 3 30
¿30>20?
Si
Ahora el mayor es 30
Dato 4 15
¿15 > 30?
No
No hace nada
Dato 5 10
¿10>30?
No
No hace nada
Como ya no hay más datos, el mayor es 30
Visto de otra forma se tiene
Cantidad de datos 5
1 2 3 4 5
7 20 30 10 15
Mayor ¿20>7? ¿30>20? ¿10>30? ¿15>30?

7 Si Si No No
Mayor Mayor
20 30
Mayor 30
En este modelo se ve mejor lo que pasa.

Si el dato es el primero no se compara con nadie y es el mayor
A partir del segundo, todo dato se compara con el mayor que lleve.
Esto indica que si se va a trabajar con un ciclo controlado por un contador, el primer dato no debe
estar dentro del ciclo porque su acción es diferente a las demás.
Modelo mental con nombres de variables y acciones
CD // Entrada
Cantidad de datos 5

CON CON CON CON CON
1 2 3 4 5
Entrada Entrada Entrada Entrada Entrada
NRO NRO NRO NRO NRO
7 20 30 10 15
Asignación Decisión Decisión Decisión Decisión
MAYOR NRO MAYOR NRO MAYOR NRO MAYOR NRO MAYOR
7 ¿20 > 7? ¿30 > 20? ¿10 > 30? ¿15 > 30?
Si Si No No
MAYOR MAYOR
20 30
Mayor 30
Definición de Variables
CD : Cantidad de Datos numérico entero

CON : Contador de datos de entrada entero
NRO : Número de entrada numérico entero
MAYOR: Número mayor de los datos numérico entero
Modelo con acciones computacionales y sin datos
Leer CD

CON  1 CONCON+1 CONCON+1 CONCON+1 CONCON+1
Leer NRO Leer NRO Leer NRO Leer NRO Leer NRO
SI (NRO>MAYOR) SI (NRO>MAYOR) SI(NRO>MAYOR) SI (NRO>MAYOR)

MAYORNRO Entonces Entonces Entonces Entonces
MAYORNRO MAYORNRO MAYORNRO MAYORNRO
Fin si Fin si Fin si Fin si
Escribir “ Mayor “, MAYOR
De lo anterior se determina que lo que debe ir en el ciclo controlado por el contador CON son las
acciones a partir del segundo dato. El algoritmo resultante es el siguiente:
Inicio
Leer CD
CON <- 1
Leer NRO
MAYOR <- NRO
Mientras ( CON < CD) Hacer
CON <- CON + 1
Leer NRO
SI ( NRO > MAYOR )
Entonces
MAYOR <- NRO
Fin si
Fin mientras
Escribir “ Mayor = “, MAYOR
Fin
Programa en lenguaje C++ solución 1
#include <iostream>
int main(){
int cd,nro,mayor,con;

cin >>cd;
// Se lee el primer número

cin >>nro;
mayor=nro;
con=1;
while (con < cd) {

con=con+1;
cin >>nro;
if (nro>mayor)
mayor=nro;
}
cout <<”Numero mayor = “<<mayor;
return 0;
}
Ejercicio ciclo 11
Determinar de una cantidad de números, el número menor
Para obtener el menor de los datos, el análisis es el mismo y lo que cambia es la variable MAYOR
por MENOR y la decisión es la siguiente:
SI ( NRO < MENOR )

Entonces
MENOR  NRO
Fin si
Que indica si el nuevo número que se lee es menor que el menor que se lleva, se lo cambia
Algoritmo para el menor
Inicio
Leer CD
CON  1
Leer NRO
MENOR  NRO
CON  CON + 1
Leer NRO
SI ( NRO < MENOR )
Entonces
MENOR  NRO
Fin si
Fin mientras
Escribir “ Menor = “, MENOR
Fin
#include <iostream>
int main(){
int cd,nro,menor,con;

cin >>cd;

cin >>nro;
menor=nro;
con=1;
while (cn <=cd) {

con=con+1;
cin >>nro;
if (nro<menor)
menor=nro;
}
cout <<”Numero menor = “<<menor;
return 0;
}
El método anterior lee un dato por fuera del ciclo y lo establece como MAYOR o como MENOR,
esto se hace con el propósito de tener un dato válido para realizar las comparaciones con los
demás datos.
Ejercicio ciclo 12
Sacar el mayor y el menor de una cantidad de datos numéricos dada
Con el método anterior se tendría como resultado la combinación de los dos primeros en donde
cambiaría la condición.
Inicio
Leer CD
CON  1
Leer NRO
MENOR  NRO
MAYOR  NRO
CON  CON + 1
Leer NRO
SI ( NRO > MAYOR )
Entonces
MAYOR  NRO
Sino
Si ( NRO < MENOR )
Entonces
MENOR  NRO
Fin si
Fin si
Fin mientras
Fin
#include <iostream>
int main(){
int cd,nro,mayor,menor,con;

cin >>cd;

cin >>nro;
mayor=nro;
menor=nro;
con=1;
while (con <cd) {

con=con+1;
cin >>nro;
if (nro>mayor)
mayor=nro;
else
if (nro<menor)
menor=nro;
}
cout <<”Número menor = “<<menor;
return 0;
}
Otra forma del ejercicio
Inicio
Leer CD
CON <- 1
Leer NRO
MENOR <- NRO
MAYOR <- NRO
CON <- CON + 1
Leer NRO
SI ( NRO > MAYOR )
Entonces
MAYOR <- NRO
Fin si
Si ( NRO < MENOR )

Entonces
MENOR <- NRO
Fin si
Fin mientras
Fin
Ejercicio ciclo 13
Determinar de una cantidad de números dada, el número mayor. Utilizando otro método
En el siguiente ejercicio va determinar el mayor de los datos, con otro método que incluye la
lectura de todos los datos dentro del ciclo.
Cuando se busca el mayor y el menor de una cantidad de datos, la mente reserva un espacio de
memoria para ir llevando el mayor o el menor, sabiendo que el primer dato, por ser el primero
será el mayor y el menor, a partir del segundo ya se puede comparar porque al menos hay un dato
en la memoria.
El método anterior lee un dato por fuera y este, lo vuelve mayor y menor, y durante el ciclo los
compara con los demás datos.
Ahora el método que se propone es leerlos todos dentro del ciclo, por lo que dentro de las
instrucciones del ciclo, debe haber alguna señal que controle que el dato tratado es el primero.
Muchos ejercicios van a necesitar de este tratamiento, por lo que es muy importante tenerlo
presente.
Modelo mental
Para 5 datos que son 7,20,30,10,15 donde el mayor es 30
Paso a paso necesita hacer la pregunta de si es el primero
Cantidad de datos 5
1 2 3 4 5
7 20 30 10 15
¿7 es el primero? ¿20 es el primero? ¿30 es el primero? ¿10 es el primero? ¿15 es el primero?

Si No No No No
Mayor ¿20>7? ¿30>20? ¿10>30? ¿15>30?
7 Si Si No No
Mayor Mayor
20 30
Mayor 30
Modelo con variables y acciones
CD
Cantidad de datos 5
CON Asignación Asignación Asignación Asignación Asignación

0 CON CON CON CON CON
1 2 3 4 5
Entrada Entrada Entrada Entrada Entrada
NRO NRO NRO NRO NRO
7 20 30 10 15
Decisión Decisión Decisión Decisión Decisión
NRO NRO NRO NRO NRO
¿7 es el primero? ¿20 es el primero? ¿30 es el primero? ¿10 es el primero? ¿15 es el primero?
Si No No No No
Asignación Decisión Decisión Decisión Decisión
MAYOR NRO MAYOR NRO MAYOR NRO MAYOR NRO MAYOR
7 ¿20 > 7? ¿30 > 20? ¿10 > 30? ¿15 > 30?
Si Si No No
Asignación Asignación
MAYOR MAYOR
20 30
Mayor 30
Este ejercicio se realiza con un ciclo controlado por el contador CON, donde la condición de
control es, CON < CD .
Para determinar si es el primero se lo hace preguntado si CON vale 1. Solo para el primer dato
CON vale 1, para los demás es diferente de 1 por lo tanto, para los demás datos la condición ya no
va a ser verdadera y pasa por el falso a comparar con el valor leído en NRO
Algoritmo
Inicio
Leer CD
CON <- 0
Mientras ( CON < CD ) Hacer
CON <- CON + 1
Leer NRO
SI ( CON = 1 )
Entonces // si es verdadero es porque es el primero
MAYOR <- NRO // el primer dato lo vuelve mayor
Sino // ya no es el primero entra a comparar
Si ( NRO > MAYOR )
Entonces
MAYOR <- NRO
Fin si
Fin si
Fin mientras
Fin
#include <iostream>
int main(){
int cd,nro,mayor,con;

cin >>cd;
con=0;
while (con < cd) {
con=con+1;
cin >>nro;
//determina si es el primero
if (con==1)
mayor=nro;
else
if (nro>mayor)
mayor=nro;
}
return 0;
}
Inicio
Leer CD
CON <- 0
CON <- CON + 1
Leer NRO
SI ( CON = 1 )
Entonces // si es verdadero es porque es el primero
MAYOR <- NRO // el primer dato lo vuelve mayor
MENOR <- NRO
Sino // ya no es el primero entra a comparar
Si ( NRO > MAYOR )
Entonces
MAYOR <- NRO
Fin si
Si ( NRO < MENOR )
Entonces
MENOR <- NRO
Fin si
Fin si
Fin mientras
Escribir " Mayor = ", MAYOR
Escribir " Menro = ", MENOR
fin
#include <iostream>
int main(){
int cd,nro,mayor,menor,con;

cin >>cd;

cin >>nro;
con=0;
while (cn <cd) {

con=con+1;
cin >>nro;
//determina si es el primero
if (cn==1) {
mayor=nro;
menor=nro;
}
else{
if (nro>mayor)
mayor=nro;
else
if (nro<menor)
menor=nro;
}
}
}
cout <<”Número menor = “<<menor;
return 0;
}
Ejercicio ciclo 14
Determinar de una cantidad de números dada, el número mayor. Método 3
Existe un tercer método para obtener el mayor y el menor que es muy utilizado, y es
estrictamente computacional.
Para hallar el mayor o el menor, se parte del hecho de que se debe tener en una variable MAYOR o
MENOR un dato para comparar, y esto no se lo tiene, sino se ha leído el primer dato, para evitar
esto, por fuera del ciclo se inicializa MAYOR con el valor más pequeño y para MENOR con el valor
más alto del tipo de dato.
Ejemplo
MAYOR 0 si los datos son positivos

y
MENOR  32767
Si el máximo valor que puede entrar es 32767
Esto garantiza que tanto el mayor como el menor, con la primera comparación cambien.
El algoritmo para el mayor queda:
Inicio
Leer CD
CON <- 0
MAYOR <- 0 // se inicializa en 0 para que en la primera comparación cambie
CON <- CON + 1
Leer NRO
Si ( NRO > MAYOR )
Entonces
MAYOR <- NRO
Fin si
Fin mientras
Fin
Ciclo controlado por un contador decreciente
Hasta ahora los ciclos han sido controlados por contadores que van en forma creciente a alcanzar
un número dado. Ahora, depende del análisis del ejercicio el que determina que tipo de contador
es.
El siguiente ejercicio es un ejemplo de un contador decreciente.
Ejercicio ciclo 15
Determinar el factorial de un número dado.
El factorial de un número se lo define de la siguiente forma:
5!
Es 5*4*3*2*1 = 120
1*2*3*4*5 = 120
El factorial de 5 es 120
Ejemplo
Dato dado 5
5! = 5*4*3*2*1 = 120
Respuesta Factorial de 5 = 120
Nuevamente este es un modelo que no tiene características computacionales. Las características

se las establece con la regla de un dato a la vez. Pero si podemos apreciar que hay un contador
que va decrementándose ( 5 ,4,3,2,1)
Con un dato a la vez se obtiene el siguiente modelo, esto es que pasa con cada valor decreciente.
Número dado 5
FAC<-1 CON 4 CON<-CON-1 2 1

5 3 <- 4-1
CON<-5 FAC <- FAC*CON FAC <- FAC <- FAC*CON 120<-60*2 120<-120*1
FAC*CON 60 <-20*3
5 <- 1 * 5 20 <- 5*4
Factorial de 5 = 120
Adición de nombres y acciones

En este ciclo controlado con un contador, el decremento se lo hace al final por lo tanto el contador
inicia en NRO y se decrementa al final.
La condición que va a controlar el ciclo es CON>=1
NRO
5
Asignación CON>=1? CON>=1? CON>=1? CON>=1? CON>=1?

CON<- 5 4 3 2 1
NRO
FAC FAC<-FAC*CON FAC FAC FAC * CON FAC<-FAC * FAC
1 5 <- 1 * 5 20 60 <- 20*3 CON 120
CON<-CON-1 CON<-CON-1 CON<-CON-1 120<-60*2 CON<-CON-1
4<-5-1 CON<-CON-1
FAC
Factorial de 5 = 120
El algoritmo queda:
Inicio
Leer NRO
CON <- NRO
FAC <- 1
Mientras ( CON >= 1) Hacer
FAC <- FAC * CON

CON <- CON - 1
Fin mientras
Escribir “Factorial de “, NRO , “ = “, FAC
Fin
#include <iostream>
int main(){
int con,nro, fac;

cin >>nro;
con=nro;
fac=1;
while (con >=1) {
fac=fac*con;
con=con-1;
}
cout <<”Factorial de “<<nro <<” = “<<fac;
return 0;
}
Ejercicio ciclo 16
Determinara el factorial de un número dado. Método 2
Ahora el ejercicio anterior se lo pudo haber realizado de la siguiente forma:
5! = 5*4*3*2*1 = 1*2*3*4*5 = 120
Esto porque la multiplicación es conmutativa.
El algoritmo entonces depende como se lo analiza. Si se analiza de la segunda forma se tiene, un

contador ascendente y no decreciente como el anterior. Con cualquier método se puede realizar
lo importante, es seguir lo analizado.
Algoritmo
Inicio
Leer NRO
CON <- 1
FAC <- 1
Mientras ( CON <=NRO) Hacer
FAC <- FAC * CON
CON <- CON +1
Fin mientras
Escribir “Factorial de “, NRO , “ = “, FAC
Fin
#include <iostream>
int main(){
int con,nro, fac;

cin >>nro;
con=1;
fac=1;
while (con <=nro) {
fac=fac*con;
con=con+1;
}
cout <<”Factorial de “<<nro <<” = “<<fac;
return 0;
}
Ciclos anidados
Los siguientes ejercicios tienen ciclos anidados.
Se habla de ciclos anidados cuando dentro de las instrucciones a repetir de un ciclo, una o varias
de ellas son también ciclos.
Formato general
Mientras ( Condicion 1) hacer

Acciones ciclo 1
Mientras ( Condición 2 ) hacer
Acciones ciclo 2
Mientras ( Condición 3 ) hacer
Acciones ciclo 3
.
Fin mientras // ciclo 3

Esta situación planteada muestra que hay 3 ciclos mientras anidados con sus respectivas acciones
genéricas.
Características
- Cuando se tiene ciclos anidados, el ciclo más interno se acaba primero
- El orden del fin mientras (}) de cada ciclo, está especificado desde el más interno hasta el más
externo. Por eso es que se acaba primero.
- Cada ciclo interno tiene sus condiciones antes del ciclo y después del ciclo, que se deben
manejar muy bien, para evitar errores.
Ejercicios propuestos, donde se necesitan ciclos anidados
- Hallar las tablas de multiplicar del 1 al 10

- Se tiene una cantidad de números dada, determinar cuantos números primos hay en esos
números.
- Se tiene una cantidad de números dada, determinar el promedio de los números primos que
están en esos números.
- Se tiene una cantidad de números dada, determinar el primo menor de los números primos.
- Se tiene una cantidad de números dada, determinar la suma de los factoriales de los números
primos.
Ejercicios ciclo 17
Se tiene una cantidad de números dada, determinar el promedio de los números primos que están
en esos números.
Números 8 7 2 4 13 17
Promedio 7+2+13+17 = 39 = 9.75

4 4
Resultado Promedio Primos = 9.75
Modelo mental con características computacionales. Un dato a la vez
Cantidad de Números 6
1 2 3 4 5 6
8 7 2 4 13 17
¿8 es primo? ¿7 es primo? ¿2 es primo? ¿4 es primo? ¿13 es primo? ¿17 es primo?

No Si Si No Si Si
7 9 22 39
1 2 3 4
Promedio primos = 39 = 12,25

4
Promedio = 12,25
Modelo con Nombres de variables y tipo de acción
CNUM // Entrada
Cantidad de Números 6
Asignación Asignación Asignación Asignación Asignación Asignación Asignación

CON CON CON CON CON CON CON
0 1 2 3 4 5 6
Entrada Entrada Entrada Entrada Entrada Entrada
NRO NRO NRO NRO NRO NRO
8 7 2 4 13 17

No Si Si No Si Si
SUMP SUMP SUMP SUMP SUMP
0 7 9 22 39
CONP CONP CONP CONP CONP
0 1 2 3 4
SUMP PROMP // Asignación

Promedio primos = 39 = 9,75
CONP
4
PROMP //Salida
Promedio = 9,75
La pregunta
NRO
¿8 es primo?
No
Exige que se ejecuten las acciones para determinar si NRO es primo, entonces esta pregunta se
transforma en:
CN  0
CD  0
CN CN + 1
Entonces
CD  CD + 1
Fin si
Fin mientras
Si ( CD = 2)
Entonces // el número si es primo
SUMP  SUMP + NRO
CONP  CONP + 1
Fin si
Las acciones a repetirse entonces son las siguientes:
¿CON < CNUM?

CON  CON + 1
Leer NRO
CN  0
CD  0
CN CN + 1
Entonces
CD  CD + 1
Fin si
Fin mientras
Si ( CD = 2)
SUMP  SUMP + NRO
CONP  CONP + 1
Fin si
CNUM : Cantidad de Números a evaluar
CON : Contador de Números a entrar
NRO : variable que recibe todos los números
SUMP : Variable acumulador de números primos
CONP : Variable contador de números primos
CN : Contador utilizado para determinar un número primo
CD : Contador de divisores exactos para determinar si es primo
PROMP : Promedio de primos
Algoritmo
Algoritmo PromedioPrimos
Definir CNUM,CON,NRO,SUMP,CONP,CN,CD Como Entero
Definir PROMP Como Real
Leer CNUM
CON <- 0
SUMP <- 0
CONP<- 0
Mientras ( CON < CNUM ) hacer // ciclo para controlar la entrada de datos
CON <- CON + 1
Leer NRO
CN <- 0
CD <- 0
Mientras (CN < NRO ) Hacer // ciclo para determinar divisores exactos
CN <-CN + 1
Entonces
CD <- CD + 1
Fin si
Fin mientras
Si ( CD = 2)
SUMP <- SUMP + NRO
CONP <- CONP + 1
Fin si
Fin mientras
Si ( CONP > 0 ) // Valida si hay al menos un número primo
Entonces
PROMP <- SUMP/CONP
Escribir " Promedio de Primos = ",PROMP
Sino
Escribir " No hay números primos "
Fin si
FinAlgoritmo
El algoritmo muestra en otro color que implica establecer si un dato es o no primo, el cual necesita
de un ciclo para determinar la cantidad de divisores exactos.
#include <iostream>
int main(){
int cnum,con,nro,sump,conp,cn,cd;
float promp;
cout<<"Cantidad de números ";

cin >>cnum;
con=0;
sump=0;
conp=0;
while (con<cnum) {
con=con+1;
cout<<"Digitar numero";
cin>>nro;
cn=0;
cd=0;
while(cn<nro) {
cn=cn+1;
if(nro%cn==0)
cd=cd+1;
}
if (cd==2){
sump=sump+nro;
conp=conp+1;
}
}
if( conp>0){
promp=(float)sump/conp;
cout<<"Promedio de números primos "<<promp;
}
else
cout<<"No hay números primos";
Ejercicio ciclo
Generar la serie de Fibonacci para n términos.
La serie de Fibonacci tiene el siguiente comportamiento. Inicia con 0 y 1 y el siguiente término es

la suma de los dos anteriores.
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Esta serie se genera con un ciclo donde por cada repetición o iteración del ciclo se genera un
término.
Modelo mental
Numero de Términos 10
A B T T T T T
1 2 3 4 5 6 7 8 9 10
0 1 1 2 3 5 8 13 21 34
A B
A B
A B
A B
A B
T<-A+B
A<-B
B<-T
Donde los dos primeros números por definición ya se los tiene generados, faltan los otros 8 los
cuales se los realiza de la siguiente forma
Lo que se conoce es
1 2 3 4 5 6 7 8 9 10
0 1 1<-0+1 2<-1+1 3<-1+2 5<-2+3 8 13 21 34
El anterior modelo indica lo que pasa mentalmente. Con nombres queda:
C C C C C C C C C C
1 2 3 4 5 6 7 8 9 10
A B T T T T T T T T
0 1 1 2 3 5 8 13 21 34
C C C<-C+1 C<-C+1 C<-C+1 C<-C+1 C<-C+1 C<-C+1 C<-C+1 C<-C+1

1 2 3 4 5 6 7 8 9 10
A B T<- A+B T<-A+B T<-A+B T<-A+B T<-A+B T<- A+B T<- A+B T<-A+B
0 1 1<- 0+1 2<-1+1 3<-1+2 5<-2+3 8<-3+5 13<-5+8 21<-8+13 34<-13+21
A<-1 A<-1 A<-2 A<-3 A<-5 A<-8 A<-13 A<-21
B<-1 B<-2 B<-3 B<-5 B<-8 B<-13 B<-21 B<-34
Para que el nuevo termino se genere, se debe tener en cada tiempo los dos valores anteriores. En
el modelo mental se tiene que valores debe estar en las variables A y B, que siempre van a ser los
dos anteriores para obtener el proximo que es T
T<- A+B
Esto significa que antes de generar el termino T los valores de A y B deben haber cambiado y lo
hacen como en el ejemplo. Eso significa que
A <- B
B <- T
Ahora cada vez que se genera un numero de la serie se lo muestra. Entonces el modelo es el
siguiente
NT
Numero de términos 10
C C C<-C+1 C<-C+1 C<-C+1 C<-C+1 C<-C+1 C<-C+1 C<-C+1 C<-C+1
1 2 3 4 5 6 7 8 9 10
A B T<- A+B T<-A+B T<-A+B T<-A+B T<-A+B T<- A+B T<- A+B T<-A+B
0 1 1<- 0+1 2<-1+1 3<-1+2 5<-2+3 8<-3+5 13<-5+8 21<-8+13 34<-13+21
Sale A T T T T T T T T
Sale B Sale 1 Sale 2 Sale 3 Sale 5 Sale 8 Sale 13 Sale 21 Sale 34
A<-B A<-B A<-B A<-B A<-B A<-B A<-B A<-B
B<-T B<-T B<-T B<-T B<-T B<-T B<-T B<-T
Entonces las acciones que se repiten son:

C<-C+1
T<-A+B
Escribir T
A<-B
B<-T
Donde A<-B y B<-T dejan preparado los valores para generar el próximo numero fibonacci, el
cual se hace en el siguiente tiempo.
El algoritmo queda
Inicio
Leer NT
A<-0
B<-1
Escribir A
Escribir B
C<-2
Mientras ( C<NT ) Hacer
C<-C+1
T<-A+B
Escribir T
A<-B
B<-T
Fin mientras
Fin
Programa en lenguajes C++

#include <iostream>
int main(){
int nt,c,a,b,t;
cout <<"Cantidad de términos => ";
cin>>nt;
a=0;
b=1;
cout << "Termino fibonacci 1 = "<<a;
cout << "\nTermino fibonacci 2 = "<<b;
c=2;
while (c<nt) {
c=c+1;
t=a+b;
cout<<"\nTermino fibonacci "<<c<<" = "<<t;
a=b;
b=t;
}
return 0;
}
Ejercicio ciclo
Determinar si un valor dado pertenece a la serie de fibonacci
O determinar si un numero dado es fibonacci
Ejemplo
nro
Número dado 30
Para saber si pertenece a la serie, se debe conocer la serie, por lo que se debería generarla y mirar
si el número está o no en la serie. Para este número se tendría:
A B T T
0 1 1 2 3 5 8 13 21 34
¿T<NRO?
Con esto se concluye que el 30, no es un número de Fibonacci, porque no está en la serie donde
debería estar, que es entre el 21 y el 34, los demás valores que siguen, por la característica de la
serie serán mayores que el 30, y no tendría sentido seguir generando la serie.
Computacionalmente se hace el siguiente análisis.
Para el 30 se genera
0 1 1 2 3 5 8 13 21 34
Para el 21
0 1 1 2 3 5 8 13 21
Pasos
Leer el Numero
Generar la serie hasta el número evaluado
Preguntar si el último número generado es igual al número evaluado
Si es igual es Fibonacci
Sino es igual no es Fibonacci
NRO
Para el 21
A B T ...
A B T T T T T T T
0 1 1 2 3 5 8 13 21
La condición del ciclo que se va a generar queda
¿T<NRO?
Después del ciclo se pregunta
NRO = T
¿21 = 21?
Si
NRO es Fibonacci
Inicio
Leer NRO
A<-0
B<-1
T<-0 // T debe valer 0 para que también tome el 0 que si es fibonacci
Mientras ( T < NRO ) Hacer
T<-A+B
A<-B
B<-T
Fin mientras
Si ( NRO = T ) Entonces
Escribir NRO, " ES FIBONACCI "
Sino
Escribir NRO, " NO ES FIBONACCI "
Fin si
Fin

#include <iostream>
int main(){
int a,b,t,nro;
cout <<"Digitar numero => ";
cin>>nro;
a=0;
b=1;
t=0;
while (t<nro) { //llega hasta la frontera del numero a evaluar

t=a+b;
a=b;
b=t;
}
if (t==nro)
cout <<nro<<" es numero fibonacci ";
else
cout <<nro<<" no es numero fibonacci ";
return 0;
}
Los ejercicios realizados hasta el momento, utilizaron ciclos controlados por contadores o por
variables que tenían variaciones con resultados aritméticos, estos ciclos tienen un esquema
cuantitativo y generalmente se los utiliza cuando se conoce el número de veces que se va a repetir
el conjunto de acciones.
Ejercicios
Se tiene una cantidad de números dados.

- Determinar el mayor y el menor de los número primos
- Determinar el mayor de los fibonacci
- Determinar el mayor y el menor de los fibonacci.
- Determinar el promedio de los número fibonacci.
- Determinar el factorial de la diferencia del primo mayor con el primo menor
- Determinar si la diferencia del primo mayor con el fibonacci menor es un numero fibonacci
Ejercicio
Se tienen una cantidad de números dado, determinar el promedio de los números que son
fibonacci.
En los números pueden haber fibonacci y no fibonacci.
Datos numéricos 4 5 11 34
4 es fib?
(5+34)/2 = 19.5
Un dato a la vez
Leer cantidad de datos

Por cada dato de entrada // implica un ciclo
Determinar si es fibonacci
Si es fibonacci
Sumarlo y contarlo
Hallar el promedio con la suma y contador
Elementos claros
Entrada de varios datos
Sumador
Contador
Determinar si es fibonacci
Promedio
CDN : Cantidad de datos
CON : Contador de los datos que van a entrar
NRO : Variable donde van a entrar todos los datos
SUMF : sumador de los numeros fibonacci
CONF : Contador de los números fibonacci
A : para generar serie fibonacci
B : para generar serie fibonacci
T : para generar serie fibonacci
PROMF : promedio de fibonacci
Inicio
// leer cantidad de datos
Leer CDN
CON <- 0
SUMF<-0
CONF<-0
// Ciclo para la entrada de datos y evaluación
Mientras ( CON < CDN ) hacer
CON <- CON+1
Leer NRO
A<-0
B<-1
T<-0
Mientras ( T < NRO ) Hacer
T<-A+B
A<-B
B<-T
Fin Mientras
Si ( T= NRO) Entonces
SUMF <- SUMF+NRO
CONF<- CONF + 1
Fin si
Fin mientras
Si (CONF>0) Entonces
PROMF<-SUMF/CONF
Escribir “ Promedio = “,PROMF
Sino
Escribir “ No hay fibonacci”
Fin si
Fin
#include <iostream>
int main(){
int con,sumf,conf,a,b,t,nro,cdn;
float promf;
cout <<”Digitar cantidad de numeros => “;

cin>>cdn;
sumf=0;
conf=0;
con=0;
while (con<cdn){
con=con+1;
cout <<”Digitar numero => “;
cin>>nro;
//determinar si el nro es primo
a=0;
b=1;
t=0;
while (t<nro) { //llega hasta la frontera del numero a evaluar
t=a+b;
a=b;
b=t;
}
if (t==nro) {
sumf=sumf+nro;
conf=conf+1;
}
}
if (conf>0){
promf=(float)sumf/conf;
cout<<”Promedio de numeros fibonacci = “<<promf;
}
else
cout<<”no hay numeros fibonacci = “;
return 0;
}
Ejercicio ciclo
Se tiene una cantidad de numeros dada, determinar el primo menor de estos.
Ejemplo
Cantidad de numeros 6
Numeros dados 4 8 7 5 13 9
El primo menor es 5
Este es un ejemplo de lo que se pide, pero no es computacional.

Se debe tener presente en este ejercicio, que se va a obtener el menor de los primos de una
cantidad de datos, donde todos no son primos, por lo que se debe preguntar por cada dato leido,
si el dato es primo.
Ahora si el dato es primo debo tener en cuenta que si éste es el primero, para hacerlo hasta ese
momento el menor de los primos, como se lo explicó en ejercicios anteriores.
Si el primo no es el primero, significa que ya hay un primo menor con el que se puede comparar.
Como controlar que sea el primero
El primero se lo puede controlar con un contador de primos, de tal forma que cuando se
encuentre un primo se incremente en 1, y cuando este valga 1, significa que es el primer primo,
por lo tanto se lo determina como el menor, si hay más primos el contador se va a incrementar y
ya no va a ser 1 ahora vale 2 o más, indicando con esto, que ya no es el primero, por lo que cada
primo nuevo, se debería comparar con el menor que se lleve.
Con estas anotaciones planteamos el modelo mental siguindo la regla de un dato a la vez.
1 2 3 4 5 6
4 8 7 3 13 9

No No Si Si Si No
¿es el primero? ¿3 es el ¿13 es el
Si primero? primero?
Menor
7 No No
¿3<7? ¿13<3?
Si No
Menor
3
Resultado
Primo menor = 3
Identificación de variables y acciones

CDN
CN // asignación CN // asignación CN // asignación CN // asignación CN // asignación CN // asignación
1 2 3 4 5 6
NRO // Entrada NRO // Entrada NRO // Entrada NRO // Entrada NRO // Entrada NRO // Entrada
4 8 7 3 13 9
NRO // decisión NRO // decisión NRO // decisión NRO // decisión NRO // decisión NRO // decisión
No No Si Si Si No
¿7 es el primero? ¿3 es el ¿13 es el primero?
Si primero? NRO Menor
Menor NRO Menor No ¿13 < 3?
7 No ¿ 3 < 7? No
Si
Menor
3
Resultado
Menor
Primo menor = 3
Para la pregunta
¿NRO es primo?
Sabemos que no es computacional, esto implica que para determinar si NRO es primo, como se
dijo en el ejercicio anterior, se debe realizar varias intrucciones con las cuales se va a hallar la
cantidad de divisores exactos, para evaluarlo y determinar si es primo. El siguiente codigo
determina este proceso:
C<-0
CD<-0
Mientras ( C<NRO ) Hacer
C<-C+1
Si ( NRO mod C = 0) Entonces
CD <- CD+1
Fin si
Fin mientras
Si (CD = 2) Entonces // si es verdadero, es primo
CP<-CP+1
El número es primo si la condición anterior es verdadera y pasa a evaluar la siguiente pregunta
¿NRO es el primero?
Si
Menor
7
Como se dijo anteriormente se lo maneja con un contador CP que va a iniciar en 0 y se va a

incrementar cada vez que llegue un primo. Se sabrá que es el primero, cuando después de
incrementarse, el contador CP valga 1.
La pregunta anterior y la definicion del menor se transforma en computacionalmente en:
CP <- CP+1
Si ( CP = 1 ) Entonces // Indica que es el primero
Menor <- NRO
Sino // indica que ya no es el primero y lo debe comparar como lo muestra en el algoritmo
Algoritmo:
Inicio
Leer CDN
CP<-0
CN<-0
Mientras (CN<CDN) Hacer
CN<-CN+1
Leer NRO
C<-0
CD<-0
C<-C+1
CD <- CD+1
Fin si
Fin mientras
Si (CD = 2) Entonces
CP <- CP + 1
Si ( CP = 1 ) Entonces
Menor<-NRO
Sino
Si (NRO<Menor) Entonces
Menor <- NRO
Fin si
Fin si
Fin si
Fin mientras
Escribir “ Primo menor “,Menor
Fin
#include <iostream>
int main(){
int cn, nro,cdn,c,cd,cp,menor;
cout<<"Cantidad de numeros";
cin>>cdn;
cp=0;
cn=0;
while (cn<cdn){
cn=cn+1;
cout<<"Digitar numero => ";
cin >>nro;
c=0;
cd=0;
while (c<nro){
c=c+1;
if (nro%c==0){
cd=cd+1;
}
}
if (cd==2){
cp=cp+1;
if (cp==1)
menor=nro;
else{
if (nro<menor)
menor=nro;
}
}
}
cout<<"primo menor ="<<menor;
}
Ejercicio
Determinar el primo mayor y menor de una cantidad de números dada
Para este ejercicio se utiliza el mismo concepto de controlar el primero, ya que, todos los números
no son primos.
Inicio
Leer CDN
CP<-0
CN<-0
CN<-CN+1
Leer NRO
C<-0
CD<-0
C<-C+1
CD <- CD+1
Fin si
Fin mientras
CP <- CP + 1
Si ( CP = 1 ) Entonces
Menor<-NRO
Mayor<-NRO
Sino
Menor <- NRO
Fin si
SI (NRO>Mayor) Entonces
Mayor<-NRO
FinSi
Fin si
Fin si
Fin mientras
Escribir " Primo menor ",Menor
Escribir " Primo mayor ",Mayor
Fin
#include <iostream>
int main(){
int cn, nro,cdn,c,cdcp,menor,mayor;
cout<<”Cantidad de numeros”;
cin>>cdn;
cp=0;
cn=0;
while (cn<cdn){
con=con+1;
cout<<”Digitar numero => “;
cin >>nro;
c=0;
cd=0;
while (c<nro){
c=c+1;
if (nro%c==0){
cd=cd+1;
}
}
if (cd==2){
cp=cp+1;
if (cp==1) {
menor=nro;
mayor=nro;
}
else{
if (nro>mayor)
mayor=nro;
else
if (nro<menor)
menor=nro;
}
}
}
cout<<”primo menor =”<<menor;
cout<<”primo mayor =”<<mayor;
return 0;
}
Ahora se va a optimizar el manejo anterior en donde se utiliza un contador (cp) para determinar
situaciones específicas, introduciendo el concepto de variable bandera o switche.
Variable bandera o switche

La variable bandera, es un campo de memoria que durante la ejecución de un programa almacena
valores que le permite determinar si el flujo de ejecución de un programa pasa por un conjunto
de acciones específicas, con lo que se pueden tomar decisiones y volver así más óptimo el
programa.
Generalmente, esta variable toma dos valores 0 o 1, donde cada valor tiene un significado
específico. Esta bandera debe estar asociado con una condición que evalúa si el valor almacenado
es 0 o 1, y tomar las acciones respectivas.
Ejercicio
Se tiene una cantidad dada de números, determinar el primo menor de ellos.
Para este ejercicio se planteó la solución anterior, donde se controló el primer primo con un
contador CP, donde el valor de 1 indicaba que era el primero.
Esta parte del algoritmo se lo puede modificar utilizando una bandera o switche, el cual va a tener
dos comportamientos B=0 para indicar que es el primero y B=1 para indicar que ya pasó por el
primero. El resto del algoritmo permanece igual.
Entonces la pregunta
¿NRO es el primero?
Si
Menor
7
Como se dijo anteriormente se lo maneja con un contador CP que va a iniciar en 0 y se va a

incrementar cada vez que llegue un primo. Se sabrá que es el primero, cuando después de
incrementarse, el contador CP vale 1.
La pregunta anterior y la definicion del menor se transforma en computacionalmente en:
CP <- CP+1
Si ( CP = 1 ) Entonces // Indica que es el primero
Menor <- NRO
Para manejar este comportamiento con bandera se utiliza la bandera B inicialmente en 0

B<-0
…..
Si ( B = 0 ) Entonces // Indica que es el primero
Menor <- NRO
B<-1 // Cambia la bandera para que no vuelva a pasar por este camino
Inicio
Leer CDN
B<-0 // variable bandera, inicia en 0 para indicar que es el primero
CN<-0
CN<-CN+1
Leer NRO
C<-0
CD<-0
C<-C+1
CD <- CD+1
Fin si
Fin mientras
Si ( B = 0 ) Entonces
Menor<-NRO
B<-1 // Con esto se garantiza que no vuelva a pasar por estas acciones
Sino
Menor <- NRO
Fin si
Fin si
Fin si
Fin mientras
Escribir “ Primo menor “,Menor
Fin
Con la variable B se garantiza que si vale 0, es el primero, si vale 1, ya no es el primero, y se la

trabaja de la forma como se especifica en el ejercicio, lo que se encuentra con otro color indica
donde se colocan las acciones. Cuando se da el valor de 1 obliga a que el flujo del programa se
vaya por la otra situación, que es la de comparar el NRO con el valor.
La variable tipo bandera permite optimizar algunos algoritmos, sobretodo en el proceso de

ejecución. El siguiente ejercicio permite optimizar el algoritmo de un número primo.
#include <iostream>
int main(){
int cn, nro,cdn,c,cd,b,menor;
cout<<”Cantidad de numeros”;
cin>>cdn;
b=0;
cn=0;
while (cn<cdn){
cn=cn+1;
cout<<”Digitar numero => “;
cin >>nro;
c=0;
cd=0;
while (c<nro){
c=c+1;
if (nro%c==0){
cd=cd+1;
}
}
if (cd==2){
if (b==0){
menor=nro;
b=1;
}
else{
if (nro<menor)
menor=nro;
}
}
}
cout<<”primo menor =”<<menor;
return 0;
}
Ejercicio ciclo bandera 2

Determinar si un número dado es primo utilizando bandera.
El algoritmo para determinar si un valor es primo, se lo realiza utilizando el contador de divisores

exactos, el cual se avaluaba después del ciclo, para determinar si era o no primo.
El análisis fue el siguiente:
Número dado 7
7 mod 1 = 0? si 1
7 mod 2 = 0? no
7 mod 3 = 0? no
7 mod 4 = 0? no
7 mod 5 = 0? no
7 mod 6 = 0? no
7 mod 7 = 0? Si 2
Este es el comportamiento mental paso a paso para el 7.

El 7 es primo porque solo hay 2 números que lo dividen exactamente, el 1 y 7.
Y el algoritmo en seudocódigo fue el siguiente:
Inicio
Leer NRO
CN  0
CD  0
CN CN + 1
Entonces
CD  CD + 1
Fin si
Fin mientras
Si ( CD = 2)
Entonces
Sino
Fin si
Fin
Para implementarlo con bandera. Se va realizar lo siguiente.
Se lee un valor
Se va a tomar una variable bandera B que va a tomar el valor de 0
Realizar un ciclo controlado por un contador entre 2 y el número menos 1 (Se descarta el 1 y el
número mismo porque todo número es divisible exactamente por estos valores).
Dentro del ciclo, se aplica la operación residuo entre el numero y contador, y si hay un numero,
que lo divida exactamente cambia el valor de la bandera a 1.
Despues del ciclo se evalúa la bandera. Si B es 0, el número es primo, si es 1, el número no es
primo.
Análisis
Número dado 7
B=0
7 mod 2 = 0? no
7 mod 3 = 0? no
7 mod 4 = 0? no
7 mod 5 = 0? no
7 mod 6 = 0? no
B = 0?
Si 7 es primo
Para el numero 6 se tiene el siguiente modelo
Número dado 6
B <- 0
6 mod 2 = 0? si B<-1
6 mod 3 = 0? si B<-1
6 mod 4 = 0? no
6 mod 5 = 0? no
B=0?
No
6 no es primo.
El algoritmo elimina el contador de divisores y se incluye la variable bandera B, y queda así:
Inicio
Leer NRO
CN<- 1
B <- 0 // inicia la bandera en 0
Mientras (CN < NRO-1 ) Hacer
CN CN + 1
Entonces
B <-1 // cambia la bandera
Fin si
Fin mientras
Si ( B=0)
Entonces
Sino
Fin si
Fin
Lo que está en otro color es lo que se modifica para determinar si es primo.

#include <iostream>
int main(){
int cn, nro,b;

cin>>nro;
b=0;
cn=0;
while (cn<nro){
cn=cn+1;
if (nro%cn==0)
b=1;
}
if (b==0)
cout<<nro<<" es primo";
else
cout<<nro<<" no es primo";
return 0;
}
Cuando se utiliza una variable bandera, para optimizar más el programa, en el ciclo que controla el
proceso repetitivo, se introduce en la condición de control del ciclo la evaluación de la variable
bandera, generando condiciones compuestas controlando el ciclo.
Condición compuesta para controlar el ciclo.

El ejercicio anterior tiene una condición simple como control del ciclo, lo cual indica que se va a
recorrer todo el ciclo especificado. Con el concepto de bandera, no es necesario, ya que, si la
variable B cambia a 1, cuando hay un valor que lo divida exactamente, el número ya no es primo, y
no tiene sentido que lo siga evaluando.
Si se requiere que el ciclo termine inmediatamente se encuentre un valor que lo divida

exactamente, se debe incluir dentro de la condición que controla el ciclo, la evaluación de la
bandera de la siguiente forma:
B<-0
Mientras ( CN < NRO-1 and B=0 ) hacer
cn=1;
b=0;
while (cn <nro-1 && b==0)
Donde CN < NRO-1 and B=0 (cn <nro-1 && b==0) es una condición compuesta.
Esto significa que, que entra a realizar el ciclo si la condición es verdadera por lo que CN < NRO-1 y
B=0 deben ser verdaderas y dejará de ejercutarse cuando CN<NRO-1 o B=0 se vuelva falso.
La condición como es compuesta, se va a volver falso por lo siguiente:
- El ciclo puede terminar si CN<NRO-1 se vuelve falso, esto ocurrirá cuando un número es
primo, lo cual indica que la bandera B no cambia su valor de 0, porque ningún número entre 2
y el número evaluado-1, lo dividió exactamente.
- El ciclo puede terminar si B=0 se vuelve falso. Esto ocurrirá cuando hay un número que lo
divide exactamente, lo que hace que la bandera cambie a 1 (B<-1 o b=1).
En la primera situación el ciclo realiza todas las iteraciones. En la segunda el ciclo no realiza todas
las iteraciones, en el momento en que haya un valor que lo divida exactamente, la bandera cambia
a 1 (B<-1 o b=1) lo cual va a indicar que B=0 o b==0 se vuelve falsa y toda la condición compuesta
se vuelva falsa.
Ahora, si hay una condición compuesta, en ejecución no se va a saber por que termina el ciclo, una
de las dos, fue la que se volvió falsa, por lo que se debe programar, para que después del ciclo se
determine el porque de la salida. Si se trabaja con bandera, generalmente se evalúa la bandera,
porque el propósito del ciclo es determinar si es primo o no.
Si la bandera cambia, no es primo.
Si la bandera no cambia es primo.
El algoritmo es el siguiente:
Inicio
Leer NRO
CN<- 1
B <- 0 // inicia la bandera en 0
Mientras (CN < NRO-1 and B= 0) Hacer
CN CN + 1
Entonces
B <-1 // cambia la bandera
Fin si
Fin mientras
Si ( B=0)
Entonces
Sino
Fin si
Fin
También se pudo haber realizado lo siguiente después del ciclo. Preguntar si la que se volvió falsa
es la otra condición simple. Esto quedaría así:
Si ( CN=NRO-1)
Entonces
Sino
Fin si
Es importante tener en cuenta lo anterior cuando se trabaja con condiciones compuestas.

#include <iostream>
int main(){
int cn, nro,b;

cin>>nro;
b=0;
cn=1;
while (cn<nro-1 && b==0){
cn=cn+1;
if (nro%cn==0)
b=1;
}
if (b==0)
cout<<nro<<" es primo";
else
cout<<nro<<" no es primo";
return 0;
}
Manejo de banderas para conmutar procesos.
Dentro de la programación hay muchos procesos que necesitan estár conmutando entre 2 grupos
de acciones o más. Cuando se presenta esto, se utiliza una bandera para que controle esta
conmutación. La conmutación se realiza dentro de un ciclo, donde los grupos de acciones se
ejecutan alternadamente, durante un conjunto determinado de veces.
Ejercicio bandera
Generar una cantidad dada de términos de la siguiente serie:
4 9 7 12 10 15 13 18 16 21 19 24 22 27 25
La generación del número 9 se obtiene sumando 5 al 4, la generación de 7 se logra restando 2 al 9

y asi sucesivamente.
Entonces se tiene:
4 (+5) 9 (-2) 7(+5) 12(-2) 10(+5) 15(-2) 13(+5) 18
Si se va a trabajar con una variable bandera SW se tiene lo siguiente:
Si SW es igual a 0 se incrementa 5 al termino que se está trabajando.

Si SW es igual a 1 se resta 2 al termino que se está trabajando
El ejercicio plantea que sumar 5 y restar 2 se realiza en forma alterna, lo cual indica que si se
ejecutó la suma de 5 la siguiente vez se debe restar 2 y luego sumar 5 y después restar 2. Esto lo
coordina la bandera de la siguiente forma:
Entonces,
si SW = 0 se suma 5 y el SW debe cambiar a 1 para que la proxima vez vaya a restar 2.

si SW = 1 se resta 2 y el SW debe cambiar a 0 para que la proxima vez vaya a sumar 5.
4 (+5) 9 (-2) 7(+5) 12(-2) 10(+5) 15(-2) 13(+5) 18
Análisis con un dato a la vez

CT
Cantidad de términos 9
1 2 3 4 5 7 8 9
0 sw=0? sw=0? sw=0? sw=0? sw=0? sw=0? sw=0?
4 si no si no si no si
9 7 12 10 15 13 18
Con nombres de variables queda:
CT
NT NT NT NT NT NT NT NT
1 2 3 4 5 7 8 9
SW SW=0? SW=0? SW=0? SW=1? SW=0? SW=0? SW=0?
0 Si no si no si no si
T T T T T T T T
4 9<-4+5 7<-9-2 12 10 15 13 18
SW SW SW SW SW SW SW
1 0 1 0 1 0 1
CT
NT NT<-NT+1 NT<-NT+1 NT<-NT+1 NT<-NT+1 NT<-NT+1 NT<-NT+1 NT<-NT+1

1 2 3 4 5 6 7 8
SW Si (SW=0) Si (SW=0) Si (SW=0) Si (SW=0) Si (SW=0) Si (SW=0) Si (SW=0)
0 Si Si Si Si Si Si Si
T T<-T+5 T<-T+2 T<-T+5 T<-T-2 T<-T+5 T<-T-2 T<-T+5
4 9 7 12 10 15 13 18
SW <- 1 SW <- 0 SW <- 1 SW <- 0 SW <- 1 SW <- 0 SW <- 1
1 0 1 0 1 0 1
Algoritmo
Inicio
Leer CT
NT<-1
SW<-0
T<-4
Escribir T
Mientras ( NT < CT ) Hacer
NT <- NT + 1
Si (SW= 0) Entonces
T<-T+5
Escribir T
SW <- 1 // Garantiza que la proxima vez va a restar 2
Sino
T<-T-2
Escribir T
SW <- 0 // Garantiza que la proxima vez va a sumar 5
Fin si
Fin mientras
Fin
Lo que está en otro color determina como se maneja la variable bandera SW para que alterne
acciones.
Es importante tener bien claro el comportamiento de un ciclo, porque muchas veces se realizan
acciones para que se tengan en cuenta en la próxima iteración o repetición del ciclo, como fue el
caso de los números de fibonacci, donde se dejaban listos los valores de A y B para la siguiente
repetición. En este ejercicio ocurre lo mismo el SW queda listo para que en la siguiente iteración el
flujo de ejecución se vaya por el bloque de acciones que le corresponde.
#include <iostream>
int main(){
int ct,nt, sw,t;
cout<<”Cantidad de terminos => ”;

cin>>ct;
nt=1;
sw=0;
t=4;
cout<<”Término 1 -> ”<<t;
while (nt<ct) {
nt=nt+1;
if (sw==0){
t=t+5;
cout<<”\nTermino “<<nt<<” -> “<<t;
sw=1;
}
else{
t=t-2;
cout<<”\nTermino “<<nt<<” -> “<<t;
sw=0;
}
}
return 0;
}
Ejercicios
- Realizar un algoritmo que permita determinar si un número dado pertenece a la siguiete

secuencia
4 9 7 12 10 15 13 18
Ejercicio ciclos de aplicación

Se tiene una cantidad dada de números enteros, determinar si la suma de los dos primeros primos
es un número de fibonacci.
cdn
num
6 4 3 8 5 13
cp
P1
Primo 1 3
P2
Primo 2 5
sum
3+5 = 8
sum
8 es fibonacci?
si
Respuesta la suma de los dos primeros primos si es un número de fibonacci
Pasos genéricos
Definir variables
Determinar cantidad de datos
Leer dato por dato y realizar por cada dato
Determinar si es primo
Si es primo
Determinar si es el primero
Si es el primero marcarlo como primero
Sino es el primero
Determinar si es el segundo
Si es el segundo marcarlo como segundo
Sumar primo1 con primo2
Determinar si la suma es fibonacci
Este ejercicio para determinar el primer y el segundo primo utiliza un contador de primos, el cual
se va a incrementar cada vez que uno de los datos sea primo.
Cuando el contador de primos sea uno se puede obtener el primer primo en la variable p1, cuando
este sea 2 se obtiene el segundo primo en la variable p2, y para que no siga con el proceso se
utiliza una bandera para que termine el ciclo, igual que se hizo con los primos.
Para determinar si el número es primo se utiliza el segundo método con bandera.
Inicio
Leer cdn
Cn <- 0
Cp <- 0
B1 <- 0
Mientras ( Cn < cdn & B1 = 0 ) hacer // controla la entrada de numeros
Cn<-Cn+1
Leer Num
c <- 1
b2 <- 0
Mientras (c < Num-1 & b2=0) hacer // Para determinar si es primo
c <- c+1
Si (Num mod c = 0) Entonces
b2 <- 1
Fin si
Fin mientras
Si ( b2=0) Entonces // El numero es primo
cp<-cp+1
Si (cp = 1) Entonces
p1<-Num // Se obtiene el primer primo
sino
si ( cp= 2) Entonces
p2<-Num // Se obtiene el segundo primo
B1 <- 1
fin si
fin si
fin si
Fin mientras
Sum <- p1+p2
A<-0
B<-1
T<-0
Mientras ( T < Sum ) Hacer // Genera serie de fibonacci hasta sum
T<-A+B
A<- B
B <- T
Fin mientras
Si ( T = Sum ) Entonces // Evalua si es fibonacci
Escribir “La suma ”, Sum, “ es fibonacci ”
Sino
Escribir “La suma ”, Sum, “ no es fibonacci ”
Fin si
Fin
#include <iostream>
int main(){
int cdn,cn,nro,c,cp,b1,b2,p1,p2,sum,a,b,t;
cout<<”Cantidad de numeros -> ”;
cin>>cdn;
cn=0;
b1=0;
cp=0;
while (cn<cdn && b1==0){
cn=cn+1;
cout<<”Digitar numero “<<cn<<” -> “;
cin>>nro;
c=1;
b2=0;
//determina si el nro es primo
while (c<nro-1&&b2==0){
c=c+1;
if (nro%c==0)
b2=1;
}
if (b2==0){
cp=cp+1;
//determina si es el primer primo
If (cp==1)
p1=nro;
else
// determina si es el segundo primo
if (cp==2)
p2=nro;
b1=1; //cambia la bandera para terminar búsqueda
}
}
sum=p1+p2;
// determina si la suma de los primos es un número fibonacci
a=0;
b=1;
t=0;
while (t<sum){
t=a+b;
a=b;
b=t;
}
if (t==sum)
cout<<”la suma de los primos “<<sum<<” es un numero fibonacci “;
else
cout<<”la suma de los primos “<<sum<<” no es un numero fibonacci “;
return 0;
}
Ejercicio con validación de los dos números primos

#include <iostream>
int main(){
int cdn,cn,nro,c,cp,b1,b2,p1,p2,sum,a,b,t;
cout<<"Cantidad de numeros -> ";

cin>>cdn;
cn=0;
b1=0;
cp=0;
p1=0;
p2=0;
while (cn<cdn && b1==0){
cn=cn+1;
cout<<"Digitar numero "<<cn<<" -> ";
cin>>nro;
c=1;
b2=0;
//determina si el nro es primo
while (c<nro-1&&b2==0){
c=c+1;
if (nro%c==0)
b2=1;
}
if (b2==0){
cp=cp+1;
//determina si es el primer primo
if (cp==1)
p1=nro;
else
// determina si es el segundo primo
if (cp==2){
p2=nro;
b1=1;
} //cambia la bandera para terminar búsqueda
}
}
if (p1!=0&&p2!=0){
sum=p1+p2;
// determina si la suma de los primos es un número fibonacci
a=0;
b=1;
t=0;
while (t<sum){
t=a+b;
a=b;
b=t;
}
if (t==sum)
cout<<"la suma de los primos = "<<sum<<" es un numero fibonacci ";
else
cout<<"la suma de los primos = "<<sum<<" no es un numero fibonacci ";
}
else
cout<<"no hay dos numeros primos";
return 0;
}
Ejercicio de aplicación
Realizar un programa para el manejo de los pagos de los empleados de una empresa X, que tiene
la siguiente información:
Cantidad de empleados
Por cada empleado:
Código empleado
Valor de la hora
Porcentaje de descuento
Para que entregue la siguiente información:
Resultados
Por cada empleado
Codigo y sueldo Neto a pagar
Por todos los empleados
Total sueldos pagados

Total descuentos
Ejemplo
Numero de empleados 2
_________________________________________________
Número empleado 1
Codigo1 1
Numero de Horas 20
Valor de hora 30000
Descuento 10%
Total sueldo 20*30000=600000

Descuento 600000*10/100 = 60000
Sueldo Neto 600000-60000=540000
Salida Codigo 1 Sueldo Neto 540000
Suma neto 540000

Suma Descuento 60000
_________________________________________________
Numero empleado 2
Codigo2 2
Numero de Horas 30
Valor hora 50000
Descuento 15%
Total Sueldo 30*50000=1500000

Descuento 1500000*15/100 = 225000
Sueldo Neto 1500000-225000 = 1275000
Salida Codigo 2 Sueldo Neto 1275000
Suma neto 1775000

_________________________________________________
Resultado Total sueldo empleados 1775000

Total descuentos 285000
Para este ejercicio se tiene en cuenta que por cada empleado se tiene que los campos
determinados sirven para leer la información de todos los empleados, por lo que, al leer la
información de cada empleado se deben realizar los cálculos pertinentes, como están
especificados en el ejemplo. Si esto no se realiza, cuando llegue el siguiente empleado borra la
información del actual, y ya no se podrán realizar los cálculos.
Este ejemplo tiene solo dos empleados, pero el modelo sirve para cualquier cantidad de
empleados.
Ejemplo con nombres de variables
Ejemplo
NEMP
Numero de empleados 2
_______________________________________________________
CE
Numero empleado 1
CODE
Codigo1 1
NHT
Numero de Horas 20
VALH
Valor de hora 300000
DES
Descuento 10%
NHT VALH SUELT
Total sueldo 20 * 30000 = 600000
SUELT PDESC DESCUENTO
Descuento 6000000 * 10 / 100 = 60000
SUELT DESCUENTO SUELN
Sueldo Neto 6000000 - 60000 = 540000
CODE SUELN
Resultado Codigo E001 Sueldo Neto 540000
SUMS
Suma neto 540000
SUMD
__________________________________________________________
CE
Numero empleado 2
CODE
Codigo2 2
NHT
Numero de Horas 30
VALH
Valor hora 50000
PDESC
Descuento 15%
NHT VALH SUELT

Total Sueldo 30 * 50000 = 1500000
Descuento 1500000 * 15/100 = 225000
Sueldo Neto 1500000 - 225000 = 1275000
CODE SUELT
Resultado Codigo E002 Sueldo Neto 1275000
SUMS
Suma neto 1775000
SUMD
_________________________________________________________________
SUMS
SUMD
El ejemplo anterior tiene 2 registros.
NUME : Número de empleados numérico entero
CE : Contador de empleados numérico entero
CODE : Codigo del Empleado tipo alfanumérico
NHT : Número de horas trabajadas numerico entero
VALH : Valor hora numerico real
PDESC : Porcentaje descuento numerico entero
SUELT : Suedo total empleado numérico real
DESCUENTO : Descuento empleado numerico real
SUELN : Sueldo Neto empleado numerico real
SUMS : Acumulador sueldos netos numérico real
SUMD : Acumulador descuentos numérico real
La información de los empleados son por entrada

Todos los calculos son por asignación
Sumadores por asignación, teniendo en cuenta en iniciarlos en 0 antes de ciclo.
Algoritmo completo
Inicio
Leer NUME
SUMS <- 0
SUMD <- 0
CE <- 0
Mientras ( CE < NUME) Hacer
CE<-CE + 1
Leer CODE
Leer NHT
Leer VALH
Leer DESC
SUELT <- NHT * VALH
DESCUENTO <- SUELT * DESC/100
SUELN <- SUELT – DESCUENTO
Escribir “ Código Empleado “, CODE, “ Sueldo Neto “, SUELN
SUMS <- SUMS + SUELN
SUMD <- SUMD + DESCUENTO
Fin mientras
Escribir “ TOTAL SUELDO EMPLEADOS “, SUMS
Escribir “ TOTAL DESCUENTOS “, SUMD
Fin
Ejercicio anterior con diseño de entrada de información. Las modificaciones se limitan a establecer
un mensaje manejado con instrucciones de escribir, que detallan la información que se debe
digitar.
Esto hace parte del diseño, por lo que toma gran importancia cuando se selecciona el lenguaje de
programación en la fase de compilación
Si se tiene un material educativo computacional como el PseInt, se puede realizar aspectos que
tienen que ver con diseño, como en el siguiente caso:
Inicio
Escribir " CANTIDAD DE EMPLEADOS "
Leer NUME
SUMS <- 0
SUMD <- 0
CE <- 0
Mientras ( CE < NUME) Hacer
CE<-CE + 1
Escribir " CODIGO EMPLEADO "
Leer CODE
Escribir " HORAS TRABAJADAS "
Leer NHT
Escribir " VALOR HORA "
Leer VALH
Escribir " DESCUENTO "
Leer DESC
SUELT <- NHT * VALH
SUELN <- SUELT - DESCUENTO
Escribir " Código Empleado ", CODE, " Sueldo Neto ", SUELN
Fin mientras
Escribir " "
Escribir " TOTAL SUELDO EMPLEADOS ", SUMS
Escribir " TOTAL DESCUENTOS ", SUMD
fin

NUME : Número de empleados numérico entero
CE : Contador de empleados numérico entero
#include <iostream>
int main(){
// definición de variables
int nume,ce,code,nht,valh,pdesc,suelt;
float descuento,sueln,sums,sumd;
cout << "Cantidad de empleados ";

cin >>nume;
sums=0;
sumd=0;
ce=0;
while(ce<nume) {
ce=ce+1;
cout<<"\n Codigo empleado -> ";
cin>>code;
cout<<"\n Horas trabajadas -> ";
cin>>nht;
cout<<"\n Valor hora -> ";
cin>>valh;
cout<<"\nPorcentaje de descuento -> ";
cin>>pdesc;
suelt=nht*valh;
descuento=suelt*pdesc/100;
sueln=suelt-descuento;
//muestra información de un empleado
cout<<"\nCodigo empleado "<<code<<" Sueldo neto "<<sueln;
sums=sums+sueln;
sumd=sumd+descuento;
}
//Resultados totales
cout<<"\nTotal sueldos pagado "<<sums;
cout<<"\nTotal descuentos "<<sumd;
}
Ejercicio de aplicación de ciclos.
Para una empresa X se requiere realizar un programa que haga el calculo del valor a pagar a cada
uno de sus empleados, para lo cual se tiene la siguiente información:
Cantidad de empleados
Por cada empleado se tiene:
Código empleado
Número de Horas Trabajadas
Valor de la Hora
Para cada empleado se realiza un descuento de la siguiente forma:
Si el sueldo total está entre 0 – 200000 descuento del 5%
Si sueldo total está entre 200001 – 500000 descuento del 10%
Si Sueldo total es mayor que 500000 descuento del 12%
Resultados
Sueldo neto por cada empleado

Con Código y sueldo Neto.
Total valor pagado (sueldos netos)

Total de descuentos
Empleado que más gana (codigo y valor pagado)

Empleado que menos gana ( codigo y valor pagado)
Promedio de sueldos
Promedio de descuentos
Para este ejercicio se deben tener bien claro los siguientes conceptos.
Entrada de varios datos controlados por ciclos, para la entrada de cada uno de los empleados.
Control de un ciclo con contador
Calculos con acciones de asignación
Acciones de decisión para controlar los descuentos
Obtener el mayor y el menor de varios datos
Sumar varios datos, para la suma total de los sueldos y descuentos
Contador para el cálculo de promedios
Con todos los ejercicios anteriores se tiene ya se tiene la destreza para solucionar este problema.
Modelo mental
Modelo computacional
Algoritmo
Esquema cualitativo con respecto a los ciclos.
Todos los ejercicios anteriores trabajados con ciclos, fueron controlados por contadores o por
condiciones que eran el resultado de operaciones aritméticas, como en el caso de los números
fibonacci, donde el T estaba en función de la suma de A y de B. En esencia estos ciclos que erán
controlados de esta forma, se denomina control de ciclos con un esquema cuantitativo.
Ahora y como complemento a lo anterior se tiene, que un ciclo también puede ser controlado con
un esquema cualitativo, el cual se describe a continuación.
Control de un ciclo con esquema cualitativo.
Este esquema se presenta generalmente, cuando no se conoce el número de veces que se va a

repetir un conjunto de instrucciones dentro de un ciclo.
Como no se conoce la cantidad de datos que van a llegar, entonces en la entrada de datos se
deben especificar algunas características que determine o demarque hasta donde se debe entrar
los datos. Generalmente la información que demarca hasta donde se debe llegar es una
información inválida para ser procesada.
Registro.
Conjunto de campos de memoria agrupados, con el objeto de manejar información relacionada y
que hace referencia a una situación, objeto, individuo etc.
Ejemplo
Registro empleado. Puede tener los siguientes campos
Código Empleado
Cédula
Nombres
Apellidos
Cargo
Fecha Ingreso
Fecha de Nacimiento
Son campos relacionados que me va a manejar información específica de un empleado en

particular.
Hasta el momento en algunos ejercicios que se han realizado se ha trabajado con registros y en
especial con información de empleados para el cálculo del sueldo neto.
Dentro de la temática del manejo de ciclos con esquema cualitativo se trabaja mucho con el
concepto de registro y se tienen los siguientes conceptos:
Registro centinela. Para el procesamiento de varios registros donde no se conoce exactamente

cuantos vienen, se maneja este concepto y se determina como registro centinela al último
registro que va a entrar y no tiene información válida. Cuando este registro llega indica de que no
hay más datos o no hay más registros para ser procesados.
Campo Centinela. Del grupo de campos de un registro, se determina un campo que va a llevar la
marca de fin de registros, generalmente es un código que identifica el registro, en el empleado
puede ser código del empleado o la cédula, y su valor debe ser del mismo tipo pero no debe estar
en el rango de los datos validos de procesamiento.
Ejemplo. Registro empleado

Registro centinela: Registro que tiene en el campo código empleado 9999
Campo centinela: Código empleado

Valor centinela: 9999
Dentro de la asignación de los códigos de una empresa se debe tener claro que el código 9999 no
debe ser asignado a ningún empleado, y va a servir para procesar información en diferentes
aplicativos que se relacionen con registros de empleados.
Entrada de registros con valor centinela
Para entrar información de varios registros que no se tiene la cantidad de registros, pero se sabe
que el último registro viene con un valor centinela se realiza lo siguiente.
Leer Campo centinela del registro

Mientras ( Campo Centinela <> del Valor Centinela) hacer
Leer Siguientes campos de registro
Trabajar con el registro
Leer Campo Centinela siguiente registro

Fin mientras
Con el empleado sería lo siguiente:

Campo centinela CodigoEmpleado
Valor centinela 9999
Esto significa que ningún empleado debe tener asignado el codigo 9999 y que cuando llegue este
valor centinela significa el fin de los registros, por lo tanto, no deben leerse más campos.
Por cada empleado van a llegar varios registros o ninguno por lo que cabe la posibilidad de que
solo haya el registro centinela.
Cuando se trabaja con registros centinela, la lectura del registro no se lo hace en su totalidad, se
lee primero el campo centinela, y si este es de un registro válido, dentro del ciclo se lee el resto de
los campos, de la siguiente forma:
Leer CodigoEmpleado
Mientras ( CodigoEmpleado <> 9999) Hacer
Leer otros campos del registro
Acciones con el registro empleado.
Leer CodigoEmpleado
Fin mientras
Leer CODE
Mientras ( CODE <> 9999) Hacer
Leer NHT,VHT,DES
Acciones con el registro empleado.
Leer CODE
Fin mientras
Ejercicio ciclos cualitativos

Realizar el calculo de los sueldos de los empleados que tienen registros con la siguiente
información
Código empleado
Numero de horas trabajadas
Valor de la hora
Porcentaje de descuento
El último registro tiene en su campo código 999

Para este ejercicio se tiene en cuenta que por cada empleado se tiene un registro y los campos
determinados sirven para leer la información de todos los empleados, por lo que se debe realizar
las acciones pertinentes por cada empleado que son la siguientes.
Sueldo neto por empleado
Acumulación del sueldo neto

Acumulación del descuento
Resultados
Sueldo neto por cada empleado
Código Empleado
Total sueldos pagados

Total descuentos
Ejemplo
Codigo1 E001
Numero de Horas 20
Valor de hora 30000
Descuento 10%
Total sueldo 20*30000=600000

Descuento 600000*10/100 = 60000
Sueldo Neto 600000-60000=540000
Salida Codigo E001 Sueldo Neto 540000
Suma neto 540000

Codigo2 E002
Numero de Horas 30
Valor hora 50000
Descuento 15%
Total Sueldo 30*50000=1500000

Descuento 1500000*15/100 = 225000
Sueldo Neto 1500000-225000 = 1275000
Suma neto 1775000

Codigo 3 9999 // Fin de los empleados

Este ejemplo tiene solo dos empleados, el último registro tiene en el código de empleado 9999 por
lo tanto indica que no hay más.
Ejemplo con nombres de variables
Ejemplo
_______________________________________________________
CODE
Codigo1 E001
NHT
Numero de Horas 20
VALH
Valor de hora 300000
DES
Descuento 10%
NHT VALH SUELT
Total sueldo 20 * 30000 = 600000
Descuento 6000000 * 10 / 100 = 60000
Sueldo Neto 6000000 - 60000 = 540000
CODE SUELN
SUMS
Suma neto 540000
SUMD
__________________________________________________________
CODE
Codigo2 E002
NHT
Numero de Horas 30
VALH
Valor hora 50000
PDESC
Descuento 15%
NHT VALH SUELT

Total Sueldo 30 * 50000 = 1500000
Descuento 1500000 * 15/100 = 225000
Sueldo Neto 1500000 - 225000 = 1275000
CODE SUELT
SUMS
Suma neto 1775000
SUMD
_________________________________________________________________
Codigo3 9999 // Fin de los empleados
__________________________________________________________________
SUMS
SUMD
El ejemplo anterior tiene 3 registros, los dos primeros con valores válidos, y el tercero con valores
de fin de archivo, el cual solo tiene valor en el campo centinela CODE cuyo valor es 9999. En los
demás campos no hay valores validos, por eso no hay que leerlos.

Los registros de los empleados son por entrada

Todos los calculos son por asignación
Sumadores por asignación, teniendo en cuenta en iniciarlos en 0 antes de ciclo.
Por cada empleado, se utilizan las mismas variables, esto permite trabajar con ciclos y servirá para
cualquier cantidad de empleados.
Manejo del ciclo con valor centinela
Leer CODE
Leer NHT
Leer VALH
Leer DESC
SUELT <- NHT * VALH
Leer CODE
Fin mientras
Según el enfoque cualitativo, primero se lee el código ( Leer CODE) antes de ciclo, si el registro es
válido, entra al ciclo y lee los demás campos del registro (NHT,VALH, DESC ).
La última instrucción del ciclo es leer nuevamente el codigo del empleado unicamente (Leer
CODE), así, para el ultimo registro que es 9999, solo se leería este campo, y cuando se evalue en la
condición el ciclo va a terminar.
Algoritmo completo
Inicio
SUMS <- 0
SUMD <- 0
Leer CODE
Leer NHT
Leer VALH
Leer DESC
SUELT <- NHT * VALH
Leer CODE
Fin mientras
Escribir “ TOTAL SUELDO EMPLEADOS “, SUMS
Escribir “ TOTAL DESCUENTOS “, SUMD
Fin
Según lo anterior:
CODE es el campo centinela y 9999 es el valor centinela, esto indica que al llegar este valor el ciclo
termina y por lo tanto la llegada de más datos de empleados.
#include <iostream>
int main(){
int code,nht,valh,pdesc,suelt;
float descuento,sueln,sums,sumd;
sums=0;
sumd=0;
cout<<”\n Codigo empleado -> ”;
cin>>code;
while(code!=9999) {
cout<<”\n Horas trabajadas -> ”;
cin>>nht;
cout<<”\n Valor hora -> ”;
cin>>valh;
cout<<”\nPorcentaje de descuento -> ”;
cin>>pdesc;
suelt=nht*valh;
descuento=suelt*pdesc/100;
sueln=suelt-descuento;
//muestra información de un empleado
cout<<”Codigo empleado “<<code<<” Sueldo neto ”<<sueln;
sums=sums+sueln;
sumd=sumd+descuento;
cout<<”\n Codigo empleado -> ”;
cin>>code;
}
//Resultados totales
cout<<”Total sueldos pagado “<<sums;
cout<<”\nTotal descuentos “<<sumd;
}
Ejercicio ciclo esquema cualitativo

Realizar un algoritmo que determine el promedio de los números pares positivos. Terminar
cuando llegue un número negativo.
El anterior ejercicio, no me plantea la cantidad de datos, pero si me establece que los números son
positivos, por lo que se puede tener la condición del ciclo de entrada de datos, mientras el
número de entrada sea positivo.
Esto quiere decir que los datos van a llegar hasta que el dato de entrada sea negativo.
Numeros de entrada 3 8 5 10 30 7 -5
Promedio pares 8 + 10 +30 = 48 = 16

3 3
Con un dato a la vez y con nombres
NRO ¿3>0? ¿8>0? ¿5>0? ¿10>0? ¿30>0? ¿7>0?

3 Si Si Si Si Si Si

3 es par? 8 es par? 5 es par? 10 es par? 30 es par? 7 es par?
No Si No Si Si No
SP SP SP
8 18 48
CP CP CP
1 2 3
8 5 10 30 7 -5
SP CP PROMP
PROMP 48 / 3 = 16
PROMP
Promedio pares = 16
El tratamiento de esta información tiene el mismo comportamiento que el ejercicio anterior,

donde el campo NRO va a ser el campo centinela, y el valor centinela sera cualquier valor negativo,
en el ejemplo es el -5
Como en el ejercicio anterior lo primero que se hace es leer antes de ciclo el primer valor para
NRO que en el ejemplo vale 3 que es un valor positivo por lo que el valor entra al ciclo a evaluarse
si es par.
Ahora, si el primer valor es negativo, no va a entrar al ciclo y no habrá promedio.
Con un dato a la vez y con nombres
¿NRO>0? ¿NRO>0? ¿NRO>0? ¿NRO>0? ¿NRO>0? ¿NRO>0?

NRO // Entrada Si Si Si Si Si Si
3 NRO// Decision NRO// Decision NRO// Decision NRO// Decision NRO// Decision NRO// Decision
3 es par? 8 es par? 5 es par? 10 es par? 30 es par? 7 es par?
No Si No Si Si
SP SP SP No
8 18 48
CP CP CP
1 2 3
NRO// Entrada NRO// Entrada NRO// Entrada
5 30 7
NRO// Entrada NRO// Entrada NRO// Entrada
8 10 -5
SP CP PROMP
PROMP 48 / 3 = 16
PROMP
Promedio pares = 16
El modelo anterior presenta la pregunta ¿NRO>0?, lo que se entiende que por cada iteración se
hace la pregunta
NRO :Campo numérico para la entrada de todos los datos. Entero
SP :Acumulador de los números pares. Entero
CP :Contador de números pares. Entero
PROMP :Promedio de los números pares. Real
Inicio
SP <- 0
CP <- 0
Leer NRO
Mientras ( NRO > 0 ) Hacer
Si ( NRO mod 2 = 0) Entonces
SP <- SP+NRO
CP <- CP + 1
Fin si
Leer NRO
Fin mientras
Si ( CP > 0 ) Entonces
PROMP <- SP/CP
Escribir “Promedio Pares = “, PROMP
Sino
Escribir “No hay numeros pares “
Fin si
Fin
#include <iostream>
int main(){
int nro,sp,cp;
float promp;
sp=0;
cp=0;
cout<<”\n Digitar numero -> ”;
cin>>nro;
while (nro>0){
if (nro%2==0){
sp=sp+nro;
cp=cp+1;
}
cin>>nro;
}
if (cp>0){
promp=(float)sp/cp;
cout<<”Promedio de números pares -> “<<promp;
}
else
cout<<”No hay números pares “;
return 0;
}
Rompimiento de control
Uno de los conceptos que tienen gran aplicabilidad dentro de la computación, es el agrupamiento
de información y la toma de decisiones por cada grupo de datos. Esto obliga a que la información
esté agrupada por uno o varios campos.
Ejemplo 1
Un ejemplo claro es un directorio telefónico que está agrupado por apellido y dentro de apellido,
por nombres.
En el directorio vamos a encontrar que por un mismo apellido hay varias repeticiones y dentro de
estos apellidos van a existir varios usuarios con nombres repetidos, este orden facilita el buscar un
número telefónico.
Ejemplo. 2
En una empresa X se puede tener varios departamentos (contabilidad, informática, producción,
ventas, entre otros), identificados por un codigoDepartamento, y en cada departamento varios
empleados. Si la información de los empleados está agrupada por departamentos, se podría
determinar que pasa con cada departamento.
- Cuantos empleados tiene cada departamento
- Que departamento es el que más pagó por nómina
- Que departamento es el que más gasta.
Entre otros.
La agrupación de esta información tiene las siguientes características:

- No se conoce la cantidad de registros. Esto implica que debe manejarse con registro centinela
y por tanto un campo centinela y un valor centinela.
- No se conoce la cantidad de elementos por grupo. Esto implica que se debe controlar el fin de
un grupo, y el comienzo de otro, esto se lo realiza con un Rompimiento de Control.
Rompimiento de Control. Se presenta cuando la información se encuentra agrupada, y se habla de

un rompimiento de control cuando termina la información de un grupo e inicia otro
Ejemplo
La siguiente cantidad de números viene agrupada de la siguiente forma.
3 3 3 3 3 5 5 5 7 7 7 7-5
Aquí se presentan tres rompimientos de control, cuando se termina los 3 y comienza el 5., y
cuando termina el 5 y comienza el 7 y cuando termina el 7 y llega el fin de datos que es -5
Como se trabaja el rompimiento de control
El rompimiento de control puede tener diferentes niveles, la siguiente explicación muestra como
se debe trabajar el rompimiento de control de un nivel.
Para un nivel de rompimiento de control se lo trabaja con dos ciclos anidados.
Ciclo externo . Controla la entrada de los datos y lo hace con registro centinela
Ciclo interno. Controla el rompimiento de control
Los dos ciclos van a trabajar con un campo centinela, como se había trabajado anteriormente.
Para el ciclo interno, se debe trabajar con un Campo Centinela auxiliar que va a controlar el valor
a repetir dentro del grupo. Esto se especifica en forma genérica de la siguiente forma:
Leer CampoCentinela
Mientras ( CampoCentinela <> ValorCentinela) Hacer
CentinelaAux <- CampoCentinela
Mientras ( CampoCentinela = CentinelaAux ) Hacer
Leer Siguientes campos del registro
Trabajar con el registro
Leer CampoCentinela
Fin mientras
Acciones a realizar con el grupo
Fin mientras
El campo CentinelaAux va a guardar el valor representativo del grupo el cual se va comparando

con el campoCentinela que va avanzando en el grupo, y mientras sean iguales estarán dentro del
grupo. Cuando sean diferentes significa que el grupo acaba o es el fin de los datos. El siguiente
ejercicio clarifica este concepto.
Ejercicio
Se tiene una cantidad de datos numéricos con valores repetidos y agrupados, determinar cual es el
dato que se repite y las veces que lo hace. Los datos son positivos y termina con -5
Ejemplo
3 3 3 7 7 7 7 13 13 13 -5
Resultado 3 3 veces
7 4 veces
13 3 veces
Modelo con nombres
Ejemplo
Nro Nro Nro Nro Nro Nro
3 3 3 7 7 7 7 13 13 13 -5
Aux Aux Aux
1 2 3 1 2 3 4 1 2 3
Aux CG
Resultado 3 3 veces
Aux CG
7 4 veces
Aux CG
13 3 veces
De lo anterior se puede concluir que cada vez que termine un grupo se debe mostrar los
resultados con ese grupo, en este caso mostrar el contador de grupo
Modelo mental con un dato a la vez
Nro Nro <> Nro Nro <> Nro<

3 -5? <> -5? -5? > -5
3<>5? 7<>5? 13<>5 -
Si Si ? 5<>5?
Aux Aux Si No
3 7 Aux
Nro= Nro= 13
Aux? Aux? Nro=
3=3? 7=7 Aux? Nro= Nro= Nro=
Si Si 13=13 Aux? Aux? Aux?
Nro= Nro= Nro= Nro= Nro= Nro= Nro=
CG 1 Si 13=13 13=13 -5=13
Aux? Aux? Aux? Aux? Aux? Aux? Aux?
1 Nro 1 Si Si No
3=3? 3=3? 7=3? 7=7 7=7 7=7 13=7
Nro 7 Nro 2 3 Escribir
Si Si No Si Si Si No
3 13 Nro Nro Aux
CG CG Escribir 2 3 4 Escribir
13 -5 13
2 3 Aux Nro Nro Nro Aux
CG
Nro Nro 7 7 7 13 7
3
3 7 CG CG
3 4
El cuadro anterior muestra lo que se realiza en los dos ciclos, la pregunta Nro<>-5? es la del ciclo
externo y la pregunta Nro=Aux? controla el ciclo interno.
El valor de Aux, permanece constante controlando la permanencia en el grupo, hasta que en Nro
llegue la información del siguiente grupo o la terminación de los datos.
Las evaluaciones del ciclo externo se presentan cuando el ciclo interno termina.
Las actividades repintadas determinan las acciones que se realizan después de cada grupo.
Cuando llega el valor centinela -5 hace que se salga de los dos ciclos.
Dentro del ciclo interno se realiza la lectura de proximo valor por lo que el ciclo termina.
Definicion de variables
Nro : Campo numérico entero para la entrada de los enteros

Aux : Campo numérico entero para almacenar representante del grupo
CG : Campo numérico entero, contador de elementos de cada grupo
Algoritmo
Inicio
Leer Nro
SF<-0
Mientras (Nro > 0) Hacer
Aux <- Nro // En Aux se guarda el representante del grupo
CG <- 0
Mientras ( Nro = Aux ) Hacer // recorre el grupo
CG <- CG + 1
Leer Nro
Fin mientras
Escribir “ Grupo “, Aux, “ “, CG, “ Veces “
Fin Mientras
Fin
#include <iostream>
int main(){
int nro,aux,cg;
cin>>nro;
while (nro>0){
aux=nro; // determina el representante del grupo que va a iniciar
cg=0;
while (nro==aux){
cg=cg+1;
cin>>nro;
}
//cuando se sale del ciclo, termina un grupo
cout<<”\n Grupo -> ”<<aux<<” “<<cg<<” veces”;
}
return 0;
}
Este programa termina cuando se digite un valor negativo
Se debe tener en cuenta que los datos deben entrar agrupados, de lo contrario, no se puede
manejar el rompimiento de control.
Cuando se maneje el concepto de arreglo de datos, ya se los puede agrupar dentro de la memoria
y se puede aplicar el rompimiento de control.
Ejercicio rompimiento de control 2

Se tiene una cantidad de datos numéricos con valores repetidos y agrupados, determinar cual es el
dato que se repite y las veces que lo hace, y el grupo que más datos repetidos tiene. Los datos son
positivos y termina con -5.
Ejemplo
3 3 3 7 7 7 7 13 13 13 -5
Resultado 3 3 veces
7 4 veces
13 3 veces
Resultado
Grupo de mayor repetidos 7 Cantidad de repetidos 4
Modelo con nombres
Ejemplo
Nro
3 3 3 7 7 7 7 13 13 13 -5
Aux CG
Resultado 3 3 veces
Aux CG
7 4 veces
Aux CG
13 3 veces
Resultado DMY GMY
El comportamiento es el mismo anterior pero tiene una variación, despues de contar los
elementos de cada grupo y mostrarlo, hace la comparación de que grupo es el mayor. Para esto
utilizamos dos variables.
GMY Contador grupo mayor

DMY almacena al representante del grupo
GMY lo iniciamos en 0, para que cambien con el contador del primer grupo que llegue
DMY lo iniciamos en -5, que es el valor centinela.
Nro Nro <> Nro Nro <> Nro<

3 -5? <> -5? -5? > -5
3<>5? 7<>5? 13<>5 -
Si Si ? 5<>5?
GMY
Aux Aux Si No
0
3 7 Aux
Nro= Nro= 13
DMY Aux? Aux? Nro=
-5 3=3? 7=7 Aux? Nro= Nro= Nro=
Si Si 13=13 Aux? Aux? Aux?
Nro= Nro= Nro= Nro= Nro= Nro= Nro=
CG 1 Si 13=13 13=13 -5=13
Aux? Aux? Aux? Aux? Aux? Aux? Aux?
1 Nro 1 Si Si No
3=3? 3=3? 7=3? 7=7 7=7 7=7 13=7
Nro 7 Nro 2 3 Escribir
Si Si No Si Si Si No
3 13 Nro Nro Aux
CG CG Escribir 2 3 4 Escribir
13 -5 13
2 3 Aux Nro Nro Nro Aux
CG
Nro Nro 7 7 7 13 7
3
3 7 CG CG
3 4
CG>GM CG>GM CG>GM

Y? Y? Y?
3>0? 3>0? 3>0?
Si Si Si
GMY<- GMY<- GMY<-

3 3 3
DMY<- DMY<- DMY<-

3 3 3
GMY DMY
El resultado que va después del ciclo se lo realiza una vez termina el ciclo externo.
Entonces el algoritmo queda:
Definicion de variables
Nro : Campo numérico entero para la entrada de los enteros

Aux : Campo numérico entero para almacenar representante del grupo
CG : Campo numérico entero, contador de elementos de cada grupo
GMY : Campo numérico entero, almacena el contador mayor de cada grupo
DMY : Campo numérico entero, almacena el dato representante del mayor de cada grupo
Inicio
GMY <- 0 // Para garantizar que la primera vez cambie
DMY <- -5
Leer Nro
Mientras (Nro <> -5) Hacer
CG <- 0
CG <- CG + 1
Leer Nro
Fin mientras
Si ( CG> GMY) Entonces
GMY <- CG
DMY <- Aux
Fin si
Fin Mientras
Si GMY > 0 Entonces
Escribir " Grupo con mas datos repetidos ", DMY
Escribir " Cantidad de veces que se repite ", GMY
SiNo
Escribir " no hay grupos"
FinSi
Fin
#include <iostream>
int main(){
int nro,aux,cg,gmy,day;
cin>>nro;
gmy=0; //se lo inicializa en 0 que representaría cuando no hay grupos
dmy=-5; // es el valor centinela, puede ser cualquier otro valor
while (nro!=-5){
aux=nro; // determina el representante del grupo que va a iniciar
cg=0;
while (nro==aux){
cg=cg+1;
cin>>nro;
}
//cuando se sale del ciclo, termina un grupo
cout<<”\n Grupo -> ”<<aux<<” “<<cg<<” veces”;

if (cg>gmy){
gmy=cg;
dmy=aux;
}
}
// cuando termina este ciclo termina la entrada de datos.
// se valida si hubo grupos
if (gmy>0) {
cout<<”Grupo con más repetidos -> “<<dmy;
cout<<”\nCantidad de veces que se repite -> “<<gmy;
}
else
cout<<”\n no hay datos”;
return 0;
}
Manejo de ciclo con ciclos controlados con enfoque cualitativo, respuesta.
Dentro de la computación se acostrumbra a controlar ciclos preguntando al usuario si quiere
seguir procesando más datos, para lo cual se va a tener una respuesta positiva o una respuesta
negativa.
Si la respuesta es positiva se procesan datos dentro de un ciclo, de lo contrario sale de ciclo.
Para esto se maneja un campo de memoria de tipo carácter o alfanumérico que va a recibir una
respuesta que puede ser ‘S’o ‘N’ y dependiendo de esta respuesta, se ejecuta o nó las acciones del
ciclo.
Este método es muy utilizado , si se quiere dejar la decisión de terminar al usuario, dependiendo
de una respuesta.
El siguiente grupo de instrucciones, es una propuesta genérica de lo que sería un ciclo controlado
por pregunta y respuesta.
Escribir “ Desea procesar datos ? ( S/N )”

Leer resp
Mientras ( resp=’S’ ) Hacer
Acciones dentro del ciclo
.
.
Escribir “ Desea procesar más datos ? (S/N) “
Leer resp
Fin mientras
Ejercicio. Ciclo cualitativo

Determinar si un conjunto de ternas (tres datos) de datos correspondientes a los tres lados de un
triángulo, es equilatero, isosceles o escaleno. Las ternas a procesar deben estar controladas por el
usuario.
Modelo mental
Desea procesar triángulos?

resp
Si
a b c
3 3 3
Respuesta
Triangulo es equilatero
Desea procesar mas triángulos?
resp
Si
a b c
3 5 7
Respuesta
Triángulo escaleno
Desea más triángulos

resp
No
Resp
A
B
C
Para el ejercicio se va a validar si

Algoritmo TipoTriangulo
Escribir " Desea procesar trianguloa S/N"
Leer resp
mientras ( resp='s'|resp=’S’) Hacer

Leer a,b,c
Si (a>0yb>0yc>0) Entonces
Si (a=b) Entonces
Si (b=c) Entonces
Escribir " Triangulo equilatero "
SiNo
Escribir " Triangulo isosceles "
FinSi
SiNo
Si (a=c) Entonces
Escribir “ Triangulo isosceles “
Sino
Si (b=c) Entonces
Escribir " Triangulo isosceles "
Sino
Escribir " Triangulo escaleno "
FinSi
Finsi
Sino
Escribir “Triangulo no valido”
finsi
Escribir " Desea procesar más triangulos (S/N) "
Leer resp
FinMientras
FinAlgoritmo
#include <iostream>
int main(){
int a,b,c;
char resp;
cout <<"Desea procesar triángulos (S/N) => ";

cin>>resp;
while (resp=='s'||resp=='S'){
cout <<"Digitar lado 1 => ";
cin>>a;
cin>>b;
cin>>c;
if (a>0&&b>0&&c>0)
if (a==b)
if (b==c)
cout<<"Triangulo es equilatero ";
else
cout<<"Triangulo es isosceles ";
else
if(a==c)
else
if (b==c)
else
cout<<"Triangulo es escaleno ";
else
cout <<"Datos de triágulo invalido ";
cout <<"\nDesea procesar más triágulos (S/N) => ";
cin>>resp;
}
return 0;
}
Ejercicio
Determinar si un número dado es múltiplo de 5 sin utilizar el operador residuo
Modelo mental
23 mod 5 = 3
23
No es múltiplo de 5
El objetivo no es utilizar la división y hallar el residuo.
Solución moverse en todos los múltiplos de 5 hasta llegar al número evaluado y preguntar si el
último número generado es el buscado.
Para el 23 sería entonces:
5 10 15 20 25
¿23 = 25?
No
El 23 no es múltiplo de 5
Para el numero 30 se tendría
5 10 15 20 25 30
Al final se pregunta
¿30=30?
Si
30 es múltiplo de 5
Pasos genéricos
Leer número
Generar la secuencia de 5 mientras sea menor que número
Si el número es igual al último generado
Entonces el número es múltiplo de 5
Sino el número no es múltiplo de 5
Modelo detallado con variables
Num
Numero dado 23
C5 C5 C5 C5 C5
5 10 15 20 25
Num C5
¿23 = 25?
No
23 no es múltiplo de 5
Num :Campo numérico recibe valor a evaluar

C5 :Campo numérico contador genera la secuencia de 5 en 5
Definición de valores y acciones
Num // entrada
Numero dado 23
C5 Asignación Asignación Asignación Asignación Asignación

0 C5 C5 C5 C5 C5
5 10 25 20 25
Num C5
¿23 = 25? // Decisión
No
23 no es múltiplo de 5
La secuencia de 5, se genera con un ciclo y la condición de control es ¿C5<Num?
Asignación
C5 C5 + 5
C5  0
Decisión
Si ( Num = C5 ) Entonces
Escribir Num, “ es múltiplo de 5”
Sino
Escribir Num, “ No es múltiplo de 5”
Fin si
Algoritmo
Inicio
Leer Num
C5<-0
Mientras ( C5 < Num ) hacer
C5 <- C5 +5
FinMientras
Si ( Num = C5) Entonces
Escribir Num, " Es multiplo de 5"
SiNo
Escribir Num, " No es multiplo de 5"
FinSi
Fin
Existe otro método, que le permite determinar si es múltiplo.
Generar una secuencia con variaciones de -5 hasta llegar a 0, si se llega a 0 es múltiplo de 5 sino,
no lo es.
¿C5 = 0?
Si es múltiplo de 5
No No es múltiplo de 5
Se lo hace también con ciclo y su condición ¿C5>0?
Cuando sea igual a 5 o menor que 5 se termina el ciclo
Las variables son las mismas, cambia es la asignación de C5
C5  C5 – 5
Antes de ciclo
C5  Num
Algoritmo
Inicio
Leer Num
C5<-Num
Mientras ( C5 > 0 ) hacer
C5 <- C5 -5
FinMientras
Si ( C5 = 0) Entonces
Escribir Num, " Es multiplo de 5"
SiNo
Escribir Num, " No es multiplo de 5"
FinSi
Fin
El anterior ejercicio determina un método para averiguar si un número determinado pertenece o
no a una serie que tiene unas características determinadas.
En el ejemplo la serie es la secuencia de 5, en donde se generó la serie hasta el número dado y se
averiguó que pasaba en esa frontera.
Algoritmo
Inicio
Leer Nro
SF<-0
Mientras (Nro > 0) Hacer
CG <- 0
CG <- CG + 1
Leer Nro
Fin mientras
//Si DeterminarFibonacci(CG) = 0 Entonces
// SF<-SF+DeterminarFactorial(CG)
A<-0
B<-1
T<-0
Mientras T<CG hacer
T<-A+B
A<-B
B<-T
Fin Mientras
Si T=CG entonces
// Determinar factorial de CG

Fin Mientras
Fin

CursoComputaciónModelos

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

CursoComputaciónModelos

Cargado por

Copyright:

Formatos disponibles

Curso de computación utilizando modelos mentales

Características de un ejemplo de una solución mental a un problema.

Ejemplo de un modelo mental.

Hallar el área de un triángulo.

Se debe conocer la fórmula del Área- de un triángulo

- Representación de un dato en la memoria del computador

Representación de un dato en la memoria del computador, que permite definir el concepto de

Instrucciones que permiten manipular los datos.

Estas instrucciones se resumen en las siguientes

Representación de un dato en la memoria del computador

Instrucciones que permiten manipular datos

Leer Lista de variables

También se puede tener

La instrucción anterior también puede ser:

Es la acción que le permite sacar información almacenada en la memoria principal a un dispositivo

Escribir Lista de variable o constantes alfanuméricas

Escribir “Valor de variable A es “,A

cout <<”Valor de variable a es”<<A;

“Valor de variable A es “ es una constante alfanumérica y sirve para especificar lo que se va a

Si el valor de A es 20, la ejecución de la instrucción mostrará lo siguiente:

Escribir “Digitar un valor numérico ==> “

cout<<”Digitar un valor numérico ->”;

Digitar un valor numérico ==>

Esta acción se entiende que la variable va a cambiar con el resultado de la expresión

Anotaciones acerca de la asignación

Ejercicios con Instrucciones secuenciales

Hasta el momento se tiene el modelo mental con el cual se realiza lo siguiente:

Solución mental + Características computacionales = Solución computacional

De lo anterior se concluye que, la solución mental y la computacional son los mismos, en

Características computacionales a adicionar

Los datos se convierten en variables o constantes:

Continuación ejemplo del triángulo

B numérico entero para base

Entonces el modelo con nombres queda

Modelo mental con nombres

Determinación de los valores de las variables. La determinación de valores de las variables ya

Valores a variables por asignación.

Del ejemplo se tiene que el resultado es:

Para obtener esto se tiene la siguiente acción de salida:

Escribir “Area = ”,Area

Construcción del algoritmo

De lo anterior se concluye que el modelo resultante no debe involucrar valores presentes en el

Programa en lenguaje C++

Concepto a manejar en el modelo mental

Suma 10+5 = 15 suma = 15

Construcción del modelo computacional

- Variable int,float,double nombre(único)

El modelo computacional debe quedar con estos elementos únicamente.

Los datos del modelo mental soportan las variables

Modelo con nombres de variables

SUM cout<<”Suma = “<<SUM;

Determinación de valores de variables

De aquí se tienen las siguientes acciones:

Escribir “Suma = “,SUM

Programa en lenguaje C++

cout<<”Digitar dato 1 -> ”;

Hallar el promedio de 3 valores numéricos

Ejemplo- Solución mental

El anterior es un modelo mental

Modelo mental con nombres

La definición del problema es la que determina si es constante o variable, en el ejemplo se plantea

Por lo que quedaría así:

ST DES // asignación DES  ST10/100 DES ST0,1