SEUDO-CODIGO:

El Seudo-Código es una herramienta para el diseño de programas, que toma las mejores
características del lenguaje natural (idioma español) y de los lenguajes de programación
(C, C++, Java, Python, Matlab, Pascal, Fortran, Cobol, etc.), mismo que resulta adecuado
para tanto la lógica, como la estructura de los algoritmos, la naturaleza de los datos y es
fácil de leer e interpretar. Una vez elaborada la solución del algoritmo, es sencillo
traducirla al lenguaje de alto nivel que se desee.

Un algoritmo en Seudo-Código debe tener la siguiente estructura:

Programa NombreAlgoritmo;
Declaración de constantes;
Declaración de variables;
Definición de procedimientos o funciones;
Inicia NombreAlgoritmo
Instrucciones del algoritmo
Fin Programa NombreAlgoritmo.

Al final de cada instrucción debe ponerse un punto y coma.

En el caso de que haya dificultad en la declaración de constantes o variables, se

empleará la palabra reservada Utiliza y a continuación se describirá los elementos que
utiliza ese algoritmo.

Se identifican los siguientes tipos de instrucciones o sentencias:

Instrucciones de secuencia.
Instrucciones de selección.
Instrucciones de repetición.

Instrucciones de secuencia:
Son aquellas que van una a continuación de otra:

Instrucción1;
Instrucción2;
Instrucción3;
…
InstrucciónN;
En ciertos casos, se requiere agrupar las sentencias formando un bloque, por lo que se
requiere emplear la estructura:

Inicia NombreProceso
Lista de instrucciones
Fin Proceso NombreProceso
TAREA:

Resolver los ejercicios propuestos del texto guía desde la pag 119 hasta la pag 132.
Implementarlos en Lenguaje C y Python. Usar la metodología para resolver problemas en
la computadora, en por lo menos cuatro ejercicios.
NRC 6492: ejercicios de la serie 1, 4, 7, 10 …
NRC 7676: ejercicios de la serie 2, 5, 8, 11 …

Instrucciones de selección:

Se la utilizan para implementar alternativas, tiene la siguiente estructura:

Si condición es verdadera Entonces

Bloque de instrucciones verdadero
Caso_contrario
Bloque de instrucciones falso

Variante:
Si condición es verdadera Entonces
Bloque de instrucciones verdadero

Python:
http://www.mclibre.org/consultar/python/lecciones/python-if-else.html

Ejercicio:
Siguiendo la metodología para resolver problemas por computadora diseñar un algoritmo
en seudocódigo e implementar un programa en Lenguaje C y Python para ingresar un
valor entero y determinar si es par o impar.

Solución:
Ver el archivo ParImpar.docx

SI ANIDADOS:
Un si anidado es aquel que va dentro de una alternativa verdadera o falsa de otro si.

Ejemplos:

Tablas de decisión:
Ejemplo1:
CONDICIONES SE EJECUTA SENTENCIA
C1, C2 Y C3 deben ser verdaderas BLOQUE1
C1, C2 deben ser verdaderas Y C3 debe ser falsa BLOQUE2
C1 debe ser verdadera Y C2 falsa BLOQUE3

Ejemplo2:
CONDICIONES SE EJECUTA SENTENCIA
C1, C2 Y C3 deben ser verdaderas BLOQUE1
C1, C2 deben ser verdaderas Y C3 debe ser falsa BLOQUE2
C1 debe ser falsa BLOQUE3

USO DE CONDICIONES COMPUESTAS

Las condiciones compuestas se las puede usar combinando los operadores lógicos con
las condiciones simples.
Ejemplo: Convertir los ejercicios anteriores a una secuencia de sentencias Si-Entonces
usando condiciones compuestas

SOLUCION:
Ejemplo 1:
Si C1 Y C2 Y C3 Entonces
BLOQUE1;
Si C1 Y C2 Y NO C3 Entonces
BLOQUE2;
Si C1 Y NO C2 Entonces
BLOQUE3;

Ejercicios:

Siguiendo la metodología para resolver problemas por computadora diseñar un algoritmo

en seudocódigo e implementar un programa en Lenguaje C y Python para ingresar desde
la consola tres lados de un triángulo en orden ascendente. Si se trata de un triángulo,
desplegar su tipo, perímetro y área. De lo contrario indicar que no es un triángulo.

