Pseudocódigo

[] Informática UNDAV

Apunte de Pseudocódigo


Índice

Algoritmo...........................................................................................................................................3

Pseudocódigo.....................................................................................................................................4

Variable..............................................................................................................................................4

Expresión............................................................................................................................................5

Operadores........................................................................................................................................5

Acciones de Secuencia:......................................................................................................................6

Acciones de Selección:.......................................................................................................................8

Acciones de Iteración.......................................................................................................................11

Sub Algoritmos.................................................................................................................................16

Ejercicios Integradores.....................................................................................................................20

Ejercicios Varios en Pseudocódigo (Resueltos y no resueltos).........................................................26

Ejercicio Notas y Padrones...............................................................................................................28

Fuentes:

Cátedra Mandrafina, Facultad de Ingeniería, UBA

http://mis-algoritmos.com/aprenda-a-crear-diagramas-de-flujo

http://mis-algoritmos.com/aprenda-a-crear-diagramas-de-flujo


Algoritmo

Algoritmo: Secuencia finita de pasos (acciones) que sirven para resolver un problema.

Ejemplo de Rueda pinchada.

Algoritmo rueda pinchada

Abrir baúl

Sacar rueda auxilio

Sacar gato

Levantar coche

Repetir

Sacar tuerca

Hasta que No halla más tuercas

Sacar Rueda

Poner Rueda de Auxilio

Repetir

Poner Tuerca

Hasta que estén todas

Bajar coche

Guardar Rueda

Guardar Gato

Fin algoritmo

Herramientas para construir Algoritmos: Diagrama de flujo, diagrama de Jackson,


Pseudocódigo

Pseudocódigo: Se utiliza durante toda la carrera. Se asemeja al lenguaje de prog..

Una vez construido el algoritmo en pseudocódigo, se traduce a un lenguaje que “entiende la computadora” quedando construido el programa.

Variable

Concepto de Variable: Casillero que tiene un Nombre (Referencia) y Contenido

Nombre: Identificador, debe ser una palabra compuesta sólo por letras, el carácter ‘_’ y números. No puede comenzar con un número.

Ej. Hola, Letra, Let1, A , Z etc.

No pueden ser Nombres de variables: 1, 1Hola, f. Etc.

Contenido: Valor que contiene la variable (Casillero).

Se pueden clasificar en los siguientes Tipos:

Números: Ej. 4, 5, 6.7 etc.

Caracteres: ‘A’, ‘.’, ‘2’ Etc. (Existe una tabla que contiene todos los caracteres en orden)

Lógicos: V o F.

Expresión


Expresión: Representa un valor

Está formada por:

è Valor o Variable

è Variable o Valor operador Expresión

Ej. De Valor: numéricos: 4, caracteres: ‘a’, lógicos: V, F.

Ej. De Variables: A, Hola etc.

Operadores

Los operadores pueden utilizarse:

Entre Números: Deben estar entre expresiones numéricas

Enteros : +, - , *, Div, Mod

Reales: +,-,*,% (Punto Flotantes)

Entre valores Lógicos: Deben estar entre expresiones lógicas

^ , v, ~

Lógicos : >,<, >=, <=,==, +

Acciones de Secuencia:

Asignar

Leer


Escribir

Escribir

Escribir: Permite exteriorizar una expresión.

Sintaxis:

Escribir(Expresión o Expresiones (Separadas por comas))

Ejemplo:

Escribir(Numero+3)

Escribir(Letra, Numero+1, ‘Hola’)

Nota: ‘Hola’ no es un valor de ningún tipo conocido, es decir, no es un carácter, pero se anotará de esta forma cuando se quiera escribir ‘H’, ’o’, ’l’, ’a’.

Ejercicio:

Ingresar un Número y luego imprimir el cubo del mismo.

Asignar

Asignar, Permite almacenar una expresión en una variable

Sintaxis:

Variable <- Expresión

Ejemplo:

Numero<-7

Letra<-‘s’


Ejercicio:

Almacenar en una variable el 8 * 62

Leer

Leer, Permite entrar un dato, y almacenarlo en una variable.

Sintaxis:

Leer(Variable)

Ejemplo:

Leer(Numero) Cuando se ejecuta la acción se ingresará un valor y quedará almacenado en la variable

