República Bolivariana de Venezuela

Ministerio del Poder Popular Para la Educación Universitaria

Universidad Nacional Experimental Rómulo Gallegos
Área de Ingeniería de Sistemas
Programa de Ingeniería En Informática
Núcleo Calabozo
Semestre 2 sección 1

Sub - algoritmos.

Profesor: Bachiller:
Ing. José Cuenca Luisana López
C.I. V-30.547.166

Enero 2.023
 Índice
Pág.
Introducción-------------------------------------------------------------------------------- 3
Procedimientos y funciones-------------------------------------------------------------- 4
Parámetros por valor y por referencia-------------------------------------------------- 6
Introducción a las estructuras de datos estáticas (Arreglos) ------------------------- 8
Conclusión---------------------------------------------------------------------------------- 13
Bibliografía--------------------------------------------------------------------------------- 14
 Introducción

Dados un estado inicial y una entrada, siguiendo los pasos sucesivos se llega a
un estado final y se obtiene una solución. Los algoritmos son el objeto de estudio de
la algoritmia. En la vida cotidiana, se emplean algoritmos frecuentemente para
resolver problemas. Algunos ejemplos son los manuales de usuario, que muestran
algoritmos para usar un aparato, o las instrucciones que recibe un trabajador por parte
de su patrón. Algunos ejemplos en matemática son el algoritmo de la división para
calcular el cociente de dos números, el algoritmo de Euclides para obtener el máximo
común divisor de dos enteros positivos, o el método de Gauss para resolver un
sistema lineal de ecuaciones.
Procedimientos y funciones

Uno de los métodos fundamentales para resolver un problema es dividirlo en

problemas más pequeños, llamados subproblemas. Estos problemas pueden a su vez
dividirse repetidamente en problemas más pequeños hasta que
los problemas sean de fácil solución. Divide y vencerás Cada subproblema es
deseable que sea independiente de los demás y se denomina módulo. El problema
original se resuelve con un programa principal (llamado también driver o main), y los
subproblemas (módulos) mediante subprogramas: procedimientos y funciones. Los
subproblemas o módulos se diseñan con subprogramas, que a su vez se clasifican en
procedimientos y funciones. Los procedimientos y funciones son unidades de
programas diseñados para ejecutar una tarea específica. Por ejemplo los
procedimientos predefinidos LEER y ESCRIBIR están diseñados para realizar
operaciones de entrada y salida de datos de un programa. El proceso de
descomposición de un problema en módulos se denomina modularización. Los
procedimientos y funciones asisten a la programación modular. Las funciones,
normalmente, devuelven un sólo valor a la unidad de programa (programa que invoca
a la función) que las referencia. Los procedimientos pueden devolver cero, uno o
varios valores. En el caso de no devolver ningún valor, realiza alguna tarea tal como
alguna operación de entrada y/o salida. A un procedimiento no se le puede asignar
valor, y por consiguiente ningún tipo está asociado con el nombre del procedimiento.
Una función se diferencia utilizando su nombre en una expresión, mientras que un
procedimiento se diferencia por su llamada o invocación al mismo.

Sin embargo, un sub-algoritmo es el que recibiendo o no datos devuelve un

único resultado. Tienen su origen ligado al concepto matemático de función de una o
más variables. Ejemplo de este tipo de sub-algoritmos son las llamadas funciones
internas (sin, cos, abs). Las cuales pueden usarse en expresiones algorítmicas como si
se tratara de variables.
 Otros ejemplos de funciones matemáticas: f( x ) = x2 + 2x – 1 g( x , y ) = x3 +
5y h( x , y , z ) = 3x + 2y – z parámetro formales. Donde x,y,z: son los parámetros
formales o ficticios, es decir permiten expresar la ley o “forma” de la función.
Las funciones pueden tener uno o más parámetros formales (datos) pero siempre
devuelven un único resultado. Las funciones son evaluadas utilizando parámetros
actuales o reales, es decir los valores con los que se quiere evaluar la función:
f( 3 ) g( -1 , 5 ) h( 2 , 0 , 7 )parámetros actuales.