Solución:
Ver el archivo Triangulo.docx

Ejercicio 2 Página 127

Determinar los valores finales de las variables X, Y y Z luego de ejecutar las siguientes
instrucciones:
1 A1;
2 B3;
3 C2;
4 XA+B-C;
5 Y(X+3)/(A-2);
6 Si A<C Entonces
Proceso VERDAD
7 AA+2;
8 BB+3;
9 CC+1;
10 Fin Proceso VERDAD
Caso_Contrario
Proceso FALSEDAD
11 AA+1;
12 BA;
13 CC-1;
Fin Proceso FALSEDAD;
14 XX+A;
15 YY-C;
16 ZY+B;

Variante:
Si condición es verdadera Entonces
Bloque de instrucciones verdadero;
Ejercicio 3 Página 128
Dada la siguiente instrucción
Si A<B Entonces Si B<=C Entonces Proceso UNO SI C<>D Entonces X1;
Caso_Contrario X3…32; Fin Proceso UNO Caso_Contrario X3; Caso_Contrario
X4;
 a. Reescribir la instrucción de tal manera que se pueda visualizar su lógica. De
ser posible simplificar al máximo la instrucción.
b. Escribir3333 la instrucción equivalente usando condiciones compuestas sin
anidamiento.

Ejercicio 4 Página 128

Dada la siguiente instrucción
Si (A>B) Y ((A>B)O(C<>D)) Entonces
XX+15;
Caso_Contrario
Si C>D Entonces
XX+3;
Caso_Contrario XX-1;

¿Cuál de las siguientes secuencias de instrucciones son equivalentes? (Existe una

sola respuesta correcta):
a. SI (A>B)O(C<>D) Entonces XX+15 Caso_Contrario SI C>D Entonces XX+3
Caso_Contrario XX-1;
b. SI A<=B Entonces Si C<=D Entonces XX-1 Caso_Contrario XX+3
Caso_Contrario XX+15;
c. Si C<>D Entonces XX+15; Caso_Contrario Si C<=D Entonces XX-1
Caso_Contrario XX+3;
d. Si A>B Entonces XX+15 Caso_Contrario Si C<=D Entonces XX-1
Caso_Contrario XX+3;
e. Si (A<=B)Y(C>D) Entonces XX+3; Caso_Contrario XX-1; XX+15;

SOLUCION:
Se debe transformar la sentencia si original a otra equivalente con uso de condiciones
simples:
Si (A>B) Entonces
Si (A>B) Entonces
XX+15;
Caso_Contrario
Si (C <> D) Entonces
XX+15;
Caso_Contrario
Si C>D Entonces
XX+3;
Caso_Contrario
XX-1;
Se buscan condiciones redundantes o contradictorias a fin de simplificar esta estructura:
Si (A>B) Entonces
Si (A>B) Entonces // Condición redundante
XX+15;
Caso_Contrario // A <= B es una condición contradictoria
Si (C <> D) Entonces
XX+15;
Caso_Contrario
 Si C>D Entonces
XX+3;
Caso_Contrario
XX-1;

Por tanto la estructura simplificada es:

Si (A>B) Entonces
XX+15;
Caso_Contrario
Si C>D Entonces
XX+3;
Caso_Contrario
XX-1;
Esta estructura se compara con las propuestas.
a) SI (A>B)O(C<>D) Entonces
XX+15
Caso_Contrario
SI C>D Entonces
XX+3
Caso_Contrario
XX-1;
No es equivalente porque en la estructura simplificada no existe la parte de la
condición O (C<>D)

b) SI A<=B Entonces
Si C<=D Entonces
XX-1
Caso_Contrario
XX+3
Caso_Contrario
XX+15;
Para la estructura original:
Instrucción A>B C>D
XX + 15; Verdadero
X X + 3; Falso Verdadero
X X – 1; Falso Falso

Para la estructura del literal b:

Instrucción A>B C>D
XX + 15; Verdadero
X X + 3; Falso Verdadero
X X – 1; Falso Falso

Como coinciden las tablas de decisión, la respuesta correcta es (b)

12, pag 137.-

