TECNICA DE PROGRAMACION

DIAGRAMA DE FLUJO

Un diagrama de flujo de datos (DFD) es un modelo lógico-gráfico para representar el funcionamiento de un sistema en un proyecto software. Sus elementos gráficos son círculos, flechas, y rectángulos cerrados o abiertos. Los cerrados representan entidades externas mientras que los abiertos describen almacenes o archivos. Los círculos significan procesos y las flechas flujos de datos desde, o hacia, un proceso.

VENTAJAS DE LOS DIAGRAMAS DE FLUJO:

* Favorecen la comprensión del proceso a través de mostrarlo como un dibujo. El cerebro humano reconoce fácilmente los dibujos. Un buen diagrama de flujo reemplaza varias páginas de texto.

* Permiten identificar los problemas y las oportunidades de mejora del proceso. Se identifican los pasos redundantes, los flujos de los reprocesos , los conflictos de autoridad, las responsabilidades, los cuellos de botella, y los puntos de decisión.

* Muestran las interfases cliente-proveedor y las transacciones que en ellas se realizan, facilitando a los empleados el análisis de las mismas.

* Son una excelente herramienta para capacitar a los nuevos empleados y también a los que desarrollan la tarea, cuando se realizan mejoras en el proceso.

SIMBOLOS QUE SE EMPLEAN EN LOS DIAGRAMAS DE FLUJO

inicio o fin del programa



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




Operaciones de entrada y salida



Toma de desiciónes y Ramificación

Conector para unir el flujo a otra parte del diagrama

Cinta magnética

Disco magnético




Conector de pagina



Líneas de flujo




Anotación




Display, para mostrar datos





OBSERVACION:

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

SIMBOLOS GRAFICOS:


+ MAS

- Menos
* Multiplicación
/ División
± Mas o menos
= Equivalente a
> Mayor que
<> Diferente de
Si
No
True
False

REGLAS PARA LA CREACION DE UN DIAGRAMA DE FLUJO

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 van a utilizar conectores cuando sea estrictamente necesarias.

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ímbolos.



EJEMPLOS:

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







Bueno, y ahora la descripción del diagrama anterior:

*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.

*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 ) ¿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).

A CONTINUACION UN VIDEO EN EL QUE MUESTRA PASO A PASO PARA REALIZAR EL DIAGRAMA DE FLUJO DE VENTAS.

ALGORITMOS:

Un algoritmo es una serie de pasos lógicos, que se estructuran para resolver un problema.Generalmente un algoritmo se compone de sentencias simples y sentencias de control.
Los algoritmos están delimitados por la palabras : INICIO y FIN
Sentencias simples Asignación de variables
Se le asigna un valor a una variable, a través del simbolo de flecha(<--) que dice que el valor a la derecha tiene que ser asignado a la variable que está a la izquierda.

EJEMPLO:

a <-- 10 Se asigna un valor 10 a la variable a. Al escribir esta sentencia por primera vez en un algoritmo, da por entendido su declaración o creación. Comunmente al lado derecho de la flecha, se pueden realizar operaciones aritméticas (+,-,/,*), para que su resultado se le asigne a la variable. Además en estas operaciones se puede incluir la misma variable u otras. ejemplo :

INICIO

x <-- 5 y <-- 10 z <-- x + y z <-- y * x + 7 z <-- x/8 + y/9 + (7 + x/8) z <-- z + 1 z <-- z * z + y * y x <-- -x + -y + -3 FIN

EJEMPLO:

determinar cuánto vale (a,b,c) después de las siguientes sentencias de asignación INICIO

a <-- 2 b <-- a * 4 /* b <-- 2 * 4 = 8 */ a <-- b + 2 * a /* a <-- 8 + 2 * 2 = 12 */ b <-- 2 - a * b /* b <-- 2 - 12 * 8 = 2 - 96 = -94 */ a <-- a - b /* a <-- 12 - -94 = 12 + 94 = 106 */ b <-- -b + 6 /* b <-- --94 + 6 = 94 + 6 = 100 */ FIN

Para seguir en forma ordenada, el cambio de valores en las variables, se utiliza una tabla llamada traza. a 2
---------------
b
a 2
---------------
b 8
a 2 12
---------------
b 8
a 2 12
---------------
b 8 -94
a 2 12 106
----------------
b 8 -94 100

valores finales : a = 106 , b = 100

Por lo tanto si se pide una traza, se debe mostrar la última tabla. Los pasos anteriores son sólo pasos explicativos.

EJERCICIO:

hacer la traza del siguiente algoritmo INICIO
t <-- 1 p <-- 4 t <-- 3 * t p <-- p - 12 t <-- -t + 6 p <-- -p * -2 FIN

valores finales : t = 3 y p = -16

LECTURA DE VARIABLES:

En muchos algoritmos, el valor de alguna variable debe ser introducido dinámicamente por el usuario a través del teclado o algún otro medio. A esa acción le llamaremos "leer", que consiste en la asignación del valor de entrada, a la variable correspondiente. ejemplo: INICIO

a <-- 12 leer b a <-- a + b FIN

Si se tiene que leer más de una variable, se pueden escribir usando el separado coma.

EJEMPLO:

Leer a, b, c /* lee en ese orden las variables a, b y c */

DECLARACION DE UNA CONSTANTE:

Si se necesita incluir en el algoritmo alguna constante, se debe seguir la misma metodología de la asignación de variables, pero con la limitación que el identificador debe estar escrito con letras mayúsculas y que la declaración se haga a continuación del inicio del algoritmo.
Comentarios
Todo comentario de alguna sentencia, debe ir entre los simbolos /* */.Los comentarios son útiles para explicar mejor alguna sentencia que puede estar no clara, para alguien que se enfrenta a las sentencias por primera vez. Ej : INICIO
PI <-- 3.14 /* constante */ Leer radio area <-- 4 * PI * radio * radio /* area de una esfera */ FIN

COMPARACIONES:

Para comparar dos variables se usará la siguiente nomenclatura : a <> b /* esta sentencia es verdadera (true) si a es mayor que b , y es falsa (false) en caso contrario */
a <= b /* esta sentencia es verdadera (true) si a es menor o igual que b, y ees falsa " " */ a >= b /* esta sentencia es verdadera (true) si a es mayor o igual que b , y es falsa " " */
a == b /* esta sentencia es verdadera si a tiene el mismo valor de b, y es falsa en caso contrario */
a != b /* esta sentencia es verdadera si a no tiene el mismo valor de b, y es falsa en caso contrario */

METODO IMPRIMIR:

Se usara un método llamado "imprimir", para identificar una salida estándar (ej : pantalla o consola).
El método consiste de la palabra "imprimir", seguido de un conjunto de argumentos, delimitado entre paréntesis.
imprimir(..argumentos..)
Los argumentos pueden ser de dos tipos : constantes alfanuméricas o variables. Si se quiere encadenar una constante con una variable, se debe usar el separador '+'.
Ej: INICIO
imprimir("Ingrese radio : ") /* imprime el mensaje constante "Ingrese x : " */
leer radio
imprimir("El valor del radio ingresado es : " + radio) /* se encadena lo constante con lo variable */
imprimir(r * 2) /* imprime el resultado de la operación aritmética */
FIN

En el caso que la operación tenga el operador suma, se deben adicionar paréntesis para su correcta interpretación. Debe ser interpretado como un operador aritmético y no de concatenación. imprimir("la suma de a y b es : " + (a + b) )
imprimir("a + b + c +++") /* como el simbolo suma esta dentro de la cadena constante, limitada
por comillas "", es interpretado como caracter */

SENTENCIAS DE CONTROL

SENTENCIA SI SI (condicion) ENTONCES
sentencia_1
sentencia_2
:
sentencia_n
FIN SI
Si la condición es verdadera, entonces se ejecutarán en orden las sentencias delimitadas por el FIN SI.Si la condición es falsa o no se cumple, el punto de algoritmo ejecutará la sentencia posterior al FIN SI.
Ejemplo : Una vez leidos b y c, si c es mayor que b, entonces asignar a b el valor de c y a continuación asignar a c el valor del doble de b. INICIO
leer b
leer c
SI (c > b) ENTONCES
b <-- c c <-- 2 * b FIN SI

FIN

EJEMPLO:

Si a es igual a b, entonces imprimir "Diferencia cero". A continuación imprimir "Concluida la comparación" INICIO
leer b,c

SI (c == b) ENTONCES
imprimir("Diferencia cero")
FIN SI
imprimir("Concluida la comparación")
FIN

EN GENERAL :

Es válido, ejecutar un conjunto de sentencias de control, dentro de otra del mismo tipo. Para una ordenada notación, todas las sentencias contenidas dentro de otra sentencia, se escribiran dejando un número positivo (recomendado : 4) de espacios a la derecha, de la columna correspondiente al inicio de la sentencia.
Para el caso de la sentencia SI, a continuación se muestra una abertura del ciclo de segundo orden :

INICIO

SI (c + a > 0 ) ENTONCES
imprimir("c + a es mayor que cero")
SI (c - a > 0) ENTONCES
imprimir("a es menor que c );
FIN SI
FIN SI
FIN

SENTENCIA SI - SINO
SI (condicion) ENTONCES
sentencia(s)
SINO
sentencia(s)

FIN SI

Si la condición es verdadera, entonces se ejecutarán las sentencias anteriores al SINO. Si la condición es falsa, el punto de algoritmo ejecutará las sentencias posteriores al SINO.
Ejemplo : SI (a != b) ENTONCES
imprimir("a es distinto de b")
SINO
imprimir("a es igual b ")
FIN SI

SENTENCIA DE SELECCIÓN SELECCION (variable)

constante_1 : sentencia(s)
constante_2 : sentencia(s)
:
:
constante_n : sentencia(s)

FIN SELECCION

Para eliminar el problema de tener muchas condiciones "SI (variable == valor_i) ENTONCES", se agrupan las instrucciones, en función del valor que tome cierta variable.
Ejemplo :
Algoritmo de la Calculadora INICIO
imprimir("1.- suma");
imprimir("2.- resta");
imprimir("3.- multiplicacion")
imprimir("4.- division")
imprimir("Ingrese opcion : ")
Leer a,b,opcion

SELECCION(opcion)

1 : imprimir("suma de " + a + " y " + b + " igual a : " + (a + b))
2 : imprimir("resta de " + a + " y " + b + " igual a : " + (a - b))
3 : imprimir("multiplicacion de " + a + " y " + b + " igual a : " + (a * b))
4 : SI (b != 0) ENTONCES
imprimir("division de " + a + " y " + b + " igual a : " + (a / b))
SINO
imprimir("division por cero --> infinito ")
FIN SI
FIN SELECCION
FIN

CICLOS ITERATIVOS

SENTENCIA MIENTRAS MIENTRAS (condicion) HACER
sentencia(s)

FIN MIENTRAS

Mientras se cumpla la condición, se ejecutarán las sentencias anteriores al FIN MIENTRAS. Además se cumple, que se puede entrar al ciclo, sólo si se cumple la condición. Finalmente, es muy importante determinar la variación de alguna variable, para quebrar la condición y no convertir al ciclo iterativo, en un "loop" o ciclo infinito.

EJEMPLOS:

Cantidad de dígitos de un número INICIO
Leer numero
contador <-- 0 MIENTRAS (numero > 0) HACER
numero <-- numero / 10 contador <-- contador + 1 FIN MIENTRAS imprimir("cantidad de digitos : " + contador) FIN

SENTENCIA HACER MIENTRAS
HACER
sentencia(s)

MIENTRAS (condición)

Se ejecutarán las sentencias, mientras se cumpla la condición. Además, una diferencia con la sentencia de control anterior, es que en ésta por lo menos se entra una vez en el ciclo.
Ej : leer un carácter, mientras sea distinto de '#' INICIO
HACER
leer caracter
MIENTRAS (caracter != '#')
FIN

SENTENCIA PARA PARA variable <-- valorInicial HASTA valorFinal HACER sentencia(s)

FIN PARA

Esta sentencia es útil para hacer variar el valor de una variable entera, permitiendo su inicialización y la determinación del último valor que puede tomar dentro del ciclo.
El ciclo cumple los siguientes pasos :

1) Inicializa el valor de la variable