Leer(Letra)

Ejercicio:

Ingresar un Número y luego imprimir el cubo del mismo.

Acciones de Selección:

Si

Si, Permite tomar una decisión a partir de una expresión lógica.

Sintaxis:

Si <expresión lógica> Entonces


Acción/es

Fin si

Ejemplo:

Si (Numero=4) Entonces

Escribir(‘El número es un cuatro’)

Escribir(‘Ingrese otro número’)

Leer (Numero)

Fin si

Ejercicio:

Ingresar un Número y decir si es mayor menor o igual a cero


Si/Si no, Permite tomar una decisión a partir de una expresión lógica.

Sintaxis:

Si <expresión lógica> Entonces

Acción/es

Si no

Acción/es

Fin si

Ejemplo:

Si (Numero>0) Entonces

Escribir(‘El número es Positivo’)

Si no

Si (Numero<0) Entonces

Escribir(‘El número es Negativo’)

Si no

Escribir (‘El número es cero’)

Fin si

Fin si

Ejercicio:

Ingresar un número N y otro M y decir cual es el mayor.

Ingresar un número entre 1 y 3 y escribirlo en letras.

Según

Segun, Permite tomar una decisión a partir expresión lógica.


Sintaxis:

Según <expresión lógica> Hacer

Valor/es: Acción/es

Valor/es: Acción/es

Si No

Acción/es

Fin Según

Ejemplo:

Según (Numero)

1: Escribir(‘Uno’)

2: Escribir(‘Dos’)

3: Escribir(‘Tres’)

Si no

Escribir(‘El número no está en el rango’)

Fin según

Ejercicios:

1) Diseñar un algoritmo que imprima un número entre 1 y 3 en letras.

2) Ahora probar con un número entre 1 y 5

3) Ingresar un carácter e indicar si es un Número, Letra o signo.


Acciones de Iteración

Para

Para Permite realizar un ciclo definido por un rango de valores finito finita

Sintaxis

Para Variable<-Expresión (Valor Inicial) Hasta Expresión (Valor Final) hacer

Acción/es

Fin Para

Ejemplo

- Leer 10 números y escribir la suma de ellos.

Algoritmo Suma

Escribir(‘Ingrese 10 número para poder realizar la suma de ellos’)

Suma<-0

Para i<-1 hasta 10 hacer

Escribir(‘Ingrese un número’)

Leer(Nmero)

Suma=Suma+numero

Fin Para

Escribir ‘(El resultado es’,suma).

Fin Algoritmo


Para manejar un ciclo, en una estructura Para, existe la variable de control.

Se debe iniciar el ciclo Para con la inicialización de dicha variable (Variable<-Valor Inicial) y luego se ejecutarán la/s Acción/es (Valor Final - Valor Inicial) + 1 veces.

Nota: - Nunca modificar la variable de control dentro del ciclo.

- Cuando termina el ciclo la variable de control toma el valor final.

Ejercicios

1) Diseñar un algoritmo lea 3 número y los sume.

2) Ahora probar con 10 números.

3) Leer un número e imprimir sus divisores.

4) Leer un número N y luego leer N número. Indicar cuál fue el mayor.

5) Leer un número e indicar si es primo.

Mientras

Mientras Permite realizar un ciclo con una o más condiciones de corte.

Sintaxis

Mientras <Expresión lógica> hacer

Acción/es

Fin Mientras

El ciclo mientras iterará siempre y cuando la Expresión lógica sea verdadera.

Nota: - Inicializar la/s variable/s de control antes de empezar el ciclo.

- Modificar la/s variable/s de control dentro del ciclo.


Ejemplo

- Leer una serie de números terminada en cero e imprimir el promedio

Algoritmo Promedio

Escribir(‘Ingrese una serie de números terminada en 0’)

Suma=0

Leer(Numero)

Cantidad=0

Mientras Numero<>0 hacer

Cantidad=Cantidad+1

Suma=Suma+Numero

Leer(Numero)

Fin Mientras

Si Suma<>0 entonces

Escribir (‘El promedio es:’, Suma/Cantidad)

Fin Algoritmo

Ejercicios

1) Leer una serie de números terminada en 0 y sumarlos.