SOLUCION usa si anidados con condiciones simples:
Programa Ventas1;
// Usa si anidados con condiciones simples
Const
LIM1 = 500;
LIM2 = 1000;
LIM3 = 1500;
PORC1 = 0.05;
PORC2 = 0.07;
PORC3 = 0.08;
PORC4 = 0.1;
// Declaración de variables:
Var
Nombre: HILERA;
MontoV, Comision: REAL;
Nanios: ENTERO
Inicia Ventas1
// Ingreso de datos:
Escribir(“Ingresar el nombre del vendedor: ”);
LeerYSaltar(Nombre);
Escribir(“Ingresar el monto de ventas: ”);
LeerYSaltar(MontoV);
Escribir(“Ingresar el numero de años en la empresa: ”);
LeerYSaltar(Nanios);
// Calcular la comisión:
Si MontoV < LIM1 Entonces
Comision  PORC1 * MontoV
Caso_Contrario
Si MontoV < LIM2 Entonces
Comision  PORC2 * MontoV
Caso_Contrario
Si MontoV <=LIM3 Entonces
Comision  PORC3 * MontoV
Caso_Contrario
Comision  PORC4 * MontoV;
Si Nanios > 6 Entonces
Comision  2 * Comision;
Si Nanios > 10 Entonces
Comision  Comision + 10 * (Nanios – 10);
// Despliegue de resultados:
EscribirYSaltar(Nombre,“ ha vendido “,MontoV,“ y tiene “,Nanios, “ años en la
empresa”);
EscribirYSaltar(“ por tanto recibe un ingreso de “, Comision);
Fin Programa Ventas1.

SOLUCION usa una secuencia de instrucciones si – entonces con condiciones

compuestas:
Programa Ventas2;
// Usa una secuencia de instrucciones si – entonces condiciones compuestas
Const
LIM1 = 500;
 LIM2 = 1000;
LIM3 = 1500;
PORC1 = 0.05;
PORC2 = 0.07;
PORC3 = 0.08;
PORC4 = 0.1;
// Declaración de variables:
Var
Nombre: HILERA;
MontoV, Comision: REAL;
Nanios: ENTERO
Inicia Ventas2
// Ingreso de datos:
Escribir(“Ingresar el nombre del vendedor: ”);
LeerYSaltar(Nombre);
Escribir(“Ingresar el monto de ventas: ”);
LeerYSaltar(MontoV);
Escribir(“Ingresar el numero de años en la empresa: ”);
LeerYSaltar(Nanios);
// Calcular la comisión:
Si MontoV < LIM1 Entonces
Comision  PORC1 * MontoV;
Si (MontoV >= LIM1) Y (MontoV < LIM2) Entonces
Comision  PORC2 * MontoV;
Si (MontoV >= LIM2) Y (MontoV <=LIM3) Entonces
Comision  PORC3 * MontoV;
Si MontoV > LIM3 Entonces
Comision  PORC4 * MontoV;
Si Nanios > 6 Entonces
Comision  2 * Comision;
Si Nanios > 10 Entonces
Comision  Comision + 10 * (Nanios – 10);
// Despliegue de resultados:
EscribirYSaltar(Nombre,“ ha vendido “,MontoV,“ y tiene “,Nanios, “ años en la
empresa”);
EscribirYSaltar(“ por tanto recibe un ingreso de “, Comision);
Fin Programa Ventas2.

SOLUCION usa una secuencia de instrucciones si – entonces con condiciones simples:

Programa Ventas3;
// Usa una secuencia de instrucciones si – entonces condiciones simples
Const
LIM1 = 500;
LIM2 = 1000;
LIM3 = 1500;
PORC1 = 0.05;
PORC2 = 0.07;
PORC3 = 0.08;
PORC4 = 0.1;
// Declaración de variables:
 Var
