7 Arreglos

En las secciones anteriores se ha trabajado con tipos de datos primitivos o elementales (atomic types) que representan un único dato como un número entero o real, una letra o un valor booleano. Sin embargo, en muchas situaciones se requiere trabajar con una colección de valores que agrupados hacen parte de un todo. Los tipos de datos compuestos son estructuras de datos que permiten en una misma variable e identificador puede representar más de un dato o valor primitivo. Hay dos tipos de datos compuestos con los que ya hemos trabajado, uno de ellos son las cadenas, que son una secuencia de carácteres, y el otro son los números complejos, que están compuestos por dos números reales.

En esta sección se hará una revisión de los arreglos o arrays, tipos de datos compuestos y estructuras de datos básicas que incorporan una gran mayoría de lenguajes de programación. Un arreglo es una colección finita de datos del mismo tipo, que se almacenan en posiciones consecutivas de memoria y reciben un nombre común. Para referirse a un determinado elemento de un arreglo se deberá utilizar un índice, el cual especifica su posición relativa dentro del arreglo. Los arreglos podrán ser unidimensionales o multidimensionales, sin embargo, como la memoria de la computadora es lineal, un arreglo multidimensional tendrá que tener un equivalente linealizado (un arreglo unidimensional equivalente) para su almacenamiento en memoria.

Se espera que al finalizar las actividades de esta sección, el estudiante tenga clara la manera en que se hace uso de los arreglos en el diseño de un algoritmo bajo el paradigma de programación imperativa estructurada.

Preparación de clase

Leer las secciones 7.1 a 7.6 del libro: L. Joyanes Aguilar, Fundamentos de programación: algoritmos, estructura de datos y objetos. McGraw Hill, 2020 [Online]. Disponible en http://www.ebooks7-24.com.ezproxy.unal.edu.co/?il=10409 o en http://www.ebooks7-24.com.ezproxy.biblored.gov.co/?il=10409

En sus propias palabras, explique lo que le transmitió y lo que le enseño cada parte de lo que leyó en el texto, incluya su discusión, reflexiones y conclusiones al respecto; exponga lo que no entendió e intente encontrar por su cuenta respuestas a las preguntas que le surgieron, para poder compartirlas en clase.

7.1 Arreglos unidimensionales

Ya se mencionó que un arreglo es una colección finita de datos del mismo tipo, que se almacenan en posiciones consecutivas de memoria y reciben un nombre común. En el caso de un arreglo unidimensional estamos hablando de una estructura de datos que tendría cierta equivalencia o similaridad con el objeto matemático: vector, ya que ambos corresponden a una secuencia de valores ordenados, que son indexados por un único índice asociado a una única dimensión. El tamaño de un arreglo unidimensional es la cantidad de elementos del arreglo en su única dimensión.

Las variables de tipo arreglo se deben declarar como cualquier otra variable. Sin embargo, cuando un arreglo se declara, adicionalmente se debe informar el tipo de dato de los elementos del arreglo. Es decir, la declaración se debe hacer en función de otro tipo de dato conocido o previamente definido. En pseudocódigo, la declaración de un arreglo unidimensional podría hacerse de la siguiente manera:

var

  arreglo tipo_dato: nombre_arreglo[tamaño_arreglo], …

  …

Dependiendo del lenguaje de programación, la indexación de los elementos del arreglo: nombre_arreglo va de 0 a tamaño_arreglo - 1 o de 1 a tamaño_arreglo. Usando los valores del índice, los elementos de un arreglo son igualmente accesibles y cualquiera de ellos puede ser seleccionado para lo que se desee hacer. Para seleccionar el elemento en la posición i del arreglo, se escribe: nombre_arreglo[i]. Para todo efecto práctico, cada elemento del arreglo: nombre_arreglo se comporta como si fuese una variable de tipo: tipo_dato.

Los elementos de un arreglo se pueden recorrer por completo, mediante el uso de una estructura iterativa y una variable que pase por todos los valores de la indexación. Por ejemplo:

i <- 0

mientras i < tamaño_arreglo hacer

  escribir(nombre_arreglo[i])

  i <- i + 1

fin_mientras

De la misma manera en que ocurre con los demás tipos de datos, un subprograma puede recibir variables de tipo arreglo o puede devolver una variable de tipo arreglo. La capacidad de devolver una variable de tipo arreglo permite a un subprograma devolver uno o más valores o datos de un mismo tipo de dato.

Especialmente en el caso de los arreglos, debemos tener claras las dos formas distintas en que un programa principal puede pasar / un subprograma puede recibir los parámetros, parámetros por valor y parámetros por referencia.

7.1.1 Paso de parámetros por valor

Paso por valor o paso por copia significa que cuando se llama un subprograma, este recibe una copia de los valores de los parámetros en un espacio de memoria aparte. Si el valor de un parámetro se modifica mediante una o más asignaciones o instrucciones del subprograma, el cambio solamente tiene efecto dentro del subprograma y no por fuera de él.

En varios lenguajes de programación, los parámetros que sean de un tipo de dato primitivo o elemental se suelen pasan por valor / copia.

7.1.2 Paso de parámetros por referencia

Paso por referencia o paso por dirección significa que cuando se llama un subprograma, este recibe la dirección de lo que se le halla dado a los parámetros. Esto quiere decir que las etiquetas, identificadores o nombres de los parámetros al interior del subprograma quedan apuntando a elementos con sus propios espacios de memoria que existen y se encuentran fuera del subprograma. Esto también quiere decir que cuando una o más asignaciones o instrucciones del subprograma modifican los valores de los parámetros, estas modificaciones tienen efecto en los espacios de memoria que existen y seguirán existiendo fuera del subprograma (las modificaciones dentro del subprograma tendrán efecto dentro y fuera del subprograma).

En varios lenguajes de programación, los parámetros que sean de tipo de dato arreglo (array) se suelen pasar por referencia / dirección.

7.2 Arreglos multidimensionales

Los arreglos multidimensionales son aquellos en donde cada elemento del arreglo está indexado por más de un índice (por más de un subíndice cuando los elementos del arreglo se denotan de la siguiente manera: a_{i,j,k,l}). La dimensión de un arreglo es la cantidad de índices distintos que tenga o use el arreglo para sus elementos (en a_{i,j,k,l} serían 4 dimensiones). Cada índice tendrá una cantidad máxima de valores posibles y esa cantidad se denomina el tamaño de cada dimensión (n, m, o y p si 0 \leq i < n, 0 \leq j < m, 0 \leq k < o, 0 \leq l < p). La cantidad total de elementos del arreglo es igual al producto de los tamaños de todas las dimensiones ((n)(m)(o)(p)). Cuando se habla del tamaño de un arreglo, se está refiriendo a los tamaños de cada dimensión (el arreglo con elementos a_{i,j,k,l} es de tamaño n \times m \times o \times p).

En pseudocódigo, la declaración de un arreglo multidimensional podría hacerse de la siguiente manera:

var

  arreglo tipo_dato: nombre_arreglo[tam_dim1, tam_dim2, tam_dim3, …], …

  …

Obviamente, un arreglo bidimensional necesita dos índices para poder identificar a cada elemento del arreglo (de la misma manera en que cada elemento de una matriz tiene asociado dos subíndices). La referencia a un determinado elemento del arreglo bidimensional requiere emplear un primer valor para el primer índice y un segundo valor para el segundo índice (si es de alguna utilidad, el primer valor se puede interpretar como un número de fila y el segundo como un número de columna, pero no se está obligado a seguir esta interpretación). Por ejemplo, nombre_arreglo[0, 0] hace referencia al elemento de la posición: 0, 0 (en la interpretación mencionada, el elemento de la fila 0 y la columna 0). Cada elemento del arreglo tendrá todos los beneficios y limitaciones de una variable de tipo: tipo_dato. Para seleccionar un elemento de un arreglo multidimensional bastaría hacer: nombre_arreglo[i, j, k, ...], para los valores i, j, k, etc. que correspondan a la posición del elemento deseado.