2) Revisa la condición de término

3) SI se cumple la condición ENTONCES
ejecuta la sentencia
incrementa la variable

Vuelve al paso 2)

SINO saltar al paso 4)

4) Fin del ciclo

EJEMPLO:

1) Imprimir todos los dígitos (0..9)
PARA i <-- 0 HASTA 9 HACER imprimir(i) FIN PARA PROBLEMAS RESUELTOS Problema del triángulo Determinar si un triangulo es : equilatero, isóceles o escaleno, conociendo sus tres lados (a,b,c). INICIO

leer a,b,c
SI (a == b) ENTONCES
SI (b == c) ENTONCES
imprimir("Triangulo Equilátero")
SINO
imprimir("Triangulo Isóceles")
FIN SI
SINO
SI (b == c) ENTONCES
imprimir("Triangulo Isóceles")
SINO
imprimir("Triangulo Escaleno")
FIN SI
FIN SI
FIN

Problema del fósforo, el ventilador y la vela

Def : encender una vela con un fósforo, en función con las siguientes restricciones.
Existe un ventilador que se ubica frente al camino del fósforo prendido, el cual genera una corriente de aire, que se interpone a la llegada del fósforo prendido. Se cuenta con una cantidad limitada de fósforos, que se deben gastar completamente si es que no se lográra prender la vela. El ventilador no se puede apagar durante los intentos.
Variables
n : Número inicial de fósforos.
f : número de fósforos quemados. Por cada ensayo fallido, esta variable disminuirá en una unidad. Posibles valores : {n , n - 1 , n -2 , .. , 1 , 0 }.
velaApagada : estado lógico {true,false}

Métodos

intento() : retorna true si la vela fue prendida, retorna false en caso que la vela siga apagada.
imprimir() : imprime según los parámetros.
Una vez que se prende, mostrar o imprimr la cantidad de fósforos quemados y sin usar. Si no se prende nunca, imprimir el mensaje : "no se pudo prender la vela." INICIO
Leer n
velaPrendida <-- false f <-- 0 SI (velaPrendida == false) ENTONCES MIENTRAS (n - f > 0) HACER
f <-- f + 1 /* aumento en 1, los fosforos usados */ velaPrendida <-- intento() /* la variable puede tomar valor true o false */ SI (velaPrendida == true) imprimir("Cantidad de fosforos quemados :" + f ) imprimir("Cantidad de fosforos sin usar :" + (n - f) ) f <-- n /* se fuerza a salir del ciclo mientras, quebrando su condición */ FIN SI FIN MIENTRAS SINO imprimir("No se pudo prender la vela")

FIN SI FIN

Problema del reconocimiento de cadena en un proceso de transición de estados

Un proceso computacional, lee una cadena constante formada por ceros y unos (terminada en "#") ("0110#" , "11000110#",...) para verificar su reconocimiento o no.El proceso reconoce una cadena, si es que al terminar de leer ésta (leer caracter "#"), el proceso se encuentra en el estado c.Especificaciones del proceso1) El proceso parte en el estado a y lee el primer carácter de la cadena.2) Si el proceso está en el estado a y es leído un carácter "1" entonces el estado del proceso cambia a b. En caso contrario si es que el carácter leído es un "0", el estado se mantiene en a.3) Si el proceso está en el estado b y si lee un carácter "1" el proceso se mantiene en el mismo estado. En caso contrario, si el carácter leído es un "0" el estado cambiará a c. 4) Si el proceso está en el estado c y es leído un carácter "1" el proceso cambia al estado a. En caso contrario, si el carácter leído es un "0" el estado se mantiene en c. 5) La cadena no puede comenzar con el carácter "#". Cadenas que dejan el proceso en estado A : {"0#" , "00#" ,.., "101#" , "0101#" , "00101101#" ,...}Cadenas que dejan el proceso en estado B : {"1#" , "01#" ,.., "111#" , "0011#" , "01101011#" ,...}Cadenas que dejan el proceso en estado C : {"10#" , "010#" ,.., "001100#" , "101100110#" , ...}

Se pide diseñar un algoritmo que lea una cadena (String) y determine el estado del proceso en función de aquella.Además, si la cadena de entrada deja al proceso en el estado c, ésta se deberá imprimir, en caso contrario se deberá imprimir "cadena no reconocida".

Algoritmo INICIO
estado <-- a leer cadena

