Probá Códigos

Los arrays de estructuras nos evitan tener que crear muchas variables para diferentes instancias de una estructura. Entonces, si quisiéramos hacer que nuestro programa registre 30 empleados, en vez de crear 30 instancias de una estructura empleado, creamos un array que contenerlos a todos.

Ejemplo
pseudocodigo
estructura: RegistroNomina
entero:Id
cadena[30]:nombre
real:salario
fin_estructura

array[1..30] de RegistroNomina:Empleado

Un registro en Pascal (record) es similar a una estructura en C y aunque en otros lenguajes como C# y C++ las estructuras pueden actuar como clases, en este capitulo restringiremos su definición al puro registro contenedor de diferentes tipos de datos. Un registro se declara con la palabra reservada estructura (struct en ingles) o registro y se declara utilizando los mismos pasos necesarios para utilizar cualquier variable. Primero se debe declarar el registro y a continuación se asignan valores a los miembros o elementos individuales del registro o estructura

Sintaxis 1
estructura: nombre_clase
tipo_1: campo1
tipo_2: campo2
...
fin estructura
Sintaxis 2
registro: nombre_tipo
tipo_1: campo1
tipo_2: campo2
fin_registro

Ejemplo.
estructura: fechaNacimiento
entero:mes
entero:dia
entero:anio
fin_estructura

un campo o miembro son las variables internas a la estructura, en este ejemplo tenemos los campos mes, dia y anio. Un campo puede ser de cualquier tipo de dato, incluso otra estructura

Ejemplo 2.
es…

Los arrays de varias dimensiones son aquellos que pueden referenciar dos tres o mas subíndices. Estos se dividen en dos grupos:
-arrays bidimensionales (2 dimensiones)
-arrays multidimensionales (3 o mas dimensiones)

Un arrays bidimensionales se podría ser V[3,5]

[1,1][1,2][1,3][1,4][1,5]
[2,1][2,2][2,3][2,4][2,5]
[3,1][3,2][3,3][3,4][3,5]