Para recorrer por completo los elementos de un arreglo bidimensional se requiere usar dos estructuras iterativas anidadas y dos variables que pasen por todos los valores de ambas indexaciones (una estructura y una variable por cada una de las dos dimensiones). Por ejemplo, fijando el valor para el primer índice mientras se recorren los valores del segundo índice (recorrido por filas, es decir se fija una fila mientras se recorren las columnas, para luego pasar a la siguiente fila, etc.):

i <- 0

mientras i < tam_dim1 hacer

  j <- 0

  mientras j < tam_dim2 hacer

    escribir(nombre_arreglo[i, j])

    j <- j + 1

  fin_mientras

  i <- i + 1

fin_mientras

o, fijando el valor para el segundo índice mientras se recorren los valores del primer índice (recorrido por columnas, es decir se fija una columna mientras se recorren las filas, para luego pasar a la siguiente columna, etc.):

j <- 0

mientras j < tam_dim2 hacer

  i <- 0

  mientras i < tam_dim1 hacer

    escribir(nombre_arreglo[i, j])

    i <- i + 1

  fin_mientras

  j <- j + 1

fin_mientras

Para recorrer los elementos de un arreglo de d dimensiones, se requieren d estructuras iterativas anidadas con sus respectivas d variables para los d índices.

7.3 Ejercicios

7.3.1 Parte A

Para los siguientes puntos:

Implemente un único programa principal que se encargue de interactuar con el usuario y que le permita probar los subalgoritmos requeridos con los valores que desee.
Los subalgoritmos deben recibir todo arreglo como un parámetro por referencia / dirección.

Realice un adecuado análisis y diseño de un subalgoritmo cuya única tarea sea:

Almacenar en todos los elementos un arreglo real arregloRecibeDatos de tamaño k, un mismo número real real1 (El subalgoritmo recibe arregloRecibeDatos, real1 y k. El subalgoritmo no devuelve.). Es decir, un subalgoritmo que hace para una variable de tipo arreglo, algo similar a lo que hace variable = 1.2 para variable de tipo de dato real.
Imprimir por pantalla los valores almacenados en cada uno de los elementos de un arreglo real arregloTieneDatos de tamaño k (El subalgoritmo recibe arregloTieneDatos y k. El subalgoritmo no devuelve.). Es decir, un subalgoritmo que hace para una variable de tipo arreglo, algo similar a lo que hace escribir(variable) para una variable de un tipo de dato elemental / primitivo.
Almacenar en un arreglo real arregloRecibeDatos de tamaño k, los números reales que el usuario ingrese por teclado (El subalgoritmo recibe arregloRecibeDatos y k. El subalgoritmo no devuelve.). Es decir, un subalgoritmo que hace para una variable de tipo arreglo, algo similar a lo que hace leer(variable) para un variable de un tipo de dato elemental / primitivo.
Almacenar en un arreglo real arregloRecibeDatos de tamaño k, los valores de cada uno de los elementos de otro arreglo real arregloTieneDatos del mismo tamaño (El subalgoritmo recibe arregloRecibeDatos, arregloTieneDatos y k. El subalgoritmo no devuelve.). Es decir, un subalgoritmo que hace para variables de tipo arreglo, algo similar a lo que hace variable1 = variable2 para una variable1 y variable2 de un tipo de dato elemental / primitivo.
Almacenar en un arreglo real arregloRecibeDatos de tamaño k, una secuencia de valores generados a partir de: un número real valIni para el valor inicial de la secuencia y un número real valIncrem para el incremento (o decremento si es un número negativo) que se debe aplicar (El subalgoritmo recibe arregloRecibeDatos, k, valIni y valIncrem. El subalgoritmo no devuelve.). No es necesario un número real para el valor final de la secuencia, ya que el valor final queda totalmente determinado por el valor inicial, el incremento y el tamaño del arreglo. Si el valor inicial es 1.23, el incremento es -0.98 y el tamaño es 5, entonces al valor final no le queda de otra que ser -2.69 (Los valores que recibiría arregloRecibeDatos serían 1.23, 0.25, -0.73, -1.71 y -2.69).
Almacenar en un arreglo real arregloResultado de tamaño k, el inverso aditivo de cada uno de los elementos de otro arreglo real arregloTieneDatos del mismo tamaño (El subalgoritmo recibe arregloResultado, arregloTieneDatos y k. El subalgoritmo no devuelve.). Es decir, un subalgoritmo que hace para variables de tipo arreglo, algo similar a lo que hace resultado = -variable para resultado y variable de tipo de dato real.
Devolver la suma de todos los elementos de un arreglo real arregloTieneDatos de tamaño k (El subalgoritmo recibe arregloTieneDatos y k. El subalgoritmo devuelve un número real realResultado.).
Almacenar en un arreglo real arregloResultado de tamaño k, la suma término a término de los elementos de dos arreglos reales arregloPrimerSumando y arregloSegundoSumando, del mismo tamaño que arregloResultado (El subalgoritmo recibe arregloResultado, arregloPrimerSumando, arregloSegundoSumando y k. El subalgoritmo no devuelve.).
Almacenar en un arreglo real arregloResultado de tamaño k, la suma de un número real realSumando1 con cada uno de los elementos de un arreglo real arregloSumando2 del mismo tamaño que arregloResultado (El subalgoritmo recibe arregloResultado, realSumando1, arregloSumando2 y k. El subalgoritmo no devuelve.). ¿Qué debo hacer si adicionalmente quiero un subalgoritmo que haga la suma de cada uno de los elementos de un arreglo real arregloSumando1 con un número real realSumando1 (Este subalgoritmo recibe arregloResultado, arregloSumando1, realSumando2 y k. Este subalgoritmo no devuelve)?.
Almacenar en un arreglo real arregloResultado de tamaño k, la suma acumulada de los elementos de otro arreglo real arregloTieneDatos del mismo tamaño (El subalgoritmo recibe arregloResultado, arregloTieneDatos y k. El subalgoritmo no devuelve.). Es decir, para un arreglo con los valores 2.1, 4.3, 6.5 y 8.7 (en ese orden), el arreglo resultante con la suma acumulada deberá tener los valores 2.1, 6.4, 12.9 y 21.6 (en ese orden).
Devolver el producto de todos los elementos de un arreglo real arregloTieneDatos de tamaño k (El subalgoritmo recibe arregloTieneDatos y k. El subalgoritmo devuelve un número real realResultado.).
Almacenar en un arreglo real arregloResultado de tamaño k, el producto término a término de los elementos de dos arreglos reales arregloPrimerFactor y arregloSegundoFactor, del mismo tamaño que arregloResultado (El subalgoritmo recibe arregloResultado, arregloPrimerFactor, arregloSegundoFactor y k. El subalgoritmo no devuelve.).
Almacenar en un arreglo real arregloResultado de tamaño k, el producto de un número real realFactor1 con cada uno de los elementos de un arreglo real arregloFactor2 del mismo tamaño que arregloResultado (El subalgoritmo recibe dos arreglos y un número real. El subalgoritmo no devuelve.). ¿Qué debo hacer si adicionalmente quiero un subalgoritmo que haga la suma de cada uno de los elementos de un arreglo real arregloFactor1 con un número real realFactor1 (Este subalgoritmo recibe arregloResultado, arregloFactor1, realFactor2 y k. Este subalgoritmo no devuelve)?
Almacenar en un arreglo real arregloResultado de tamaño k, el producto acumulado de los elementos de otro arreglo real arregloTieneDatos del mismo tamaño (El subalgoritmo recibe arregloResultado, arregloTieneDatos y k. El subalgoritmo no devuelve.). Es decir, para un arreglo con los valores 2.0, 3.0, 5.0 y 7.0 (en ese orden), el arreglo resultante con el producto acumulado deberá tener los valores 2.0, 6.0, 30.0 y 210.0 (en ese orden).
Devolver el producto punto / escalar de los dos objetos matemáticos vector asociados a dos arreglos reales arregloPrimerFactor y arregloSegundoFactor del mismo tamaño k (El subalgoritmo recibe arregloPrimerFactor, arregloSegundoFactor y k. El subalgoritmo devuelve un número real realResultado.).
Almacenar en un arreglo real arregloResultado de tamaño k, la diferencia término a término de los elementos de dos arreglos arregloMinuendo y arregloSustraendo, del mismo tamaño que arregloResultado. (El subalgoritmo recibe arregloResultado, arregloMinuendo, arregloSustraendo y k. El subalgoritmo no devuelve.).
Almacenar en un arreglo real arregloResultado de tamaño k, la diferencia de cada uno de los elementos de un arreglo real arregloMinuendo, del mismo tamaño que arregloResultado, con un número real realSustraendo. (El subalgoritmo recibe arregloResultado, arregloMinuendo, realSustraendo y k. El subalgoritmo no devuelve.).
Almacenar en un arreglo real arregloResultado de tamaño k, la diferencia de un número real realMinuendo y cada uno de los elementos de un arreglo real arregloSustraendo del mismo tamaño que arregloResultado (El subalgoritmo recibe arregloResultado, realMinuendo, arregloSustraendo y k. El subalgoritmo no devuelve.).
Almacenar en un arreglo real arregloResultado de tamaño k-1, la diferencia “respecto a un (1) elemento hacia atrás” de otro arreglo real arregloTieneDatos de tamaño k (El subalgoritmo recibe arregloResultado, arregloTieneDatos y k. El subalgoritmo no devuelve.). Es decir, para un arreglo con los valores 1.2, 3.4, 7.8 y -9.0 (en ese orden), el arreglo resultante con la diferencia “respecto a un (1) elemento hacia atrás” deberá tener los valores 2.2, 4.4 y -16.8 (en ese orden).
Almacenar en un arreglo real arregloResultado de tamaño k, el cociente término a término de los elementos de dos arreglos reales arregloDividendo y arregloDivisor, del mismo tamaño que arregloResultado. (El subalgoritmo recibe arregloResultado, arregloDividendo, arregloDivisor y k. El subalgoritmo no devuelve.).
Almacenar en un arreglo real arregloResultado de tamaño k, el cociente de cada uno de los elementos de un arreglo real arregloDividendo, del mismo tamaño que arregloResultado, con un número real realDivisor. (El subalgoritmo recibe arregloResultado, arregloDividendo, realDivisor y k. El subalgoritmo no devuelve.).
Almacenar en un arreglo real arregloResultado de tamaño k, el cociente de un número real realDividendo y cada uno de los elementos de un arreglo real arregloDivisor del mismo tamaño que arregloResultado (El subalgoritmo recibe arregloResultado, realDividendo, arregloDivisor y k. El subalgoritmo no devuelve.).
Devolver el valor booleano que corresponda, dependiendo de si son iguales, los dos objetos matemáticos vector asociados a dos arreglos reales arregloDatosVector1 y arregloDatosVector2, ambos de tamaño k (El subalgoritmo recibe arregloDatosVector1, arregloVector2 y k. El subalgoritmo devuelve un valor booleano boolResultado.). Es decir, un subalgoritmo que hace para variables de tipo arreglo, algo similar a lo que hace variable1 == variable2 para variable1 y variable2 de un tipo de dato elemental / primitivo.
Devolver el valor booleano que corresponda, dependiendo de si son diferentes, los dos objetos matemáticos vector asociados a dos arreglos reales arregloDatosVector1 y arregloDatosVector2, ambos de tamaño k (El subalgoritmo recibe arregloDatosVector1, arregloVector2 y k. El subalgoritmo devuelve un valor booleano boolResultado.). Es decir, un subalgoritmo que hace para variables de tipo arreglo, algo similar a lo que hace variable1 <> variable2 para variable1 y variable2 de un tipo de dato elemental / primitivo.
Devolver la norma euclidiana al cuadrado del objeto matemático vector asociado a un arreglo real arregloDatosVector de tamaño k (El subalgoritmo recibe arregloDatosVector y k. El subalgoritmo devuelve un número real realResultado.).
Devolver la distancia euclidiana al cuadrado entre los dos objetos matemáticos vector asociados a dos arreglos reales arregloDatosVector1 y arregloDatosVector2, ambos de tamaño k (El subalgoritmo recibe arregloDatosVector1, arregloVector2 y k. El subalgoritmo devuelve un número real realResultado.).