c <-- leerCaracter() HACER SELECCION(estado)

a : SI (c == 1) ENTONCES
estado <-- b FIN SI

b : SI (c == 0) ENTONCES
estado <-- c FIN SI

c : SI (c == 1) ENTONCES
estado <-- a

FIN SI
FIN SELECCION
c <-- leerCaracter() MIENTRAS (c != "#") SI (estado == c) ENTONCES imprimir(cadena) SINO imprimir("cadena no reconocida") FIN SI FIN

Problema de detención en un semáforo

Escribir el algoritmo, que describe las acciones que el conductor realiza ante el estado verde,amarillo o rojo de un semáforo. Tener en cuenta, que ante una luz amarilla, el conductor acelerará si es arriesgado, o desacelerará si es que es prudente.
Variables
luz : {VERDE , AMARILLA , ROJA} estaDetenido : {true,false}
Métodos
parte() , pasa() , acelera() , desacelera(), frena(), estaDetenido(), espera() INICIO
leer luz
SELECCION (luz)
VERDE : SI (estaDetenido == false) ENTONCES
parte()
SINO
pasa()
FIN SI
AMARILLA : SI (conductorEsArriesgado == true) ENTONCES
acelerarara()
SINO
desacelera()
frena()
FIN SI
ROJA : SI (estaDetenido == false) ENTONCES
desacelera()
frena()
SINO
espera()
FIN SI
FIN SELECCION
FIN

Problema de compra en función de la calidad de un lote de productos

Se requiere implementar un algoritmo, que permita registrar la calidad de un lote de productos, para agilizar el proceso de compra. El sistema consiste, en un lector de calidad que va leyendo mediante sensores a un producto dejado a través de una correa transportadora, para transmitir a continuación los datos a un software especial, depositado en un computador, que entrega hacia afuera uno de los siguientes estados numéricos :

0 : Producto MALO

1 : Producto DEFECTUOSO

2 : Producto BUENO

Especificaciones

a) Los datos que llegan en forma iterativa (mientras no se haya acabado el lote de productos a revisar), son rescatados por el método test().

b) El térnmino de la revisión está determinado cuando el método fin() retorne el valor true.

c) El algoritmo debe llevar un conteo de cuántos productos corresponden a cadaestado { MALO : 2 , DEFECTUOSO : 5 , BUENO : 43 }, para posteriormente aplicar un cálculo de porcentaje.

d) Inicialmente no se sabe la cantidad total de productos del lote, por lo tanto es fundamental que se implemente un contador para los cálculos posteriores.

e) El precio original de compra del lote, tiene que ser ingresado por el usuario. Después del análisis, se deberá imprimir según los criterios el precio propuesto de compra.

Una vez terminado el proceso de análisis y conteo, se determinará el precio de compra propuesto para el lote en cuestión.Criterios

1) Si el porcentaje de productos malos es superior al 15%, el lote no se compra (precio <-- 0). En caso contrario, pasar al punto 2

2) Si el porcentaje de productos defectuosos es menor a un 10%, se compra a un 70% del precio original. En caso contrario, pasar al punto 3

3) Si el porcentaje de productos buenos es mayor o igual a un 70%, el lote se compra al precio original. En caso contrario, se estaría comprando a un 60% del precio original.

Algoritmo INICIO N <-- 0 /* cantidad de productos analizados */ contMalos <-- 0 contDefect <-- 0 contBuenos <-- 0 precio <-- 0 /* precio en función del análisis */ leer precioInicial MIENTRAS (fin() != true) HACER calidad <-- test() SELECCION (calidad) 0 : contMalos <-- contMalos + 1 1 : contDefect <-- contDefect + 1 2 : contBuenos <-- contBuenos + 1 FIN SELECCION N <-- N + 1 FIN MIENTRAS SI (contMalos / N > 0.15) ENTONCES
precio <-- 0 SINO SI (contDefect / N <>= 0.7 )

ENTONCES
precio <-- precioOriginal SINO precio <-- precioOriginal * 0.6 FIN SI FIN SI FIN SI imprimir(precio) FIN

Problemas resueltos y una pequeño vistazo al lenguaje Java Problema de los trampolines

Se cuenta con dos trampolines olímpicos, para que una persona pueda realizar una serie de saltos, con tal de terminar parado en el segundo trampolín.

La distancia vertical entre los trampolines, es de 3 metros. Se sabe que siempre el primer salto es de 60 cm (0,6 mts).Además, se sabe que en cada salto se supera el rendimiento del salto anterior en un 30%. Determinar : cantidad de saltos necesarios para alcanzar el segundo trampolín y la altura máxima que se llega con respecto al primer trampolín. Además se necesita saber la altura alcanzada en cada salto. ejemplo : separación entre trampolines : 3.0porcentaje de aumento (0..1) : 0.3 cs altura -- ------ 1 0.6 2 0.78 3 1.014 4 1.3182 5 1.7137 6 2.2278 7 2.8961 Cantidad de saltos : 8 Altura maxima alcanzada : 3.765 seguir(1)/salir(0) : 0 Algoritmo INICIO cs <-- 1 /* cantidad de saltos */ h <-- 0.60 /* altura */ MIENTRAS( h < cs =" 1;" h =" 0.60;" seguir =" 1;" in =" new" h =" 0.6;" cs =" 1;" sep =" Double.parseDouble(in.readLine());" aumento =" Double.parseDouble(in.readLine());" seguir =" Integer.parseInt(in.readLine());" seguir ="=" href="http://pjsml.50megs.com/java/fuentes/Trampolin.java">Bajar archivo

Problema del electrón en los anillos

a ) Un electrón se mueve en un conjunto de 10 anillos, con una velocidad constante en cada uno de ellos . Una caracteristica de la trayectoria, es que una vez que completa el recorrido en un anillo, cambia de estado pasándose al anillo siguiente o más cercano al centro, con una velocidad 1.12 veces mayor a la anterior.