Nombre: HILERA;
MontoV, Comision: REAL;
Nanios: ENTERO
Inicia Ventas3
// Ingreso de datos:
Escribir(“Ingresar el nombre del vendedor: ”);
LeerYSaltar(Nombre);
Escribir(“Ingresar el monto de ventas: ”);
LeerYSaltar(MontoV);
Escribir(“Ingresar el numero de años en la empresa: ”);
LeerYSaltar(Nanios);
// Calcular la comisión:
Si MontoV < LIM1 Entonces
Comision  PORC1 * MontoV;
Si (MontoV >= LIM1) Entonces
Comision  PORC2 * MontoV;
Si (MontoV >= LIM2) Entonces
Comision  PORC3 * MontoV;
Si MontoV > LIM3 Entonces
Comision  PORC4 * MontoV;
Si Nanios > 6 Entonces
Comision  2 * Comision;
Si Nanios > 10 Entonces
Comision  Comision + 10 * (Nanios – 10);
// Despliegue de resultados:
EscribirYSaltar(Nombre,“ ha vendido “,MontoV,“ y tiene “,Nanios, “ años en la
empresa”);
EscribirYSaltar(“ por tanto recibe un ingreso de “, Comision);
Fin Programa Ventas3.

ESTRUCTURA SELECCIÓN MULTIPLE:

Tiene la sintaxis:

Caso variable De
val1: instucción1;
val2: instucción2;
val3: instucción3;
…
valN: instucciónN;
Caso_contrario
Instrucción;
Fin Caso;

Ejemplo:
Modificar la versión que utiliza si anidados con condiciones simples de ventas para que
use la estructura de selección múltiple.
SOLUCION:
Programa Ventas4;
// Usa la estructura de selección múltiple con condiciones simples
Const
 LIM1 = 500;
LIM2 = 1000;
LIM3 = 1500;
PORC1 = 0.05;
PORC2 = 0.07;
PORC3 = 0.08;
PORC4 = 0.1;
// Declaración de variables:
Var
Nombre: HILERA;
MontoV, Comision: REAL;
Nanios: ENTERO
Inicia Ventas4
// Ingreso de datos:
Escribir(“Ingresar el nombre del vendedor: ”);
LeerYSaltar(Nombre);
Escribir(“Ingresar el monto de ventas: ”);
LeerYSaltar(MontoV);
Escribir(“Ingresar el numero de años en la empresa: ”);
LeerYSaltar(Nanios);
// Calcular la comisión:
Caso MontoV < LIM1 De
Verdadero: Comision  PORC1 * MontoV;
Caso_Contrario
Caso MontoV < LIM2 De
Verdadero: Comision  PORC2 * MontoV;
Falso: Caso MontoV <=LIM3 De
Verdadero: Comision  PORC3 * MontoV;
Falso: Comision  PORC4 * MontoV;
Fin Caso;
Fin Caso;
Fin Caso;
Caso Nanios > 6 De
Verdadero: Comision  2 * Comision;
Falso:;
Fin Caso;
Caso Nanios > 10 De
Verdadero: Comision  Comision + 10 * (Nanios – 10);
Falso:;
Fin Caso;
// Despliegue de resultados:
EscribirYSaltar(Nombre,“ ha vendido “,MontoV,“ y tiene “,Nanios, “ años en la
empresa”);
EscribirYSaltar(“ por tanto recibe un ingreso de “, Comision);
Fin Programa Ventas4.

Instrucciones de repetición o ciclos:

Se la utilizan para implementar procesos que se repiten, habitualmente se emplean los

siguientes ciclos:
a) Ciclos con el control a la entrada.- tiene la siguiente estructura:

Mientras condición sea verdadera Hacer

Bloque de instrucciones;

Ejer 39, pag 143:

Programa CocienteResiduo;
// Declaración de variables:
Var
A, B, Cociente, Residuo: ENTERO;
Inicia CocienteResiduo
// Ingreso de datos:
Escribir(“Ingresar 2 valores enteros: “);
LeerYSaltar(A, B);
// Calculo del Cociente y Residuo:
Cociente  0;
Residuo  A;
Mientras Residuo >= B Hacer
Inicia RestasSucesivas
Cociente  Cociente + 1;
Residuo  Residuo – B;
Fin Proceso RestasSucesivas;
// Despliegue de resultados:
EscribirYSaltar(“El cociente y residuo de “,A, “ y “, B, “ es: “,Cociente, “ y “,Residuo);
Fin Programa CocienteResiduo.

b) Ciclos con el control a la salida.- tiene la siguiente estructura:

Repetir

Bloque de instrucciones

Mientras condición sea verdadera;