7.3.2 Parte B

Para los siguientes puntos:

Los subalgoritmos deben recibir todo arreglo como un parámetro por referencia / dirección.
Se debe poder trabajar y manipular los datos de lo que podría ser un arreglo multidimensional, sin ningún problema, mediante el uso de un arreglo unidimensional. Esto para mostrar que todo arreglo multidimensional internamente es una colección lineal de posiciones consecutivas de memoria (es decir, internamente es equivalente a un arreglo unidmensional).

Realice un adecuado análisis y diseño de un subalgoritmo cuya única tarea sea:

Almacenar en un arreglo (unidimensional) real arregloRecibeDatosMatriz de tamaño k = n*p, los elementos de un objeto matemático matriz de tamaño n \times m que el usuario ingrese por teclado (El subalgoritmo recibe arregloRecibeDatosMatriz, n y p. El subalgoritmo no devuelve.). Es decir, un subalgoritmo que almacena adecuadamente en un arreglo unidimensional, los datos de una matriz dada elemento a elemento por el usuario mediante el teclado (Ayuda: pida y almacene los datos de la matriz de manera consecutiva por columnas).
Imprimir por pantalla los valores almacenados en cada uno de los elementos de un arreglo (unidimensional) real arregloTieneDatosMatriz de tamaño k = n*p que tiene almacenados adecuadamente por columnas los datos de un objeto matemático matriz de tamaño n \times p (El subalgoritmo recibe arregloTieneDatosMatriz, n y p. El subalgoritmo no devuelve.). Es decir, un subalgoritmo que imprima adecuadamente el contenido de un arreglo unidimensional, que tiene almacenados los datos de una matriz, que por ejemplo se recibió usando el subalgoritmo del punto anterior.
Devolver el elemento de la posición i, j de los datos de un objeto matemático matriz de tamaño n \times p, que fue almacenado adecuadamente por columnas, en un arreglo (unidimensional) real arregloTieneDatosMatriz de tamaño k = n*p (El subalgoritmo recibe arregloTieneDatosMatriz, i, j, n y p. El subalgoritmo devuelve un número real realElemento.). Es decir, un subalgoritmo que devuelve un elemento de una matriz que está almacenada en un arreglo unidimensional.
Almacenar en un arreglo (unidimensional) real arregloMatrizResultado de tamaño k = n*p, los datos de la matriz resultado del producto término a término entre dos matrices almacenadas en los arreglos unidimensionales: arregloMatrizPrimerFactor y arregloMatrizSegundoFactor del mismo tamaño que arregloMatrizResultado (El subalgoritmo recibe arregloMatrizResultado, arregloMatrizFactor1, arregloMatrizFactor2, n y p. El subalgoritmo no devuelve.). ¿hay varias potenciales soluciones para el subalgoritmo solicitado? ¿entre ellas cuál sería la más eficiente? ¿es posible aprovechar el subalgoritmo que hace el producto término a término de los elementos de dos arreglos reales, solicitado en un ejercicio de la Parte A?
Almacenar en un arreglo (unidimensional) real arregloMatrizResultado de tamaño k = n*p, los datos de la matriz resultado del producto matricial entre dos matrices almacenadas en los arreglos unidimensionales: arregloMatriz1 de tamaño k1 = n*m y arregloMatriz2 de tamaño k2 = m*p (El subalgoritmo recibe arregloMatrizResultado, arregloMatrizFactor1, arregloMatrizFactor2, n, m y p. El subalgoritmo no devuelve.).