El electrón, después de recorrer el último anillo y llegar teóricamente al centro (k = 0), sale disparado perpendicularmente al radio del anillo, a una velocidad igual al doble de velocidad del radio uno (k = 1) por el último radio al cuadrado.
Además, la trayectoria cuenta con la caracteristica que el radio de cada anillo, es un 35% menor con respecto al anterior, siendo el radio inicial de 5.0 nm.
Finalmente, se sabe que el electrón tiene una velocidad inicial de 2.0 ns.
Datos
Para k : 1 , ... , 10 se tiene que
radio de cada anillo : radio_k-1 = radio_k * 0.65
Velocidad constante en cada anillo : v_k-1 = 1.12 * v_k
Tiempo_k = Distancia_k / Velocidad_k
radio inicial = 5.0 [nm]
velocidad disparo = 2 * v_1 * (1 + radio)^2

Determinar

Velocidad, distancia y tiempo en recorrer cada anillo, además del tiempo acumulado para recorrer los 10 anillos y la velocidad de disparo del electrón.
El algoritmo debe generar la siguiente salida : ingrese numero de anillos : 10
ingrese radio inicial : 5.0
ingrese velocidad inicial : 2.0
k radio Distancia Velocidad Tiempo
--- ----- --------- --------- ------
10 5.0 31.415 2.0 15.707963267948966
9 3.25 20.42 2.24 9.11622868229181
8 2.112 13.273 2.508 5.2906684316872115
7 1.373 8.627 2.809 3.07047721481847
6 0.892 5.607 3.147 1.781973383600005
5 0.58 3.645 3.524 1.0341809815535743
4 0.377 2.369 3.947 0.6001943196516281
3 0.245 1.54 4.421 0.3483270605121055
2 0.159 1.001 4.951 0.20215409761863268
1 0.103 0.65 5.546 0.11732157451081357

Velocidad disparo : 14.152

tiempo total : 37.26948901419321

Algoritmo INICIO

PI <-- 3.14 /* constante */ k <-- 10 radio <-- 5.0 velocidad <-- 2.0 distancia <-- 0 tiempo <-- 0 tiempoAcum <-- 0 imprimir("k radio Distancia Velocidad Tiempo"); imprimir("----------------------------------------------"); MIENTRAS (k > 0) HACER
distancia <-- 2 * PI * radio tiempo <-- distancia / velocidad tiempoAcum <-- tiempoAcum + tiempo imprimir(k + " " + radio + " " + distancia + " " + Velocidad" + " " + tiempo) velocidad <-- 1.12 * velocidad radio <-- radio * 0.65 k <-- k - 1 FIN MIENTRAS velocidad <-- 2 * velocidad * (1 + radio) * (1 + radio) imprimir("Velocidad disparo : " + velocidad) imprimir("tiempo total : " + tiempoAcum) FIN b ) Realizar un algoritmo en donde la cantidad de anillos, el radio inicial y la velocidad inicial, sean variables que deben ser leídas. Además, se quiere permitir tener la opción de salir o seguir calculando con nuevos valores. SoluciónINICIO PI <-- 3.14 /* constante */ distancia <-- 0 tiempo <-- 0 seguir <-- 1 HACER tiempoAcum <-- 0 /* en cada ciclo se debe inicializar en cero */ imprimir("ingrese numero de anillos : ") leer k imprimir("ingrese radio inicial") leer radio imprimir("ingrese velocidad inicial") leer velocidad imprimir("k radio Distancia Velocidad Tiempo"); imprimir("----------------------------------------------");

MIENTRAS (k > 0) HACER

distancia <-- 2 * PI * radio tiempo <-- distancia / velocidad tiempoAcum <-- tiempoAcum + tiempo imprimir(k + " " + radio + " " + distancia + " " + Velocidad" + " " + tiempo) velocidad <-- 4 * velocidad radio <-- radio * 0.65 k <-- k - 1 FIN MIENTRAS velocidad <-- 2 * velocidad * (1 + radio) * (1 + radio) imprimir("Velocidad disparo : " + velocidad) imprimir("tiempo total : " + tiempoAcum) imprimir("seguir(1)/salir(0) : ") leer seguir MIENTRAS (seguir == 1) FIN Programa en Java import java.io.*; public class Anillo { private static double redondear(double num) { double aux = num * 1000; int tmp = (int) aux; return (double) tmp / 1000; } public static void main(String[ ] args) throws IOException { double distancia = 0.0; double tiempo = 0.0; double tiempoAcum = 0.0; double radio; int k; double velocidad; int seguir = 1; BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); do { tiempoAcum = 0.0; /* en vcada ciclo se debe inicializar en cero */ System.out.print("\n\ningrese numero de anillos : "); k = Integer.parseInt(in.readLine()); System.out.print("ingrese radio inicial : "); radio = Double.parseDouble(in.readLine()); System.out.print("ingrese velocidad inicial : "); velocidad = Double.parseDouble(in.readLine()); System.out.println("\n\nk\tradio\t\tDistancia\tVelocidad\tTiempo"); System.out.println("---\t-----\t\t---------\t---------\t------"); while (k > 0) {
distancia = 2.0 * Math.PI * radio;
tiempo = distancia / velocidad;
tiempoAcum = tiempoAcum + tiempo;
System.out.println(k + "\t" + redondear(radio) + "\t\t" + redondear(distancia) + "\t\t" +
redondear(velocidad) + "\t\t " + tiempo);
velocidad *= 1.12;
radio = radio * 0.65;
k--;
}
velocidad = 2.0 * velocidad * Math.pow(1.0 + radio, 2.0) ;
System.out.println("\n\tVelocidad disparo : " + redondear(velocidad));
System.out.println("\n\ttiempo total : " + tiempoAcum);
System.out.print("\n\n\tseguir(1)/salir(0) : ");
seguir = Integer.parseInt(in.readLine());
} while (seguir == 1);
}
}