2) Imprimir tres números pares entre N y M.

3) Leer un texto terminado en “.” e imprimir la cantidad de palabras.

4) Leer dos número e indicar si son Coprimos.

Repetir


Repetir Permite realizar un ciclo con una o más condiciones de corte.

Sintaxis

Repetir

Acción/es

hasta <Expresión lógica>

El ciclo Repetir iterará siempre y cuando la Expresión lógica sea falsa.

Nota: - Modificar la/s variable/s de control dentro del ciclo.

Ejemplo

-

- Leer un numero entre 1 y 100 y luego imprimir el cuadrado del número.

Algoritmo Cuadrado

Repetir

Escribir(‘Ingrese un número entre 1 y 100 para obtener el cuadrado del mismo’)

Leer(Numero)

Hasta Numero>=1 y Numero<=100

Escribir (‘El cuadrado es:’, Numero * Numero)

Fin Algoritmo

Ejercicios

1) Leer un texto terminado en “.” e imprimir la cantidad de palabras.

2) Leer dos número e indicar si son Coprimos.


Sub Algoritmos

Ejercicio 1

- Leer un número X entre 1 y 10 y luego leer N números entre 1 y 10 e indicar cuales son coprimos con X.

En el problema descripto se pueden identificar problemas más pequeños, es decir para solucionar el ejercicio se deberían solucionar los siguientes subproblemas (1-5):

1- Leer un número X entre 1 y 10

2- Leer número N

3- Leer N números (4- entre 1 y 10) 5-ver si son cooprimos con X

Un subalgoritmos o acción es un conjunto de acciones que sirven para resolver un problema.

Sintaxis

Subalgoritmo <Nombre>

Acción/es

Fin Subalgoritmo <Nombre>

Para poder invocar (ejecutar) un subalgoritmo se debe escribir el nombre del mismo como si fuese una acción más. Un subalgoritmo se puede invocar desde un algoritmo o desde otro subalgoritmo.

Los subalgoritmos se escriben al final del algoritmo.

Ejemplo

- Leer un número par e imprimir sus divisores


Algoritmo Ejemplo

Escribir(‘Ingrese un número par’)

Leer_Par

Para i<-1 hasta N Hacer

Si (N mod i=0) entonces

Escribir(i,’Es divisor’)

Fin si

Fin para

Fin Algoritmo

Subalgoritmo Leer_Par

Leer(N)

Mientras N mod 2 <> 0 hacer

Escribir(‘El número debe ser par’)

Leer(N)

Fin mientras

Fin Subalgoritmo Leer_Par

El algoritmo funciona ejecutando acción por acción, cuando llega al subalgoritmo (o acción) Leer_Par se ejecutan todas las acciones correspondientes a dicho subalgoritmo y luego continua el algoritmo a partir de la acción siguiente a la invocación del subalgoritmo. Las variables se comparten entre el algoritmo y los subalgoritmos.

El objetivo del uso de subalgoritmos es modularizar un algoritmo, es decir dividir al problema en subpromlemas, resolver el problema con un algoritmo y a los sobproblemas con subalgoritmos. De esta forma cuando resuelvo un problema me abstraigo de los pequeños detalles que no hacen en sí al problema llamando a acciones (Subalgoritmos) que una vez resuelto el problema principal tendré que solucionar.

La ventaja más importante de modularizar es que los subprogramas se pueden reutilizar en el mismo algoritmo o en otros.

Veamos el ejemplo planteado al principio


El algoritmo, con el uso de subalgoritmos quedaría escrito de la siguiente forma.

Algoritmo Ejercicio_1

Leer_Y_Validar

X<-Numero

Escribir(‘Ingrese la cantidad de número que quiere ingresar’)

Leer(N)

Para i<-1 hasta N

Lee_y_Validar

Ver_Cooprimos

Si Son_Coopromos entonces

Escribir(‘Los número son cooprimos’)

Si no

Escribir(‘Los número no son cooprimos’)

Fin si

Fin Para

Fin Algoritmo Ejercicio_1

Subalgoritmo Leer_y_Validar

Repetir

Escribir(‘Ingrese un número entre 1 y 10’)

Leer(Numero)

Hasta (Numero<=10) ^ (Numero>=1)