Del mismo modo, una función es un objeto del ambiente, con nombre, tipo y
valor único. El tipo se asocia al valor que retorna la función cuando es evaluada para
un conjunto dado de valores de sus argumentos Función nombre (lista de parámetros
formales): Tipo de resultado Declaración de variables Inicio Acciones Devolver
(constante, variable o expresión) Fin función.

 Lista de parámetros formales: contiene las variables que pasan alguna

información necesaria para que la función ejecute el conjunto de acciones.

 Tipo de resultado: señala el tipo de dato que devuelve la función.

 Declaración de variables: en este lugar se deben declarar los parámetros

formales y también aquellas variables que se usarán en la función.

 Cuerpo de la función: lo constituye el conjunto de acciones a realizar por la

función.

 Retornar el resultado: el único resultado que devuelve la función puede ser

un valor constante, o una variable o una expresión válida, la cual debe
colocarse entre paréntesis al lado de la acción Devolver. Cuando se ejecuta
 esta acción se devuelve el control del programa al lugar donde se ha llamado a
la función.

Parámetros por valor y por referencia

Al pasar parámetros a las funciones podemos hacerlo de dos formas, por valor
y por referencia. La forma de hacerlo en PSeInt es colocando junto al parámetro
las palabras Por Valor o Por Referencia, en el momento de declarar la función. Si
no se escribe nada, por defecto se asigna Por Valor.

 Valor: La función recibe una copia del valor de la variable, dentro de la

función dicha variable se puede utilizar para operar o lo que haga falta, pero
su valor no se modificará, al salir del ámbito de la función tendrá el mismo
valor que antes de entrar en ella.

Funcion porValor (a Por Valor)

// Se le cambia el valor a la variable
a = 1000;
Escribir "DENTRO DE porValor SE CAMBIA A: " +
ConvertirATexto(a);
Escribir " ";
FinFuncion

Este proceso, relativamente complejo, se realiza con notable velocidad en el

procesador, que cuenta con instrucciones especializadas para muchas de las fases que
se han mencionado. Pero ciertamente la fase de activación y retorno supone un
tiempo "muerto", en el sentido de que sólo se efectúan cálculos en la fase de
ejecución propiamente dicha. Es bueno, entonces reducir el número de llamadas a
función cuando el tiempo necesario para las fases 1, 2 y 4 es comparable con el
tiempo dedicado a la fase 3. Los compiladores, consciente de esto, admiten como
opción la creación de funciones inline .

 Referencia: La función recibe la posición de memoria en la cual se guarda el

valor de la variable, y si se cambia su valor dentro de la función el cambio
permanece, dentro y fuera del ámbito de la función.

Funcion porReferencia(b Por Referencia)

// Se le cambia el valor a la variable
b = 500;

Escribir "DENTRO DE porReferencia SE CAMBIA A: " +

ConvertirATexto(b);
Escribir " ";
FinFuncion

El paso de parámetros en C está construido de tal modo que los valores

resultantes de evaluar los parámetros formales se copian en los parámetros formales.
Como los parámetros formales son variables distintas de los parámetros reales, los
cambios efectuados en los parámetros foramales no afectan para nada a los
parámetros reales. Esto es cierto e insalvable, pero disponemos de un auxiliar
sumamente interesante: los punteros. En efecto, considérese el siguiente fragmento de
código:
int p;
int * q = &p;
*q = 33;

Como puede verse, hemos modificado el valor del entero p a través de un

puntero. A todos los efectos, *q equivale a p , esto es, se puede poner *q en cualquier
lugar en que aparezca p . Esto puede aplicarse al paso de parámetros: si en lugar de
pasar el valor de un parámetro real se pasa la dirección del parámetro real en
cuestión, entonces será posible modificar el valor del parámetro real deshaciendo la
indirección (anteponiendo un asterisco al puntero) desde el interior de la función

Introducción a las estructuras de datos estáticas (Arreglos)

Las estructuras de datos se utilizan, generalmente, para procesar una colección