UN VIDEO SOBRE ALGORITMOS SOBRE UN EJERCICIO DE INGRESO DE NOTAS EL CUAL TIENE QUE DESARROLLAR EL INGRESO DE NOTAS Y SACAR UN PROMEDIO.

OTRO VIDEO PARA OTRA DEMOSTRACION DE ALGORITMOS:

PSEUDOCODIGO

Un pseudocódigo (falso lenguaje), es una serie de normas léxicas y gramaticales parecidas a la mayoría de los lenguajes de programación, pero sin llegar a la rigidez de sintaxis de estos ni a la fluidez del lenguaje coloquial. Esto permite codificar un programa con mayor agilidad que en cualquier lenguaje de programación, con la misma validez semántica, normalmente se utiliza en las fases de análisis o diseño de Software, o en el estudio de un algoritmo. Forma parte de las distintas herramientas de la ingeniería de software.

No siendo el pseudocódigo un lenguaje formal, varían de un programador a otro, es decir, no hay una estructura semántica ni arquitectura estándar. Es una herramienta ágil para el estudio y diseño de aplicaciones, veamos un ejemplo, que podríamos definir como: lenguaje imperativo, de tercera generación, según el método de programación estructurada.

Pseudocódigo = Pseudo (Supuesto) + Código (Instrucción).

DEFINICION DE DATOS DEL PSEUDOCODIGO:

La definición de datos se da por supuesta, sobre todo en las variables sencillas, si se emplea formaciones: pilas, colas, vectores o registros, se pueden definir en la cabecera del algoritmo, y naturalmente cuando empleemos el pseudocódigo para definir estructuras de datos, esta parte la desarrollaremos adecuadamente.

DEFINICION DE ESTRUCTURAS DEL CONTROL:

Como se había mencionado antes, cada autor usa su propio pseudocódigo con sus respectivas convenciones. Por ejemplo, considere la instrucción "Reemplace el valor de la variable x por el valor de la variable y"; algunas de las posibles sintaxis para indicar lo anterior podrían ser:

asigne a X el valor de Y

X - Y

X := Y

X = Y

Sin embargo, independientemente de estas diferencias, muchos autores consideran tres estructuras de control para desarrollar los procedimientos:

SECUENCIAL:

Las instrucciones se siguen en una secuencia fija que normalmente viene dada por el número de renglón. Es decir que las instrucciones se ejecutan de arriba hacia abajo.

Instrucción1
Instrucción2
Instrucción3
.

:
Instrucción

SELECTIVA:

La instrucción selectiva determina si una determinada instrucción se ejecuta o no, según el cumplimiento de una condición P.

Si P entonces

instrucciones

FIN SI

La condición P es una variable booleana o una función reducible a booleana (lógica, Verdadero/Falso). Si esta condición es cierta se ejecuta Instrucciones1, si no es así, ésta no se ejecuta.

SELECTIVA DOBLE ( ALTERNATIVA)

La instrucción selectiva realiza una instrucción de dos posibles, según el cumplimiento de una condición P.

si P entonces
Instrucciones1
si no
Instrucciones2
fin si

La condición P es una variable booleana o una función reducible a booleana (lógica, Verdadero/Falso). Si esta condición es cierta se ejecuta Instrucciones1, si no es así, entonces se ejecuta Instrucciones2.

SELECTIVA MULTIPLE:

También es común el uso de una selección múltiple que equivaldría a anidar varias funciones de selección.

si Condición1 entonces
Instrucciones1
si no si Condición2 entonces
Instrucciones2
.

:
si no si Condiciónn entonces
Instruccionesn - 1
si no
Instruccionesn
fin si

*En este caso hay una serie de condiciones que tienen que ser mutuamente excluyentes, si una de ellas se cumple las demás tienen que ser falsas necesariamente, hay un caso si no que será cierto cuando las demás condiciones sean falsas.
En esta estructura si Condición1 es cierta, entonces se ejecuta sólo Instrucciones1. En general, si Condicióni es verdadera, entonces sólo se ejecuta Instrucciones.

SELECTIVA MULTIPLE-CASOS:

Una construcción similar a la anterior (equivalente en algunos casos) es la que se muestra a continuación.

seleccionar Indicador
caso Valor1:
Instrucciones1
caso Valor2:
Instrucciones2
.

:
caso Valorn-1:
Instruccionesn-1
[en otro caso:
Instruccionesn]
Fin seleccionar Indicador

*En este caso hay Indicador es una variable o una función cuyo valor es comparado en cada caso con Valori, si en algún caso coinciden ambos valores, entonces se ejecutarán las Instruccionesi correspondientes. La sección en otro caso es análoga a la sección si no del ejemplo anterior.

ITERATIVA:

Las instrucciones iterativas abren la posibilidad de realizar una secuencia de instrucciones más de una vez.

mientras P hacer
Instrucciones
fin mientras