Fin Subalgoritmo Leer_y_Validar


Subalgoritmo Ver_Cooprimos

Son_Cooprimos<-V

Si X<Numero entonces

Min<-X

Si no

Min<-Numero

Fin si

i<-2

Mientras i<Min ^ Son_Cooprimos Hacer

Si Min mod i = 0 Entonces

Son_Cooprimos<-F

Si no

i<-i+1

fin si

Fin Subalgoritmo Ver_Cooprimos


Ejercicios Integradores

Ejercicio 1:

Leer un número e indicar si es capicúa

Solución: para saber si un número es capicúa, se puede averiguar de dos formas, 1compara el primer número con el último, si son iguales comparar el segundo con el anteúltimo y así sucesivamente hasta que alguna comparación difiera o se hallan comparado todas las cifras.

2 Otra forma, más sencilla podría ser invertir el número y luego compararlo con el original.

1)

Algoritmo Capicua_1

Escribir (‘Ingrese un número’)

Leer(Numero)

Calcular_Cant_Cifras

Es_Capicua<- V

Mientras Cant_Cifras>1 ^ Es_Capicua Hacer

Hallar_Primera_Cifra

Hallar_Ultima_Cifra

Si Primera_Cifra=Ultima_Cifra entonces

Cant_Cifras=Cant_Cifras-2

Sacar_Primera_Ultima

Si no

Es_Capicua<- F

Fin si

Fin Mientras


Si Es_Capicua entonces

Escribir(‘Es Capicua’)

Si no


Fin si

Fin Algoritmo

Notar que en mi algoritmo principal se describen sólo los grandes pasos a seguir sin caer en la problemática de resolver cada uno

Ahora sólo quedan diseñar los subalgoritmos, o acciones, para solucionar los subproblemas (grandes pasos) .


Subalgoritmo Calcular_Cant_Cifras

Cant_Cifras<-0

Numero_Aux<-Numero

Mientras Num_Aux>9 Hacer

Cant_Cifras<-Cant_Cifras+1

Num_Aux<_Num_Aux div 10

Fin Mientras

Fin Subalgoritmo Calcular_Cant_Cifras

Subalgoritmo Hallar_Primera_Cifra

Base<- 10

Exp<-Cant_Cifras-1

Potencia

Primera_Cifra<-Numero div Resultado

Fin Subalgoritmo Hallar_Primera_Cifra

Subalgoritmo Hallar_Ultima_Cifra

Ultima_Cifra<-Nuero mod 10

Fin Subalgoritmo Hallar_Ultima_Cifra

Subalgoritmo Sacar_Primera_Ultima

Numero<-Numero div 10

Exp<-Cant_Cifras-1

Potencia

Numero<-Numero Mod Resultado

Fin Subalgoritmo Sacar_Primera_Ultima


Subalgoritmo Potencia

Resultado<-1

Para i<-1 hasta Exponente Hacer

Resultado<-Resultado*Base

Fin para

Fin Subalgoritmo Potencia

Nota : El algoritmo sólo funciona con números enteros y positivos.

2)

Algoritmo Capicua_2

Escribir (‘Ingrese un número’)

Leer(Numero)

Invertir_Numero

Si Numero=Numero_Invertido entonces


Si no


Fin si

Fin Algoritmo

Notar que en este caso se resuelve el problema cambiando de problema, es decir el problema de saber si un número es capicúa lo reduzco al problema de invertir un número

Subalgoritmo Invertir_Numero

Numero_Aux<-Numero


Numero_Invertido<- Numero_Aux Mod 10

Mientras Numero_Aux>9 hacer

Numero_Aux<-Numero_Aux div 10

Numero_Invertido<-Numero_Invertido* 10 + Numero_Aux Mod 10

Fin Mientras

Fin Subalgoritmo Invertir_Numero

Ejercicio 2:

Desarrollar un algoritmo que resuelva un polinomio de una sola variable

Ej. 3x+5x2+9x4

Algoritmo Polinomio

Escribir (‘Este algoritmo resuelve un polinomio de una variable evaluada en Valor’)

Escribir(‘Ingrese grado del polinomio’)

Leer(Grado)

Escribir(‘Ingrese Valor de X’)