Ejemplo:

Modificar el Ejercicio 39 para impedir que se ingresen valores <= 0 (validación).

SOLUCION:

Programa CocienteResiduo;
// Declaración de variables:
Var
A, B, Cociente, Residuo: ENTERO;
Inicia CocienteResiduo
// Ingreso de datos:
Repetir
Escribir(“Ingresar el dividendo > 0: “);
LeerYSaltar(A);
Hasta que A > 0;
Repetir
Escribir(“Ingresar el divisor > 0: “);
LeerYSaltar(B);
Hasta que B > 0;
// Calculo del Cociente y Residuo:
Cociente  0;
Residuo  A;
Mientras Residuo >= B Hacer
Proceso RestasSucesivas
Cociente  Cociente + 1;
Residuo  Residuo – B;
Fin Proceso RestasSucesivas;
// Despliegue de resultados:
EscribirYSaltar(“El cociente y residuo de “,A, “ y “, B, “ es: “,Cociente, “ y “,Residuo);
Fin Programa CocienteResiduo.
Implementar un programa en Seudo-codigo para ingresar y validar un entero mayor que
cero y calculardesplegando por pantalla sus factores primos

SOLUCION:

Programa FactoresPrimos;
// Declaración de variables:
Var
Num, aux, factor: ENTERO;
Inicia FactoresPrimos
// Ingreso de datos:
Repetir
Escribir(“Ingresar el numero > 0: “);
LeerYSaltar(Num);
Hasta que Num > 0;
Escribir(“LOS FACTORES PRIMOS DE ”, Num, “SON: 1 ”);
aux  Num;
factor  2;
Repetir
Si aux MOD factor = 0 Entonces
Proceso DespliegaDescompone
Escribir(factor, “ “);
aux  aux DIV factor;
Fin Proceso DespliegaDescompone
Caso_contrario
factor  factor + 1;
Hasta que aux = 1;
EscribirYSaltar();
Fin Programa FactoresPrimos.

c) Ciclos con contadores.- tiene la siguiente estructura:

Para VC  LI a LF : Inc Hacer

Bloque de instrucciones
Ejemplos:

Desarrollar un programa para desplegar los numero naturales < 101 en orden ascendente.
SOLUCION:

Programa NumerosNaturalesAscendente;
// Declaración de variables:
Var
N: ENTERO;
Inicia NumerosNaturalesAscendente
// Generar y desplegar los números naturales:
Para N  1 a 100 Hacer
Escribir (N, “ “);
EscribirYSaltar();
Fin Programa NumerosNaturalesAscendente.

Desarrollar un programa para desplegar los numero naturales < 11 en orden descendente.
SOLUCION:

Programa NumerosNaturalesDescendente;
 // Declaración de variables:
Var
N: ENTERO;
Inicia NumerosNaturalesDescendente
// Generar y desplegar los números naturales:
Para N  10 a 1 : -1 Hacer
Escribir (N, “ “);
EscribirYSaltar();
Fin Programa NumerosNaturalesDescendente.

CICLOS ANIDADOS:

Son aquellos ciclos que van dentro de otro ciclo.

Ejemplo.
Desarrollar el ejercicio 24 pag. 140.
SOLUCION:
Programa SerieExp;
// Declaración de constantes:
Const
error = 1E-6;
max = 20;
// Declaración de variables;
Var
expx, potencia, factorial, x, termino: REAL;
i, j, nter: ENTERO;
Inicia SerieExp
// Ingreso de datos:
Escribir(“Ingresar el exponente de e: “);
LeerYSaltar(x);
// Calculo de la serie:
expx = 0;
nter  0;
para i 0 a max hacer
Proceso CalculaSerie
Si i = 0 Entonces
potencia  1;
Caso_contrario
potencia  x;
para j  2 a i hacer
potencia  potencia * x;
factorial  1;
para j  2 a i hacer
factorial  factorial * j;
termino  potencia / factorial;
nter  nter + 1;
expx  expx + termino;
Si Abs(termino) <= error Entonces
Salir;
Fin Proceso CalculaSerie
// Desplegar resultados
 EscribirYSaltar(“Exp(“, x, “) = “, expx, “Nro. De términos = “, nter);
Fin Programa SerieExp