de valores que están relacionados entre sí por algún método. Por ejemplo: una lista de
notas, una serie de puntajes de un concurso o una lista de temperaturas medidas a lo
largo de un período de tiempo. Las estructuras de datos básicas que soportan la
mayoría de los lenguajes de programación son las estructuras estáticas. Una
estructura de datos estática es aquella en la que el tamaño ocupado en memoria se
define antes de que el programa se ejecute y no puede modificarse dicho tamaño
durante la ejecución del programa. Entre las estructuras de datos estáticas se
encuentran los arreglos (arreglos unidimensionales - vectores y arreglos
bidimensionales - matrices). Hasta ahora todos los algoritmos que hemos desarrollado
hacen uso de objetos que guardan datos individuales, los cuales representan un
número, una cadena de texto o un valor lógico. Sin embargo, la verdadera utilidad de
la computación radica en poder trabajar con conjuntos de datos, organizados de
acuerdo a ciertas reglas que permitan su manipulación y acceso. Definimos entonces
como estructura de datos a un conjunto de datos que cuentan con un sistema de
organización.

Veremos dos tipos de estructuras de datos: los arreglos y las listas.

 Arreglos :Un arreglo se define como una colección de valores individuales

con dos características fundamentales:

 Ordenamiento: los valores individuales pueden ser enumerados en orden, es

decir, debe ser posible identificar en qué posición del arreglo se encuentra
cada valor.
  Homogeneidad: los valores individuales almacenados en un arreglo son
todos del mismo tipo (numérico, carácter, lógico).

Los arreglos son muy útiles para almacenar información en la memoria de la

computadora, organizando valores que estén relacionados entre sí de alguna manera,
por ejemplo, una conjunto de precios, los meses del año, el listado de calificaciones
de estudiantes en distintos parciales, etc. Los componentes individuales del conjunto
se llaman elementos. Para indicar qué posición ocupa cada elemento en el arreglo se
emplean uno o más índices. Dependiendo de cuántos índices se deban utilizar para
acceder a cada elemento dentro de los arreglos, estos se clasifican en
unidimensionales (vectores), bidimensionales (matrices) o multidimensionales. Al
igual que todas las variables que empleamos en nuestros algoritmos, los vectores que
serán utilizados deben ser declarados en el pseudocódigo, eligiendo un identificador
(nombre) e indicando su tipo y su tamaño, es decir, la cantidad de posiciones que
contienen. Esto último se señala entre paréntesis al lado del nombre elegido. Por
ejemplo, el vector x visto anteriormente puede ser creado de la siguiente forma:

VARIABLE numérica x(5)

x[1] <- -4.5
x[2] <- 12
x[3] <- 2.71
x[4] <- -6
x[5] <- 25

Si bien la declaración de un vector sólo tiene como objetivo permitirle a la

computadora que reserve internamente el espacio necesario en memoria para el
mismo, para escribir pseudocódigo de una manera sencilla estableceremos la
siguiente convención. Cuando declaramos un vector de tipo numérico con la
expresión VARIABLE numérica x(5) asumiremos que, además de reservar espacio en
memoria para el vector, se le asigna un 0 (cero) en cada posición. Es decir, el vector x
es iniciado con ceros, que más tarde pueden ser reemplazados por otros valores. Del
mismo modo, asumiremos que cuando declaramos vectores de tipo carácter, todos sus
elementos son iniciados con valores "" (una cadena de texto vacía) y cuando
declaramos vectores de tipo lógico, con el valor FALSO. En R, los vectores se
construyen de forma dinámica por lo cual no es necesario declararlos antes de
comenzar a utilizarlos. La función c() (de combinar) permite crear vectores, por
ejemplo, los mencionados anteriormente:

x <- c(-4.5, 12, 2.71, -6, 25)

y <- c("ARG", "correo@gmail.com", "Ok", "chau")
z <- c(TRUE, TRUE, FALSE)

Cuando ejecutamos dichas líneas, se crean en el ambiente global los objetos

x, y y z, como podemos notar en la pestaña Environment de RStudio. Es decir, los
vectores, así como cualquier otro tipo de arreglo, son objetos que constituyen
entidades en sí mismas y que pueden ser manipulados al hacer referencia a sus
indicadores. Además, RStudio nos muestra en la pestaña mencionada qué tipo de
vector es cada uno (num, chr, logi), cuántos elementos tiene ([1:5], [1:4], [1:3])
y una previsualización de sus primeros elementos. Dado que la función c() resulta,
en consecuencia, muy importante al programar en R, es recomendable que evitemos
usar la letra c como nombre para otros objetos. Podemos emplear estructuras
iterativas para recorrer todas las posiciones de un vector y realizar operaciones con
ellas, por ejemplo:
PARA i DESDE 1 HASTA 5 HACER
ESCRIBIR "La posición " i "de x está ocupada por el valor " x[i]
FIN PARA
for (i in 1:5) {
cat("La posición", i, "de x está ocupada por el valor", x[i], "\
n")
}
La posición 1 de x está ocupada por el valor -4.5
La posición 2 de x está ocupada por el valor 12
La posición 3 de x está ocupada por el valor 2.71
La posición 4 de x está ocupada por el valor -6
La posición 5 de x está ocupada por el valor 25
 Todos los lenguajes de programación incluyen, además, alguna función para