Leer(X)

Resultado<-0

Para i<-0 hasta Grado hacer

Base<-X

Exp<-i

Potencia

Escribir(‘Ingrese coeficiente ‘,i)

Leer(Coeficiente)

Resultado<-Resultado+Coeficiente*Res_Potencia


Fin Para

Escribir(‘El resultado es: ’,Resultado)

Fin Algoritmo


Ejercicios Varios en Pseudocódigo (Resueltos y no resueltos)

1. Ingresar 2 números distintos de cero e indicar cual es divisor de cual.

ALGORITMO Divisor

ESCRIBIR ('Ingrese dos números distintos de cero: ')

LEER (NumUno, NumDos)

SI (NumUno > NumDos) ENTONCES

SI ((NumUno MOD NumDos) = 0) ENTONCES

ESCRIBIR('El número: ', NumDos)

ESCRIBIR('...es divisor de: ', NumUno)

FIN SI

FIN SI

SI (NumUno < NumDos) ENTONCES

SI ((NumDos MOD NumUno) = 0) ENTONCES

ESCRIBIR('El número: ',NumUno)

ESCRIBIR('...es divisor de: ',NumDos)

FIN SI

FIN SI

SI (NumUno = NumDos) ENTONCES

ESCRIBIR('Los números son iguales.')

FIN SI

FIN ALGORITMO


2. Dada una velocidad indicada en metros por segundo convertir la misma a kilómetros por hora.

3. Ingresar un número, redondearlo e indicar si es par o impar.

4. Dadas las medidas de los lados de un triángulo indicar que tipo de triángulo es (equilátero, Escaleno o Isoceles).

5. Ingresar 3 números por teclado e imprimirlos en forma ordenada.

ALGORITMO Orden

ESCRIBIR('Ingrese tres números: ')

LEER(A, B, C)

ESCRIBIR('Los números ordenados son: ')

SI (A<B) Y (B<C) ENTONCES ESCRIBIR(A, B, C)

SI (A<B) Y (C<B) ENTONCES ESCRIBIR(A, C, B)

SI (B<A) Y (A<C) ENTONCES ESCRIBIR(B, A, C)

SI (B<C) Y (C<A) ENTONCES ESCRIBIR(B, C, A)

SI (C<A) Y (A<B) ENTONCES ESCRIBIR(C, A, B)

SI (C<B) Y (B<A) ENTONCES ESCRIBIR(C, B, A)

FIN ALGORITMO

6. Efectuar un algoritmo que permita obtener el valor de la función 4x3 para un rango de valores ingresado.

ALGORITMO Tabla

Escribir('Indique el rango (Xi..Xf): ')

Leer(Xi,Xf)

Escribir('X:','Y:')

Para X=Xi Hasta Xf Hacer

Y=4*X*X*X

Escribir(X,Y)

Fin Para

FIN ALGORITMO


Ejercicio Notas y Padrones

{ ENUNCIADO

ALGORITMOS Y PROGRAMACION I (75.40)

CATEDRA MANDRAFINA-OTERO-SALVIA

19/03/2003

CESAR GAZZO HUCK

UN CURSO DESEA ANALIZAR LAS NOTAS OBTENIDAD POR SUS ALUMNOS

SE PEDIRA EL INGRESO DEL PADRON Y LA NOTA OBTENIDA EN EL EXAMEN FINAL

PARA OBTENER CUAL ES LA NOTA MAS ALTA DEL CURSO Y CUAL ES LA MAS BAJA

CON SUS RESPECTIVOS PADRONES.

ADEMAS OBTENER UN PROMEDIO GENERAL DEL CURSO

}

ALGORITMO EJEMPLO

NOTA_MAX = 0

PADRON_MAX = 0

NOTA_MIN = 11

PADRON_MIN = 0

SUMATORIA = 0

ESCRIBIR('INGRESE EL NUMERO DE ALUMNOS DEL CURSO')


LEER(NUMERO_PADRONES)

PARA AUX = 1 HASTA NUMERO_PADRONES

ESCRIBIR('INGRESE EL PADRON DEL ALUMNO')

LEER(PADRON)

ESCRIBIR('INGRESE LA NOTA PARA EL ALUMNO [',PADRON,']');