y recorrerlo podría hacerse así
pseudocodigo:
desde i <- 1 hasta 3 hacer
desde j <- 1 hasta 5 hacer
leer(V[i,j]
fin_desde
fin_desde

Un array multidimensional podría ser V[2,3,4]

[1,1,1][1,1,2][1,1,3][1,1,4]
[1,2,1][1,2,2][1,1,3][1,2,4]
[1,3,1][1,3,2][1,3,3][1,3,4]
[2,1,1][2,1,2][2,1,3][2,1,4]
[2,2,1][2,2,2][2,1,3][2,2,4]
[2,3,1][2,3,2][2,3,3][2,3,4]

y recorrerlo podría hacerse así
pseudocodigo:
desde i<-1 hasta 2 hacer
desde j<-1 hasta 3 hacer
desde k<-1 hasta 4 hacer
leer(V[i,j,k]);
fin_desde
fin_desde
fin_desde

Las operaciones que se pueden realizar con vectores son:
-Asignación
-Lectura/Escritura
-Recorrido
-Actualizar(añadir, borrar, insertar)
-Ordenación
-Búsqueda

Asignación:
La asignación de elementos a un vector en pseudocódigo se hace de la siguiente manera se hace así:
V[1] <- 5  a un array V, le agregamos el valor 5 en la posición 1
Lectura/Escritura:
Leer un vector en pseudocódigo se hace de la siguiente manera:
leer(V[1])  leemos la posición 1 de un array V

Recorrido:
Normalmente para recorrer un vector usamos un ciclo
supongamos que tenemos un array V[10] , para recorrerlo haríamos algo como
pseudocódigo:
desde i <- 1 hasta 10 hacer
leer(V[i])
fin_desde
es sencillo

Actualizar:
Esta operación puede constar de tres operaciones:
-añadirelementos
-insertarelementos
-borrarelementos
Añadir quiere decir agregar un nuevo elemento al final del vector. La única condición para esta operación es comprobar que haya espacio en la memoria. En contraste la operación insertar quiere decir introducir ese element…

Un array (vector o matriz) es un conjunto ordenado (tenemos el primero, segundo ... enésimo elemento) de elementos homogéneos (de mismo tipo).

un ejemplo puede ser alumnos  ALUMNOS[3]

| JUAN  | MARTA |  JOSE |

donde si preguntamos por
ALUMNOS[1]  nos contestaran JUAN
ALUMNOS[2]  nos contestaran MARTA
ALUMNOS[3]  nos contestaran JOSE
Este tipo de array se llama unidimensional ya que por cada elemento no tenemos subelementos que correspondan a un mismo indice

Una estructura de datos es una colección de datos que pueden ser caracterizados por su organización y las operaciones que se definen en ella.
Los tipos de datos mas utilizados en los lenguajes de programación son:
datos simples:
-estándar:
-entero (integer)
-real (real)
-caracter (char)
-lógico (boolean)
-definido por el programador:
-subrango (subrange)
-enumerativo (enumerated)
datos estructurados:
-estáticos:
-vectores/matrices (arrays)
-registros (record)
-ficheros/archivos(file)
-conjuntos (set)
-cadenas (string)
-dinámicos:
-listas enlazadas
-pilas
-colas
-arboles
-grafos

De aquí en adelante vamos a ver algunos de estos tipos de datos y sus características

Como ya sabemos, un programa puede llamar a cualquier otro subprograma y este a otro y así sucesivamente. Entonces podemos tener algo como

A llamar_a B, B llamar_a C, C llamar_a D

Pero también podríamos hacer algo como
caso 1
B llamar_a B

o bien

caso 2
A llamar_a B, B llamar_a A


A esto se le llama recursividad, a las funciones que se llaman a ellas mismas ya sea directa o indirectamente.
Por ahora solo veremos esta parte de forma muy general y mas adelante se va a profundizar este tema. La recursividad se puede usar como alternativa a la iteración.
A la recursividad la podemos definir de dos maneras, directa o indirecta. Directa: por ejemplo en el caso 1, la función se llama a si misma explícitamente Indirecta: por ejemplo en el caso 2, la función no se llama así misma explícitamente  sino que primero pasa por otra función antes de efectuar la recursividad.

Las variables utilizadas en los programas principales y subprogramas se clasifican en dos tipos:
-variables locales
-variables globales

Una variable local es aquella que esta declarada y definida dentro de un subprograma(ya sea función o procedimiento). Su acceso es solo permitido dentro del subprograma en el que fue definido.

En cambio una variable global es aquella que esta declarada para el programa o algoritmo principal, del que dependen todos los subprogramas. Su acceso es permitido a todos los subprogramas y al programa principal.

El procedimiento a diferencia de la función se declara con la palabra clave "llamar_a"
pseudocódigo
[llamar_a] nombre [(lista de parametros formales)]

la palabra clave llamar_a es opcional y en la practica depende del lenguaje de programación su implementación.

La declaración de un procedimiento se hace de la siguiente forma

procedimiento nombre [(lista de parametros formales, si los tiene)]
<acciones>
[retorno, si se necesita]
fin_procedimiento

* [] = opcional

vemos que es similar, pero a diferencia de las funciones:
-antes de la palabra clave procedimiento no se necesita declarar qué tipo de retorno tendrá
-los parámetros formales pueden incluirse o no, depende las necesidades, pasa lo mismo con el retorno de valores

Aunque las funciones son herramientas muy útiles para la resolución de problemas, su alcance esta muy limitado. Con frecuencia se requieren subprogramas que calculen varios resultados en vez de uno solo, o que realicen la ordenación de una serie de números, etc. En estas situaciones una función no es apropiada y se necesita disponer del otro tipo de subprograma: el procedimiento (o subrutina)

Un procedimiento o subrutina es un programa que ejecuta un proceso especifico. Ningún valor esta asociado con el nombre del procedimiento; por consiguiente, no puede ocurrir en una expresión. Un procedimiento se llama escribiendo su nombre, por ejemplo, SORT, para indicar que un procedimiento denominado SORT se va a ejecutar. Cuando se invoca el procedimiento, los pasos que lo definen se ejecutan y a continuación se devuelve el control al programa que lo llamo.

Procedimiento versus función
Los procedimientos y funciones son programas cuyo diseño y misión son similares; sin embargo, existen unas d…

Una función debe ser llamada de la siguiente forma
pseudocodigo:
nombre_funcion(lista de parametros actuales)

Cada vez que se llama a una función desde el algoritmo principal se establece automáticamente una correspondencia entre los parámetros formales y los actuales. Debe haber exactamente el mismo número de parámetros actuales que de parámetros formales en la declaración de la función y se presupone una correspondencia uno a uno de izquierda a derecha entre los parámetros formales y los actuales.
Una llamada a la función implica los siguientes pasos:
1.A cada parámetro formal se le asigna el valor de su correspondiente parámetro actual
2.Se ejecuta el cuerpo de acciones de la función
3.Se devuelve el valor de la función al nombre de la función y se retorna al punto de llamada
Luego de invocada la función y que devolvió un valor, se sigue con el flujo del programa.

La declaración de una función requiere una serie de pasos que la definen. Una función como subalgoritmo esat constituído de forma similar a los algoritmos, por lo que tendrá de una cabecera con el tipo de valor devuelto por la función, la palabra clave "función", el nombre de la misma y la lista de argumentos que tomará. A continuación va el cuerpo de la función, que es una serie de acciones cuya ejecución hará que -al final- se asigne un valor al nombre de la función. esto determina el valor particular del resultado que se revolverá al programa invocador

todo esto se ve así
pseudocodigo
<tipo_de_dato> funcion <nombre_funcion_(lista_parametros)
[declaraciones locales a la funcion]
inicio
<acciones>
devolver(<expresion>)
fin_funcion

ejemplo
entero funcion suma(E entero:a,b)
var
resultado:entero
inicio
resultado := a + b
devolver resultado
fin_funcion

Las funciones incorporadas al lenguaje de programación se denominan funciones internas, y las funciones definidas por el usuario se denominan funciones externas . Cuando las funciones internas no permiten realizar el tipo de calculo deseado es necesario recurrir a las funciones externas que pueden ser definidas por el usuario mediante una declaración de función.

A una función  no se le puede llamar explícitamente, sino que se invoca o referencia mediante un nombre y una lista de parámetros(argumentos). El algoritmo o programa llama a la función con el nombre de esta en una expresión seguida de la lista de argumento que deben coincidir en cantidad, tipo y orden con los de la función que fue definida. La función devuelve un único valor.

Las funciones son definidas para realizar tareas especificas: tomar una lista de valores(argumentos) y devolver un único valor.

La sentencia continuar(continue) hace que el flujo de ejecución salte el resto de un cuerpo del bucle para continuar con el siguiente bucle o iteración.

sintaxis:
continuar


ejemplo

desde i = 0 hasta 10 hacer
si i = 4 entonces
continuar
fin_si
escribir(i)
fin_desde

En este ejemplo, se mostraría todos los números desde 0 hasta 10 excepto el 4, esto es porque cuando i es 4 no se muestra i sino que sigue con el bucle (incrementa uno y muestra por pantalla).

La sentencia continuar solo se utiliza dentro de una iteración de un bucle. La sentencia continuar no interfiere en el numero de veces que se repite el cuerpo de un bucle así como sucede con interrumpir.

En ocasiones se desea terminar un bucle en un lugar determinado del cuerpo del bucle en vez de esperar que termine el bucle como estaba determinado. Un uso común de la sentencia interrumpir(break) es en el la sentencia segun_sea(switch)

ejemplo
leer (a)
segun_sea (a) hacer
1:
escribir('a es 1')
interrumpir
2:
escribir('a es 2')
interrumpir
si-no:
escribir('a no es 1 o 2')
fin_segun

Para que hacer esto ?  para que cuando se ejecute un cuerpo de algunas de las condiciones del segun_sea, salga del bucle luego de finalizar de ejecutar el bloque. Esto evita que se sigan evaluando las diferentes condiciones.

Las sentencias de salto son las que se utilizan para influir en el flujo de ejecución durante la ejecución de una sentencia de bucle. Algunas de las que podemos mencionar son:
-interrumpir(break)
-continuar(continue)

Esta estructura suele llamarse desde o para..
La estructura desde ejecuta las acciones del cuerpo del bucle un número especificado de veces, y de modo automático controla el número de iteraciones (o pasos) a través del cuerpo del bucle.

desde v <- vi hasta vf [incremento (opcional)] hacer
<acciones>
fin_desde

nota : vi = valor inicial, vf = valor final.

ejemplo
vf <-10
desde v <- 1 hasta vf hacer
escribir (v)
fin_desde

nota: cuenta de 1 a 10, el incremento por defecto es 1.

La estructura repetir se ejecuta hasta que se cumpla una condición determinada que se comprueba al final del bucle (Así como en la estructura repetir-mientras).

pseudocodigo
repetir
<acciones>
hasta_que (condicion)

ejemplo
repetir
escribir('Escriba un numero')
leer(a)
escribir('Escriba otro mas')
leer(b)
c <- a + b
escribir (a,'+',b,'= ',c)
escribir ('desea realizar otra suma?')
leer(respuesta)
hasta_que (respuesta = N)

El bucle hacer-mientras es análogo al bucle "mientras" con la diferencia que primero se ejecuta el bloque de código de esta estructura y luego se verifica la condición

pseudocódigo
hacer
<acciones>
mientras (<condicion>)

ejemplo
b <- 3
a <- 4
hacer
escribir(b,' es mayor a ', a)
mientras (a > b)

Nota : Este ejemplo esta hecho para advertir sobre el uso de esta estructura, ya que puede generar conflictos a la hora de aplicarla. En el caso del ejemplo no tendría fin y se ejecutaría todo código hasta que cerremos el programa

Algunos bucles no exigen fin y otros no encuentran fin por un error de diseño.
Un bucle que nunca se termina se denomina bucle infinito o sin fin. Los bucles sin fin no-intencionados son perjudiciales para la programación y se deben evitar.  Estos son utilizados por ejemplo para programación de PIC.

La estructura repetitiva mientras(while) es aquella en que el cuerpo del bucle se repite mientras se cumple una determinada condición  Cuando se ejecuta la instrucción mientras, la primera cosa que sucede es que se evalúa la condición (una expresión booleana). Si esta condición es falsa no se toma ninguna acción y el programa sigue con el flujo. Si esta expresión es verdadera entonces se ejecuta las acciones que estén dentro del cuerpo del bucle, después se evalúa nuevamente la condición  Este proceso se repite una y otra vez mientras la expresión booleana(condición) sea verdadero.

pseudocódigo
mientras <condicion> hacer
<accion 1>
<accion 2>
<accion n>
fin_mientras

ejemplo
i <- 0
mientras 3 > i
        escribir(i)
i <- i + 1
fin_mientras

Las estructuras que repiten una secuencia de instrucciones un numero determinado de veces se denominan bucles y se denominan iteración por el hecho de repetir la ejecución de una secuencia de acciones.

Las palabras que encontraremos a menudo en este segundo episodio son:
iterar (loop)
mientras (while)
hacer-mientras (do-while)
repetir (repeat)
desde (for)

Tenemos dos clasificaciones
pre test
mientras (while)
desde(for)
Se llaman pre test porque antes de iterar primero evalúa una condición booleana

post test
repetir
hacer-mientras
Se llaman post test porque primero ejecutan el grupo de acciones en el cuerpo del bucle y luego evalúa la condición. Entonces todo código dentro del bucle se ejecuta 1 vez antes aunque la condición sea falsa.

El flujo de control de un algoritmo siempre es secuencial, excepto cuando las estructuras de control estudiadas anteriormente realizan transferencias de control no secuenciales.
La programación estructurada permite realizar programas fáciles y legibles utilizando las tres estructuras ya conocidas: secuenciales, selectivas y repetitivas. Sin embargo, en ocasiones es necesario realizar bifurcaciones incondicionales; para ello esta la instrucción <<ir_a>> (goto).

Las bifurcaciones o saltos producidos por una instrucción <<ir_a>> deben realizarse a instrucciones que estén numeradas o posean una etiqueta que sirva de punto de referencia para el salto. Pro ejemplo, un programa puede ser diseñado para determinar una detección de un error


algoritmo error
inicio
si <condicion error> entonces
ir_a(100)
fin_si
100:
fin

En algunos lenguajes es necesario crear esta etiqueta (o <<label>>), la etiqueta del algoritmo error seria 100, y estaría situado luego d…

Las estructuras de decisión <<SI-ENTONCES>> y <<SI-ENTONCES-SI_NO>> implican la selección de una de dos alternativas. Es posible también utilizar la instrucción <<SI>> para diseñar estructuras de selección que contengan mas de dos alternativas.

pseudocodigo
si <condicion> entonces
si <condicion2> entonces
<acciones>
fin_si
fin_si

Aquí anidamos dos condiciones, una dentro de la otra.
Hay que tener cuidado al utilizar condiciones anidadas ya que puede tornarse confuso si tenemos un numero excesivo de condiciones, así que se puede usar pero de forma limitada. Sí hay muchas opciones es mejor usar la estructura de alternativa múltiple

ejemplo

si 3 > 1 entonces
si 2 < 3 entonces
escribir('dos es menor a tres y tres es mayor a uno')
fin_si
fin_si

Con frecuencia es necesario que existan mas de dos elecciones posibles. Este problema podría resolver con varias condiciones simples/dobles anidadas o bien con la estructura que veremos a continuación. La alternativa múltiples evaluara una expresión que podrá tomar n valores distintos, 1, 2 ,3 .. n.

algoritmo

segun_sea expresion (E) hacer
e1:
accion 1
accion 2
accion n
e2:
accion 1
accion 2
accion n
en:
accion 1
accion 2
accion n
si-no
accion 1
accion 2
accion n
fin_segun

El funcionamiento es sencillo,  Se toma la expresión E, si <<E>> es igual a e1 entonces se ejecuta el grupo de acciones dentro de <<e1>>.   Si <<E>> es igual a <<e2>> se ejecuta el grupo de acciones dentro de <<e2>>. Si <<E>> es igual a <<en>> entonces se ejecutan las n acciones de <<en>>. En el caso de que <<E>> no sea igual a ninguno de los casos se ejecuta el bloque de acciones de <<si-no>>.


ejemplo
inicio
escri…

La estructura de alternativa simple, es muy limitada y normalmente se necesitara una estructura que permita elegir entre dos opciones o alternativas, en función del cumplimiento de una determinada condición.

En la alternativa doble tenemos la opción de realizar una acción en el caso de que la condición no se cumpla

pseudocódigo

si <condicion> entonces
<accion 1>
<accion 2>
<accion n>
si_no
<accion 1>
<accion 2>
<accion n>
fin_si

Observe que en el pseudocodigo las acciones que dependen de <<entonces>> y <<si_no>> están indentadas en relación con las palabras <<si> y <<fin_si>>; indentar aumenta la legibilidad del código y es una buena practica para representar no tan solo algoritmos, sino también en el lenguaje de programación que vayas a utilizar (el que sea)

Ejemplo

si 3<1 entonces
escribir('tres es menor a uno')
si-no
escribir('tres no es menor a uno')
fin_si

La estructura selectiva simple si-entonces (o if-then) ejecuta una determinada accion cuando se cumple una condicion. La seleccion si-entonces evalua la condicion y, si la condicion es verdadera ejecuta las acciones que contiene en su estructura, sino continua el flujo normal del programa.
pseudocodigo inicio si <condicion> entonces <accion 1> <accion 2> ... <accion n> fin_si fin
ejemplo inicio si 3 > 1 entonces escribir('tres es mayor a uno'); fin_si fin

La especificación formal de algoritmos tiene realmente utilidad cuando el algoritmo requiere una descripción mas complicada que una lista sencilla de instrucciones. Las estructuras selectivas se utilizan para tomar decisiones lógicas.  También se les suele llamar estructuras de decisión o alternativas.

En las estructuras selectivas se evalúa una condición y, en función del resultado se realiza una acción u otra. Las condiciones se especifican utilizando expresiones lógicas  La representación de una estructura selectiva se hace con palabras en pseudocódigo("si", "entonces", "sino" o bien en ingles "if", "then", "else").
Las estructuras selectivas o alternativas pueden ser:
-Simples
-Dobles
-Múltiples

Una estructura secuencial es aquella en la que una acción o instruccion sigue a otra en secuencia. Las tareas se suceden de tal modo que la salida de una es la entrada de la siguiente y asi sucesivamente hasta el final del proceso.

Representacion en pseudocodigo
inicio
<accion 1>
<accion 2>
..
..
<accion n>
fin

EJEMPLO 1
inicio
leer(a)
leer(b)
aux <- a + b
escribir(aux)
fin

EJEMPLO 2
inicio
leer(a)
aux <- a * a
escribir(aux)
fin

Se reconoce que cualquier algoritmo, no importa su complejidad, puede ser construido utilizando combinaciones de tres estructuras de control estandarizadas que son; la secuencial, selección, repetitiva(o iterativa) y una cuarta denominado, invocación (o salto <<jump>>)

Las sentencias de selección son:
    Si  (if)
    Segun-sea (switch)
Las sentencias de repeticion son:
    Desde (for)
    Mientras (while)
    Hacer-Mientras (do-while) o repetir-hasta que (repeat-until)
Las sentencias de salto o bifurcación son:
    romper (break)
    continuar (continue)
    ir-a (goto)
    volver o retornar(return)
    lanzar (throw)

El termino flujo de control se refiere al orden en que se ejecutan las sentencias de programación. Otros términos utilizados son secuenciación y control de flujo. A menos que se especifique expresamente, el flujo normal de control de todos los programas es secuencial. Este término significa que las sentencias se ejecutan en secuencia, una después de la otra,…