7.3.3 Parte C

¿Por qué los estadísticos deben saber acerca de la generación de valores pseudoaleatorios y los métodos Monte Carlo?

“Monte Carlo methods, or Monte Carlo experiments, are a broad class of computational algorithms that rely on repeated random sampling to obtain numerical results. The underlying concept is to use randomness to solve problems that might be deterministic in principle. They are often used in physical and mathematical problems and are most useful when it is difficult or impossible to use other approaches. Monte Carlo methods are mainly used in three problem classes: optimization, numerical integration, and generating draws from a probability distribution.”
Monte Carlo method - Wikipedia

Para los siguientes puntos:

Los subalgoritmos deben recibir todo arreglo como un parámetro por referencia / dirección.
Consultar:

Blanco Castañeda, Liliana. (2004). Probabilidad. Editorial UN.
Capítulo 8: Simulaciones básicas 8.1: Generación de números aleatorios
https://repositorio.unal.edu.co/bitstream/handle/unal/53471/9587014499.PDF?sequence=2

y

Press, W. H., William, H., Teukolsky, S. A., Saul, A., Vetterling, W. T., & Flannery, B. P. (2007). Numerical recipes 3rd edition: The art of scientific computing. Cambridge university press.
Chapter 7: Random Numbers
7.0: Introduction, 7.1: Uniform Deviates
http://numerical.recipes/book/book.html