LEER(NOTA)

{ ANALIZAMOS LOS DATOS }

SI NOTA => NOTA_MAX ENTONCES

NOTA_MAX = NOTA

PADRON_MAX = PADRON

FIN SI

SI NOTA <= NOTA_MIN ENTONCES

NOTA_MIN = NOTA

PADRON_MIN = PADRON

FIN SI

{ACUMULAMOS LAS NOTAS}

SUMATORIA = SUMATORIA + NOTA

FIN PARA


{MOSTRAMOS LOS RESULTADOS }

SI NUMERO_PADRONES > 0 ENTONCES

PROMEDIO = SUMATORIA/NUMERO_PADRONES

ESCRIBIR('EL PROMEDIO DEL CURSO ES :',PROMEDIO)

ESCRIBIR('LA NOTA MAS ALTA FUE :',NOTA_MAX,' Y CORRESPONDE A:',PADRON_MAX)

ESCRIBIR('LA NOTA MAS BAJA FUE :',NOTA_MIN,' Y CORRESPONDE A:',PADRON_MIN)

FIN SI

{ FIN DEL ALGORITMO }

FIN ALGORITMO

{ ALGORITMO MEJORADO }

{ ESTE EJEMPLO FUE MEJORADO PERMITIENDO QUE EL USUARIO ABANDONE INGRESANDO UN PADRON = 0 }

ALGORITMO EJEMPLO

NOTA_MAX = 0

PADRON_MAX = 0

NOTA_MIN = 11

PADRON_MIN = 0

SUMATORIA = 0

NUMERO_PADRONES = 0



LEER(PADRON)

MIENTRAS PADRON <> 0 HACER { SI EL USUARIO INGRESA CERO NO ENTRA AL CICLO}

NUMERO_PADRONES = NUMERO_PADRONES + 1

ESCRIBIR('INGRESE LA NOTA PARA EL ALUMNO [',PADRON,']');

LEER(NOTA)

{ ANALIZAMOS LOS DATOS }

SI NOTA => NOTA_MAX ENTONCES

NOTA_MAX = NOTA

PADRON_MAX = PADRON

FIN SI

SI NOTA <= NOTA_MIN ENTONCES

NOTA_MIN = NOTA

PADRON_MIN = PADRON

FIN SI

{ACUMULAMOS LAS NOTAS}

SUMATORIA = SUMATORIA + NOTA


LEER(PADRON)


FIN MIENTRAS

{MOSTRAMOS LOS RESULTADOS }

SI NUMERO_PADRONES > 0 ENTONCES

PROMEDIO = SUMATORIA/NUMERO_PADRONES

ESCRIBIR('EL PROMEDIO DEL CURSO ES :',PROMEDIO)

ESCRIBIR('LA NOTA MAS ALTA FUE :',NOTA_MAX,' Y CORRESPONDE A:',PADRON_MAX)

ESCRIBIR('LA NOTA MAS BAJA FUE :',NOTA_MIN,' Y CORRESPONDE A:',PADRON_MIN)

FIN SI

{ FIN DEL ALGORITMO}

FIN ALGORITMO


Diagramas de flujo

Introducción.

Los diagramas de flujo son una manera de representar visualmente el flujo de datos a travéz de sistemas de

tratamiento de información. Los diagramas de flujo describen que operaciónes y en que secuencia se requieren para

solucionar un problema dado.

Un diagrama de flujo u organigrama es una representación diagramática que ilustra la secuencia de las operaciones

que se realizarán para conseguir la solución de un problema. Los diagramas de flujo se dibujan generalmente antes

de comenzar a programar el código frente a la computadora. Los diagramas de flujo facilitan la comunicación entre

los programadores y la gente del negocio. Estos diagramas de flujo desempeñan un papel vital en la programación

de un problema y facilitan la comprensión de problemas complicados y sobre todo muy largos. Una vez que se

dibuja el diagrama de flujo, llega a ser fácil escribír el programa en cualquier idióma de alto nivel. Vemos a menudo

cómo los diagramas de flujo nos dan ventaja al momento de explicar el programa a otros. Por lo tanto, está correcto

decir que un diagrama de flujo es una necesidad para la documentación mejor de un programa complejo.