*El bucle se repite mientras la condición P sea cierta, si al llegar por primera vez al bucle mientras la condición es falsa, el cuerpo del bucle no se ejecuta ninguna vez.
Existen otras variantes que se derivan a partir de la anterior. La estructura de control hacer se utiliza cuando es necesario que las instrucciones de una estructura mientras se ejecuten al menos una vez:

hacer
Instrucciones
mientras P

La estructura anterior equivaldría a escribir:

Instrucciones
mientras P hacer
Instrucciones
fin mientras

Una estructura de control muy común es el ciclo para, la cual se usa cuando se desea iterar sobre sobre un índice i (por convención se usa i, sin embargo se puede usar cualquier identificador):

para I -- X hasta n hacer
Instrucciones
fin para

la cual se define como:

I -- X
mientras I mayor o igual a N hacer
Instrucciones
i -- i+1
fin mientras

Por último, también es común usar la estructura de control para cada. Esta sentencia se usa cuando se tiene una lista o un conjunto L y se quiere iterar por cada uno de sus elementos:

para X pertenece L hacer
Instrucciones
fin para

Si asumimos que los elementos de L son L0,L1,L2 ,........,Ln entonces esta sentencia equivaldría A:

para I -- 0 hasta n hacer
X -- Li
Instrucciones
fin para

sin embargo, en la práctica existen mejores formas de implementar esta instrucción dependiendo del problema.
Es importante recalcar que el pseudocódigo no es un lenguaje estandarizado. Eso significa que diferentes autores podrían dar otras estructuras de control o bien usar estas mismas estructuras, pero con una notación diferente. Sin embargo, las funciones matemáticas y lógicas toman el significado usual que tienen en matemática y lógica, con las mismas expresiones.

EL ANIDAMIENTO:

Cualquier instrucción puede ser sustituida por una estructura de control. El siguiente ejemplo muestra un pseudocódigo de un método de ordenamiento denominado Ordenamiento de burbuja en el cual aparecen varias estructuras anidadas. Este algoritmo ordena una lista L.

procedimiento ORDENAR (L)
//L= (L1,L2,....., Ln) es una lista con n elementos//
hacer
INTERCAMBIO -- FALSO
para I -- 1 hasta N - 1 hacer
si L_{i+1}\,"

INTERCAMBIAR (Li , Li + 1)

INTERCAMBIO -- VERDADERO

fin si
fin para
mientras INTERCAMBIO = VERDADERO
fin procedimiento

*El pseudocódigo que a continuación se define fue tomado de la guía EGEL lnfo-Comp del CENEVAL. Sirve para escribir programas de computadora en lenguaje natural de tal manera que se facilite la comprensión, prueba y posterior codificación en un lenguaje de programación específico.

1. Convenciones
2. Tipos de datos
3. Estructuras de datos
4. Operadores
5. Operaciones de cadenas
6. Comentarios
7. Estructuras de control
8. Funciones o procedimientos
9. Operaciones de entrada/salida

1.- CONVENCIONES:

La relación de convenciones empleadas en el pseudocódigo es la siguiente:

*El pseudocódigo se escribe empleando la fuente Times New Roman Las palabras reservadas del pseudocódigo se muestran en negritas

*Los puntos "..." indican la posibilidad de repetir algún elemento del pseudocódigo

*Cuando exista la posibilidad de elegir algún elemento a partir de un conjunto de elementos, éstos se listarán separados por el símbolo ""

*Las diferentes opciones o posibilidades de uso del pseudocódigo se listan con viñetas

El pseudocódigo posee las características siguientes:

*Se emplean oraciones en lenguaje natural, donde cada una se refiere a una actividad general o específica

*Se utiliza un lenguaje común, sin palabras rebuscadas.

*Se evitan errores gramaticales, abreviaciones y puntuaciones

2.- TIPOS DE DATOS:

Los tipos de datos básicos son:

*string cadena de caracteres

*integer número entero

*real número real

*boolean falso o verdadero

Estos tipos de datos se declaran de acuerdo con las formas siguientes:

*tipo variable1

*tipo variable2, variable3 , ... , variablen

*tipo variablen1, variablen2, ... , variablenm = valor

donde: tipo puede ser string, integer, real o boolean.

3.- ESTRUCTURA DE DATOS:

Las estructuras de datos son:

*ARREGLOS

tipo array1[rango1,...,rangon], ... , array2[rango1, ... , rangon]
donde: rangon: número de localidades deseadas. La primera localidad se referencia con uno.
tipo: es alguno de los tipos de datos básicos o alguna estructura de datos.

*REGISTROS

Declaración:
record nombre_registro
tipo variable1
... ...
tipo variablen
end
Creación de un registro:
nombre_registro registro
La referencia a un campo de un registro se efectúa de la forma: registro.nombre_campo

*ARCHIVOS

Declaración:
file nombre_archivo

*CLASES

Declaración:
class nombre_clase
variables y funciones miembros
end
Instanciación de un objeto:
nombre_clase objeto
La referencia a un campo de una clase se efectúa de la forma: objeto.nombre_campo. El llamado a una función de una clase se efectúa de la forma: objeto.nombre_función(lista_parámetros)

4.- OPERADORES:

*ARITMETICOS:

+ suma
- resta
* multiplicación
/ división
mod módulo
div división entera
de comparación:
= igual
<> diferente
<> mayor que
<= menor o igual que >= mayor o igual que

*LOGICOS:

AND La expresión será verdadera si y sólo si ambas expresiones son verdaderas
OR La expresión será verdadera si al menos una expresión es verdadera
XOR La expresión será verdadera si y sólo si ambas expresiones son diferentes (verdadero y falso, o viceversa)
NOT El valor de la expresión es la negación de la expresión original