Realice un adecuado análisis y diseño de un subalgoritmo cuya única tarea sea:

Almacenar en un arreglo entero arregloResultado de tamaño k, una secuencia de k valores pseudoaleatorios enteros, generados mediante el método denominado linear congruential generator (método que tiene una fórmula de la forma (multiplier * seed + summand) mod modulus). El subalgoritmo recibe arregloResultado, seed, multiplier, summand, modulus, k. El subalgoritmo no devuelve.
Almacenar en un arreglo real arregloResultado de tamaño k, una secuencia de k valores pseudoaleatorios enteros entre dos números enteros dados entero1 y entero2, añadiendo un paso más a la generación de valores enteros con el método: linear congruential generator (método que tiene una fórmula de la forma (multiplier * seed + summand) mod modulus). El subalgoritmo recibe arregloResultado, entero1, entero2, seed, multiplier, summand, modulus, k. El subalgoritmo no devuelve. Si ya tengo un arreglo con valores pseudoaleatorios enteros generados, ¿puedo transformar esos valores que ya tengo, para obtener un arreglo con valores pseudoaleatorios enteros entre dos números enteros dados entero1 y entero2?
Almacenar en un arreglo real arregloResultado de tamaño k, una secuencia de k valores pseudoaleatorios reales entre 0 y 1, añadiendo un paso más a la generación de valores enteros con el método: linear congruential generator (método que tiene una fórmula de la forma (multiplier * seed + summand) mod modulus). El subalgoritmo recibe arregloResultado, seed, multiplier, summand, modulus, k. El subalgoritmo no devuelve. Si ya tengo un arreglo con valores pseudoaleatorios enteros generados, ¿puedo transformar esos valores que ya tengo, para obtener un arreglo con valores pseudoaleatorios reales entre 0 y 1?
Almacenar en un arreglo real arregloResultado de tamaño k, una secuencia de k valores pseudoaleatorios reales entre dos números reales dados real1 y real2, añadiendo un par de pasos más a la generación de valores enteros con el método: linear congruential generator (método que tiene una fórmula de la forma (multiplier * seed + summand) mod modulus). El subalgoritmo recibe arregloResultado, real1, real2, seed, multiplier, summand, modulus, k. El subalgoritmo no devuelve. ¿Si ya tengo un arreglo con valores pseudoaleatorios enteros generados, ¿puedo transformar esos valores que ya tengo, para obtener un arreglo con valores pseudoaleatorios enteros entre reales dados real1 y real2?