determinar cuántos elementos tiene un vector que ya fue creado. Para esto
emplearemos la expresión LARGO() en el pseudocódigo y la función length de R:

ESCRIBIR "El vector x tiene " LARGO(x) " elementos."

ESCRIBIR "El vector y tiene " LARGO(y) " elementos."
ESCRIBIR "El vector z tiene " LARGO(z) " elementos."
cat("El vector x tiene", length(x), "elementos.")
El vector x tiene 5 elementos.
cat("El vector y tiene", length(y), "elementos.")
El vector y tiene 4 elementos.
cat("El vector z tiene", length(z), "elementos.")
El vector z tiene 3 elementos.

Entonces, para recorrer todos los elementos del vector podemos hacer
también:

PARA i DESDE 1 HASTA LARGO(x) HACER

ESCRIBIR "La posición " i "de x está ocupada por el valor " x[i]
FIN PARA

O bien:

tam <- LARGO(x)

PARA i DESDE 1 HASTA tam HACER

ESCRIBIR "La posición " i "de x está ocupada por el valor " x[i]
FIN PARA

Las estructuras de datos dinámicas son aquellas en las que el tamaño podrá
modificarse durante la ejecución del programa; teóricamente no hay límites a su
tamaño, salvo el que impone la memoria disponible en la computadora. Los arreglos
se caracterizan por las siguientes propiedades:

1. Cantidad de elementos prefijada: esto determina el tamaño del bloque de memoria

que ocupará.

2. Elementos directamente accesibles: al ubicarse en posiciones adyacentes son

fácilmente individualizables.
3. Elementos de igual tipo: esto determina que, independientemente, todos ocupan la
misma cantidad de bytes. Sus elementos se identifican a través de un índice. También
se denominan “vectores” por su similitud con los vectores matemáticos, si son
arreglos que sólo presentan una dimensión. Por ejemplo: tenemos el conjunto de
notas obtenidas por los alumnos durante un parcial. Cada nota individual es guardada
en un elemento Nota(i), donde “Nota” indica el nombre del arreglo y el índice i
significa a qué valor en particular nos estamos refiriendo.
 Conclusión

"Dada la  conceptualización suministrada y estudiada de algoritmo,

entendemos  que son una herramienta versátil para facilitar el "paso a paso" y llegar
fácilmente  a construir el camino hacia un fin determinado, llámese tarea,  receta,
planes o guías para, planes de acceso o planes de emergencia de entrada o salida,  etc.
Luego de realizar este trabajo e visto como los algoritmos son una de las herramientas
más complejas y aplicables en el área no solo de la informática y el mundo de los
computadores sino también en el mundo empresarial y de trabajo. Pude comprobar
que mientras más potente, completo y eficiente es el computador o la aplicación que
corre sobre el mismo más grande, complejo y exacto es el algoritmo que utiliza.

Bibliografía
https://usuarios.fceia.unr.edu.ar/~sorribas/info1_notas_de_clase_3.pdf
https://terepebernal.com/blog/pseudocodigo/arreglos-y-parametros-por-referencia/
http://maxus.fis.usal.es/FICHAS_C.WEB/08xx_PAGS/0803.html#anchor65773
https://docplayer.es/50245134-Capitulo-3-estructuras-de-datos-estaticas.html
https://usuarios.fceia.unr.edu.ar/~sorribas/info1_notas_de_clase_4.pdf
https://learn.microsoft.com/es-es/dotnet/visual-basic/programming-guide/language-
features/procedures/differences-between-passing-an-argument-by-value-and-by-
reference
https://docs.hektorprofe.net/python/programacion-de-funciones/paso-por-valor-y-
referencia/