NOTA: La precedencia de los operadores la establecerán los paréntesis

5.- OPERACIONES DE CADENAS:

Las funciones para cadenas son las siguientes:

*LENGTH(nombre_de_la_cadena)

Regresa un valor entero que "contiene" la longitud de la cadena nombre_de_la_cadena

*SUBSTRING(nombre_de_la_cadena,posición_inicial,longitud)

Regresa una cadena,
en donde:
posición inicial es la posición a partir de la cual se copiará el contenido de nombre_de_la_cadena
longitud es el número de caracteres que se copiarán
La forma para copiar el contenido de una cadena hacia otra es:

cadena1=cadena2

La concatenación de cadenas puede ser:

cadena_1 =cadena_2 +cadena_3
cadena_1 =cadena_1 +cadena_2

6.- COMENTARIOS:

-- comentario
/* línea1
línea2
...
línean */

7.- ESTRUCTURA DEL CONTROL:

*ASIGNACION:

variable = valor1 expresión1 variable

*SECUENCIACION:

e1
e2
.
en
o bien: e1, e2, ... ,en

*CONDICION:

if c1 then
e1

if c1 then
e1
else
e2
case variable expresión of
valor1: e1
valor2: e2
...
valorn: en
otherwise: ex
end
donde: otherwise es opcional

*LITERACIONES CONDICIONALES:

while c1
e1
do
e1
until c1
for variable = valor_inicial to c1, incremento decremento
e1

NOTAS:

*Es posible efectuar combinaciones de las estructuras de control de secuenciación, condición e iteración condicional.

*En puede ser una asignación, alguna estructura de control, combinación de estas últimas o una secuenciación delimitada por las palabras reservadas de: begin y end
cn es una condición

*Se recomienda que los pseudocódigos posean una indentación o sangría consistente

8.- FUNCIONES O PROCEDIMIENTOS

func nombre_función (lista_parámetros): tipo
begin
e1
...
en
return variable expresión valor
end

donde:

lista_parámetros, : tipo y return son opcionales
Para llamar a una función o procedimiento se escribe: nombre_función(lista_parámetros)
lista_parámetros en la definición de la función es de la forma: tipo variable1, tipo variable2, ..., tipo variablen
lista_parámetros en el llamado a la función es de la forma: variable1, variable2, ..., variablen

9.- OPERACIONES DE ENTRADA Y SALIDA:

*READ(variable1, variable2, ..., variablen)
Lee una(s) variable(s) del teclado

*WRITE("texto1", ... , "texton", variable1, ... , variablen)
Despliega texto(s) o el valor de una(s) variable(s) en el monitor

*OPEN(archivo, read write append read/write)
Abre un archivo en algún modo (escritura, lectura, adición o lectura/escritura, respectivamente)

*CLOSE(archivo)
Cierra un archivo previamente abierto

*READFILE(archivo, nombreRegistro)
Lee un registro de archivo dejando la información leída en nombreRegistro

*WRITEFILE(archivo, nombreRegistro)
Escribe o sobreescribe el contenido de nombreRegistro en el registro actual de archivo

*EOF(archivo)
Regresa verdadero si es el fin de archivo y falso en caso contrario

*ERROR(archivo)
Regresa verdadero si se presentó un error en la última instrucción ejecutada en un archivo y falso en caso contrario

*SEEK (archivo, inicio final registron)
Se posiciona al inicio, al final o en un registro x de archivo

*POSITION(archivo)
Regresa el número de registro actual en archivo

*El principal objetivo del pseudocódigo es el de representar la solución a un algoritmo de la forma más detallada posible, y a su vez lo más parecida posible al lenguaje que posteriormente se utilizara para la codificación del mismo. Las principales características de este lenguaje son:

Se puede ejecutar en un ordenador

*Es una forma de representación sencilla de utilizar y de manipular.

*Facilita el paso del programa al lenguaje de programación.

*Es independiente del lenguaje de programación que se vaya a utilizar.

*Es un método que facilita la programación y solución al algoritmo del programa. Todo documento en pseudocódigo debe permitir la descripción de:

-Instrucciones primitivas
-Instrucciones de proceso
-Instrucciones de control
-Instrucciones compuestas
-Instrucciones de descripción Estructura a seguir en su realización:

Cabecera:

*Programa:
*Modulo:
*Tipos de datos:
*Constantes:
*Variables:

Cuerpo:

*Inicio
*Instrucciones
*Fin

Para comentar en pseudocódigo se le antepone al comentario dos asteriscos (*)

Ejemplos

* Programa que calcula el área de un cuadrado a partir de un lado dado por teclado.

Programa: area_cuadrado

Modulo: main **( también se puede llamar principal)

Variables:

lado: natural

area: natural

Inicio

Visualizar "Introduce el lado del cuadrado"

Leer lado

Area<- lado * lado

Visualizar "El área del cuadrado es",

area Fin

* Programa que visualice la tabla de multiplicar del numero introducido por teclado

Programa: Tabla multiplicar

Modulo: main

Variables: t: entero

num : entero

Inicio

Visualizar "Introduce un número"

Leer num

Desde t=1 hasta t=10 repetir

Visualizar num, " X", t, "=", num*t

Fin desde Fin

Una vez que tenemos preparado un diagrama de flujos (ordinograma u organigrama) y un pseudocódigo ya podemos comenzar con la codificación del programa en nuestro ordenador. A partir de aquí todo varía dependiendo del lenguaje de programación que utilicemos, pero en todos los programas tendremos que definir los tipos de datos que utilizaremos. De todo esto hablaré en el siguiente artículo.