Reglas para dibujar un diagramas de flujo.

Los Diagramas de flujo se dibujan generalmente usando algunos símbolos estándares; sin embargo, algunos

símbolos especiales pueden también ser desarrollados cuando séan requeridos. Algunos símbolos estándares, que

se requieren con frecuencia para diagramar programas de computadora se muestran a continuación:

Inicio o fin del programa

Pasos, procesos o líneas de instruccion de programa de computo

Operaciones de entrada y salida

Toma de desiciónes y Ramificación


Líneas de flujo

Anotación

Observación: Para obtener la correcta elaboración de los símbolos, existen plantillas. Las puedes conseguir en

Papelerías.

Simbolos gráficos

Dentro de los simbolos fundamentales para la creaación de diagramas de flujo, los símbolos gráficos son utilizádos

especificamente para para operaciónes aritméticas y relaciónes condicionales. La siguiente es una lista de los

símbolos más comunmente utilizados:

+ Sumar

- Menos

* Multiplicación

/ División

± Mas o menos

= Equivalente a

> Mayor que

< Menor que

>= Mayor o igual que

<= Menor o igual que

¡= o <> Diferente de

Si

No

True

False

Reglas para la creación de Diagramas

1. Los Diagramas de flujo deben escribirse de arriba hacia abajo, y/o de izquierda a derecha.


2. Los símbolos se unen con líneas, las cuales tienen en la punta una flecha que indica la dirección que fluye la

información procesos, se deben de utilizar solamente líneas de flujo horizontal o verticales (nunca diagonales).

3. Se debe evitar el cruce de líneas, para lo cual se quisiera separar el flujo del diagrama a un sitio distinto, se

pudiera realizar utilizando los conectores. Se debe tener en cuenta que solo se vana utilizar conectores

cuando sea estrictamente necesario.

4. No deben quedar líneas de flujo sin conectar

5. Todo texto escrito dentro de un símbolo debe ser legible, preciso, evitando el uso de muchas palabras.

6. Todos los símbolos pueden tener más de una línea de entrada, a excepción del símbolo final.

7. Solo los símbolos de decisión pueden y deben tener mas de una línea de flujo de salida.

Ejemplos de diagramas de flujo

Diagrama de flujo que encuentra la suma de los primeros 50 numeros naturales

Bueno, y ahora la descripción del diagrama anterior


Suma, es la variable a la que se le va agregando la valor de cada número natural. N, es el contador. Éste recorrerá

lo números hasta llegar al 50.

El primer bloque indica el inicio del Diagrama de flujo

El segundo bloque, es un Símbolo de procesos En este bloque se asume

que las variables suma y N han sido declaradas previamente y las inicializa en 0 para comenzar a el conteo y

la suma de valores (Para declararlas existe el bloque Tarjeta perforada).

El tercer bloque, es también un Símbolo de procesos En éste paso se

incrementa en 1 la variable N (N = N + 1). Por lo que, en la primera pasada esta N valdrá 1, ya que estaba

inicializada en 0.

El cuarto bloque es exactamente lo mismo que el anterior Pero en éste, ya

se le agrega el valor de N a la variable que contendrá la suma (En el primer caso contendrá 1, ya que N = 1).

El quinto bloque es uno Símbolo de Toma de decisiones y Ramificación Lo que hay dentro del bloque es

una pregunta que se le hace a los valores que actualmente influyen en el proceso (Por decir algo, no se como

decirlo, soy muy sope :D) ¿Es N=50?, Obviamente la respuesta es no, ya

que N todavía es 1. por lo que el flujo de nuestro programa se dirigirá hacía la parte en donde se observa la

palabra no: Tercer Bloque, éste le sumará 1 (N=N+1) y vuelve a llegar a éste bloque, donde preguntará ¿Es

N=50?... ¡No!, todavía es 2. Ha pues, regresa al Tercer bloque y vuelve hacer lo mismo. Y así hasta llegar a

50, obteniendo así la suma de los primeros 50 primeros números naturales.

Por último indicamos que el resultado será mostrado en la impresora (Este lo puedes cambiarlo por el display

para mostrar datos).

Fin del programa (o diagrama)

Pseudocódigo

Documents

Transcript of Pseudocódigo