Programación en Pascal
-
Upload
nestorsocialista -
Category
Documents
-
view
27 -
download
0
description
Transcript of Programación en Pascal
Programación en PascalArrays< Programación en Pascal
Los arrays son cadenas o listas de algo. Normalmente siempre serán del mismo tipo.
Hasta ahora, hemos visto un tipo de datos que es una cadena: los strings. Son cadenas de caracteres.
Los arrays son prácticamente imprescindibles en casi cualquier tipo de programa. De una forma u otra, todo programa necesita almacenar en memoria grandes cantidades de datos. Por ejemplo, un editor de texto almacena caracteres; un programa de música datos de samples, un programa de conversión almacena datos del dato que va a convertir, un programa de video frames, un juego almacena sus características y escenas, y así con la práctica mayoría de los programas.
Declaración de un array[editar]
La organización "array" es, probablemente, la estructura de datos más conocida debido a que en muchos lenguajes es la única disponible explícitamente.
Un "array" es una estructura homogénea que está constituida por componentes del mismo tipo, llamado tipo base.
También se denomina estructura de acceso aleatorio, o acceso directo, porque todos sus componentes pueden seleccionarse arbitrariamente y son igualmente accesibles. Para designar a un componente aislado, el nombre de la estructura se amplía con el llamado índice de selección del componente. El índice debe ser un valor del tipo definido como tipo índice del array.
La definición de un tipo "array" T especifica un tipo base To y un
tipo índice I.
TYPE T = ARRAY [ I ] OF To
Ejemplos:
TYPE vector = ARRAY [1..3] OF REAL
TYPE linea = ARRAY [1..80] OF CHAR
TYPE nombre = ARRAY [1..32] OF CHAR
Los índices de un "array" deben ser de tipo ordinal. No suele ser posible utilizar el tipo INTEGER porque se excedería el espacio de memoria accesible. Para usar valores enteros como índices, hay que indicar un subrango de enteros.
Un valor de tipo "array" se puede designar por un constructor donde se indica el nombre del tipo y valores constantes de los componentes separados por comas y encerrados entre paréntesis.
Ejemplo: vector (2.57, 3.14, -8.16)
Para especificar un mismo valor a componentes consecutivos, se puede usar un factor de repetición de la forma "n of valor"; donde "n" indica el número de componentes que recibirán el mismo valor, y debe ser una expresión constante de tipo INTEGER. El "valor" puede ser una constante u otro constructor del mismo tipo que el componente.
Ejemplos: vector (3 OF 1.0) es equivalente a vector
(1.0,1.0,1.0)
vector (7.2, 2 OF 3.0)
Para seleccionar un componente individual de un "array" se usa un selector que consiste en escribir el nombre de la variable de tipo "array" seguido por el nombre correspondiente al componente, escrito entre corchetes.
Ejemplo: si v := vector (2.57, 3.14, -8.16)
entonces v [1] es igual a 2.57.
Los componentes de un "array" se pueden someter a todas las operaciones permitidas para su tipo. La única operación definida para el "array" como tal, es la asignación ( := ).
La forma habitual de operar con "arrays" es actualizar componentes aislados.
El hecho de que los índices tengan que ser de un tipo de datos definido tiene una consecuencia importante: los índices pueden calcularse, es decir, puede ponerse una expresión en lugar de una constante. La expresión debe evaluarse y su resultado determina el componente seleccionado. Esta generalización proporciona una herramienta de programación potente pero, al mismo tiempo, da ocasión a uno de los errores de programación más frecuentes: el valor resultante puede estar fuera del intervalo especificado como campo de variación de los índices. Se supone que en tales casos, la implementación en un equipo concreto ha previsto la emisión de mensajes de error.
Los valores organizados en forma de "array" se suelen manejar utilizando índices variables y sentencias repetitivas que permiten construir algoritmos para realizar tratamientos sistemáticos.
Los índices son de tipo escalar, es decir, un tipo no estructurado en el que está definida una relación de orden. Si el tipo base también está ordenado, entonces queda establecida una relación de orden para ese tipo "array".
La relación de orden entre dos "arrays" está determinada por los dos componentes desiguales, correspondientes, con menor índice.
Texto en cursiva=Declaración de un array= La o'rganización'''--148.213.14.220 19:51 14 may 2014 (UTC)Texto en cursiva--148.213.14.220 19:51 14 may 2014 (UTC)--148.213.14.220 19:51 14 may 2014 (UTC)áĎġĮĝ "array" es, probablemente, la estructura de datos más conocida debido a que en muchos lenguajes es la única disponible explícitamente.
Un "array" es una estructura homogénea que está constituida por componentes del mismo tipo, llamado tipo base.
También se denomina estructura de acceso aleatorio, o acceso directo, porque todos sus componentes pueden seleccionarse arbitrariamente y son igualmente accesibles. Para designar a un componente aislado, el nombre de la estructura se amplía con el llamado índice de selección del componente. El índice debe ser un valor del tipo definido como tipo índice del array.
La definición de un tipo "array" T especifica un tipo base To y un
tipo índice I.
TYPE T = ARRAY [ I ] OF To
Ejemplos:
TYPE vector = ARRAY [1..3] OF REAL
TYPE linea = ARRAY [1..80] OF CHAR
TYPE nombre = ARRAY [1..32] OF CHAR
Los índices de un "array" deben ser de tipo ordinal. No suele ser posible utilizar el tipo INTEGER porque se excedería el espacio de memoria accesible. Para usar valores enteros como índices, hay que indicar un subrango de enteros.
Un valor de tipo "array" se puede designar por un constructor donde se indica el nombre del tipo y valores constantes de los componentes separados por comas y encerrados entre paréntesis.
Ejemplo: vector (2.57, 3.14, -8.16)
Para especificar un mismo valor a componentes consecutivos, se puede usar un factor de repetición de la forma "n of valor"; donde "n" indica el número de componentes que recibirán el mismo valor, y debe ser una expresión constante de tipo INTEGER. El "valor" puede ser una constante u otro constructor del mismo tipo que el componente.
Ejemplos: vector (3 OF 1.0) es equivalente a vector
(1.0,1.0,1.0)
vector (7.2, 2 OF 3.0)
Para seleccionar un componente individual de un "array" se usa un selector que consiste en escribir el nombre de la variable de tipo "array" seguido por el nombre correspondiente al componente, escrito entre corchetes.
Ejemplo: si v := vector (2.57, 3.14, -8.16)
entonces v [1] es igual a 2.57.
Los componentes de un "array" se pueden someter a todas las operaciones permitidas para su tipo. La única operación definida para el "array" como tal, es la asignación ( := ).
La forma habitual de operar con "arrays" es actualizar componentes aislados.
El hecho de que los índices tengan que ser de un tipo de datos definido tiene una consecuencia importante: los índices pueden calcularse, es decir, puede ponerse una expresión en lugar de una constante. La expresión debe evaluarse y su resultado determina el componente seleccionado. Esta generalización proporciona una herramienta de programación potente pero, al mismo tiempo, da ocasión a uno de los errores de programación más frecuentes: el valor resultante puede estar fuera del intervalo especificado como campo de
variación de los índices. Se supone que en tales casos, la implementación en un equipo concreto ha previsto la emisión de mensajes de error.
Los valores organizados en forma de "array" se suelen manejar utilizando índices variables y sentencias repetitivas que permiten construir algoritmos para realizar tratamientos sistemáticos.
Los índices son de tipo escalar, es decir, un tipo no estructurado en el que está definida una relación de orden. Si el tipo base también está ordenado, entonces queda establecida una relación de orden para ese tipo "array".
4. Arrays, cadenas, registros y conjuntos.
4.1. Arrays
4.1.1. Arrays de una dimensión
Un array (que algunos autores traducen como "arreglo") es una estructura que se utiliza para guardar una serie de elementos, todos los cuales son del mismo tipo (por ejemplo, 20 números reales).
A la hora de definir un array, deberemos indicar el índice inferior y superior (desde dónde y hasta dónde queremos contar), separados por dos puntos (..), así como el tipo de datos de esos elementos individuales. Por ejemplo, para guardar hasta 200 números enteros, usaríamos:
lista: array [1..200] of integer
Se suele emplear para definir vectores o matrices. Para mostrar en pantalla el segundo elemento de esa lista de números (o de ese vector) se usaría
write( lista[2] );
Un ejemplo completo, que guarde varios datos en un array y luego muestre uno de ellos podría ser:
(* ARRAY00.PAS, Contacto con arrays *)
(* Datos en posiciones prefijadas *)(* Parte de CUPAS5, por Nacho Cabanes *) Program Array00; var datos: array[1..4] of integer; begin datos[1] := 20; datos[2] := 12; datos[3] := 7; datos[4] := 35; writeLn('El segundo dato es ',dato[2]);end.
Es habitual recorrer todo un array usando un bucle "for", de modo que podamos pedir y mostrar los datos de forma repetitiva. Por ejemplo, podríamos pedir al usuario 5 números y luego mostrarlos en orden inverso, así:
(* ARRAY01.PAS, Ejemplo de uso de arrays (01): *)(* Pedir datos y mostrarlos al revés *)(* Parte de CUPAS5, por Nacho Cabanes *) Program Array01; var datos: array[1..5] of integer; i: integer; begin for i := 1 to 5 do
begin write('Deme el dato ',i,': '); readLn(datos[i]); end; write('Los datos al reves son: '); for i := 5 downto 1 do write(datos[i], ' '); writeLn;end.
Ejercicio propuesto 4.1.1.1: Crea un programa que reserve espacio para un Array de 3 números enteros, que asigne a sus elementos los valores 3, 5 y 8, y que después muestre en pantalla la suma de los valores de sus 3 elementos.
Ejercicio propuesto 4.1.1.2: Crea un programa que pida al usuario cinco números enteros, los guarde en un array y luego muestre el primero y el último.
Ejercicio propuesto 4.1.1.3: Crea un programa que pida al usuario diez números enteros, los guarde en un array y luego muestre los que se encuentran en posiciones impares (1, 3, 5, 7, 9).
Ejercicio propuesto 4.1.1.4: Crea un programa que pida al usuario diez números enteros, los guarde en un array y luego muestre los que son impares.
Ejercicio propuesto 4.1.1.5: Crea un programa que sume dos vectores, cuyos componentes indicará el usuario. Por ejemplo, la suma de (1,2,3) y (7,11,-1) sería (8,13,2).
Ejercicio propuesto 4.1.1.6: Crea un programa que halle el producto escalar dos vectores, cuyos componentes indicará el usuario.
4.1.2. Buscar en un array
Buscar en un array "tiene truco": si el elemento que estamos mirando contiene el dato que buscábamos, sabremos con seguridad que el dato existía, pero, por el contrario, no podremos afirmar que un dato no existe hasta que no hayamos comprobado todos los elementos. Por eso, lo habitual es usar un "boolean" para memorizar si lo hemos encontrado o no:
(* ARRAYB.PAS, Buscar en un array *)
(* Parte de CUPAS5, por Nacho Cabanes *) program ArrayB; var datos: array[1..5] of integer; i: integer; encontrado: boolean; begin for i := 1 to 5 do begin write('Deme el dato ',i,': '); readLn(datos[i]); end; encontrado := false; write('Buscando un 10... '); for i := 1 to 5 do if datos[i] = 10 then encontrado := true; if encontrado then writeLn('Encontrado!'); else writeLn('No encontrado.');end.
Ejercicio propuesto 4.1.2.1: Crea un programa que pida al usuario diez números enteros, los guarde en un array y luego le pida un número más y diga si era parte de los 10 datos originales o no.
Ejercicio propuesto 4.1.2.2: Crea un programa que pida al usuario diez números enteros, los guarde en un array y luego le vaya preguntando qué número quiere buscar de forma repetitiva, y diga si era parte de los 10 datos originales o no. Terminará cuando el número introducido sea 9999.
Ejercicio propuesto 4.1.2.3: Crea un programa que pida al usuario dos listas de 5 números enteros, usando dos arrays distintos, y luego muestre en pantalla los números que aparecen en ambas listas.
4.1.3. Máximo y mínimo de un array
No es difícil encontrar el valor máximo o el mínimo de un array. Debemos empezar con un máximo (o mínimo) provisional, que puede ser el primer valor del array. A partir de ese punto, vamos comparando uno a uno con todos los demás datos. Si el dato actual es mayor que el máximo (o menor que el mínimo), pasará a ser nuestro nuevo máximo (o mínimo), que deberemos memorizar.
(* ARRAYMAX.PAS, Maximo valor en un array *)(* Parte de CUPAS5, por Nacho Cabanes *) program ArrayMax; var datos: array[1..6] of integer; i: integer; maximo: integer; begin datos[1] := 20; datos[2] := 12; datos[3] := 7; datos[4] := 35; datos[5] := 48; datos[6] := 14; maximo := datos[1]; for i := 2 to 6 do if datos[i] > maximo then maximo := datos[i]; writeLn('El maximo es: ', maximo);end.
(* Resultado:El maximo es: 48*)
Ejercicio propuesto 4.1.3.1: Crea un programa que pida al usuario diez números reales, los guarde en un array y luego busque y muestre el menor de esos números.
Ejercicio propuesto 4.1.3.2: Crea una versión alternativa, que pida al usuario diez números reales y muestre el menor de todos ellos, sin usar arrays.
Ejercicio propuesto 4.1.3.3: Crea un programa que pida al usuario 10 nombres de personas y sus 10 estaturas. Estos datos se guardarán en dos arrays distintos. A continuación deberás mostrar el nombre de la persona más alta.
4.1.4. Arrays de dos o más dimensiones
Cuando se trata de una matriz de 2, 3 o más dimensiones, podemos indicar los rangos de valores aceptables, separados por comas. Por ejemplo, una matriz de bidimensional de tamaño 3x2 que debiera contener números reales sería:
matriz1: array [1..3, 1..2] of real
y para ver el elemento (3,1) de la matriz haríamos:
writeLn( matriz1[3,1] );
Un ejemplo más completo, que pidiera 2x3 datos y mostrar uno de ellos sería:
(* ARRAYBI.PAS, Array bidimensional *)(* Parte de CUPAS5, por Nacho Cabanes *) program ArrayBi; var datos: array[1..2, 1..3] of integer;
fila,columna: integer; begin for fila := 1 to 2 do for columna := 1 to 3 do begin write('Deme el dato de la fila ',fila, ' y columna ', columna, ': '); readLn(datos[fila, columna]); end; writeLn('El dato de la fila 1 y columna 2 es ', datos[1,2]);end. (* Ejemplo de ejecucion:Deme el dato de la fila 1 y columna 1: 1Deme el dato de la fila 1 y columna 2: 20Deme el dato de la fila 1 y columna 3: 3Deme el dato de la fila 2 y columna 1: 54Deme el dato de la fila 2 y columna 2: 15Deme el dato de la fila 2 y columna 3: 9El dato de la fila 1 y columna 2 es 20*)
Ejercicio propuesto 4.1.4.1: Crea un programa que pida al usuario dos bloques de 3 números enteros y luego muestre en pantalla las dos filas de tres datos cada una.
Ejercicio propuesto 4.1.4.2: Crea un programa que pida al usuario dos bloques de 5 números enteros y luego diga la suma de ambos bloques.
Ejercicio propuesto 4.1.4.3: Crea un programa que sume dos matrices de tamaño 3x3.
Ejercicio propuesto 4.1.4.4: Si has estudiado álgebra matricial, crea un programa que multiplique dos matrices de tamaño 3x3.
Ejercicio propuesto 4.1.4.5: Si has estudiado álgebra matricial, crea un programa que calcule el determinante de una matriz de tamaño 3x3.
Ejercicio propuesto 4.1.4.6: Si has estudiado álgebra matricial, crea un programa que calcule el determinante de una matriz de tamaño 4x4.
Ejercicio propuesto 4.1.4.7: Si has estudiado álgebra matricial, crea un programa de resolución de sistemas de ecuaciones de 3 ecuaciones con 3 incógnitas usando el método de Gauss.
4.1.5. Sobredimensionar un array
Cuando no sabemos cuántos datos vamos a tener que guardar, una primera solución es sobredimensionar: crear un array más grande de lo que esperemos necesitar y llevar un contador de cuántos datos ya hemos almacenado:
(* ARRAYSD.PAS, Array sobredimensionado *)(* Parte de CUPAS5, por Nacho Cabanes *) program ArraySD; var datos: array[1..20] of integer; { Los datos en si } cantidad: integer; { Cantidad de datos guardados } i: integer; { Para bucles } begin { Pedimos 200 datos o hasta introducir el valor 999 } cantidad := 0; repeat if cantidad >= 200 then writeLn('No caben mas datos!') else begin cantidad := cantidad+1; write('Deme el dato ',cantidad,' (999 para salir): '); readLn(datos[cantidad]);
end; until datos[cantidad]=999; { El ultimo dato no hay que guardarlo } cantidad := cantidad-1; { Al final, muestro todos } writeLn('Cantidad de datos: ', cantidad); writeLn('Los datos al reves son: '); for i := cantidad downto 1 do write(datos[i], ' '); writeLn;end. (* Ejemplo de ejecucion:Deme el dato 1 (999 para salir): 23Deme el dato 2 (999 para salir): 45Deme el dato 3 (999 para salir): 7Deme el dato 4 (999 para salir): 16Deme el dato 5 (999 para salir): 999Cantidad de datos: 4Los datos al reves son: 16 7 45 23 *)
Ejercicio propuesto 4.1.5.1: Crea un programa que pida al usuario tantos números reales como desee, para después mostrar todos los datos con dos cifras decimales.
Ejercicio propuesto 4.1.5.2: Crea un programa que pida al usuario tantos números reales como desee, para después mostrar su media aritmética y los datos que están por encima de esa media.
Ejercicio propuesto 4.1.5.3: Crea un programa que pida al usuario tantos números reales como desee, para después mostrar su media aritmética, sin utilizar arrays.
4.1.6. Borrar e insertar en un array
En un array sobredimensionado, nos puede interesar borrar o insertar datos. Para borrar, deberemos desplazar hacia "la izquierda" (hacia el principio del array) los datos que hay desde esa posición, y luego disminuir el contador de datos:
(* ARRAYBor.PAS, Borrar en un array sobredimensionado *)(* Parte de CUPAS5, por Nacho Cabanes *) Program ArrayBor; var datos: array[1..10] of integer; cantidad: integer; i: integer; posicionBorrar: integer; begin datos[1] := 20; datos[2] := 12; datos[3] := 7; datos[4] := 35; datos[5] := 8; datos[6] := 49; cantidad := 6; { Primero mostramos los datos } writeLn('Los datos iniciales son: '); for i := 1 to cantidad do write(datos[i], ' '); writeLn; { Ahora borramos el tercero } posicionBorrar := 3; for i := posicionBorrar to cantidad-1 do datos[i] := datos[i+1]; cantidad := cantidad-1;
{ Y mostramos el resultado } writeLn('Los datos tras borrar el tercero son: '); for i := 1 to cantidad do write(datos[i], ' '); writeLn;end. (* Resultado:Los datos iniciales son: 20 12 7 35 8 49 Los datos tras borrar el tercero son: 20 12 35 8 49 *)
De forma similar, podríamos insertar un dato en una cierta posición, si primero desplazamos hacia "la derecha" (hacia el final del array) los datos que hay a partir de esa posición e incrementamos el contador que almacena la cantidad de datos.
Ejercicio propuesto 4.1.6.1: Crea una variante del programa que borra un elemento de un array. En esta ocasión, deberá insertar el valor "10" en la tercera posición y mostrar el resultado.
Ejercicio propuesto 4.1.6.2: Crea un programa que permita al usuario guardar tantos números enteros como desee (hasta un máximo de 1000). Deberá permitir añadir datos al final, insertar en cualquier posición, borrar cualquier posición o mostrar los datos que hay almacenados.
4.1.7. Ordenar los datos de un array
¿Y si necesitamos ordenar los datos de menor a mayor, o de mayor a menor, o (pronto) alfabéticamente? Hay muchas formas de hacerlo. Algunas son eficientes pero difíciles de entender, otras son sencillas pero lentas, otras son intermedias entre ambas.
Uno de los algoritmos de ordenación más simples y conocidos es el de "burbuja", en el que se va comparando cada dato con todos los anteriores, de modo que el más pequeño (el más "ligero", como si se tratara de una burbuja) vaya desplazándose hacia el final del array (como si "subiera hacia la superficie"). Tras cada pasada, el número más pequeño quedará colocado en su sitio:
(* ARRAYORD.PAS, Ordenar un array (burbuja) *)(* Parte de CUPAS5, por Nacho Cabanes *) Program ArrayOrd; var datos: array[1..6] of integer; i,j: integer; temporal: integer; begin datos[1] := 20; datos[2] := 12; datos[3] := 7; datos[4] := 35; datos[5] := 49; datos[6] := 8; { Primero mostramos los datos } writeLn('Los datos iniciales son: '); for i := 1 to 6 do write(datos[i], ' '); writeLn; { Ahora ordenamos mediante burbuja } for i := 6 downto 2 do for j := 0 to i - 1 do if datos[j] > datos[j + 1] then begin temporal := datos[j]; datos[j] := datos[j + 1]; datos[j + 1] := temporal; end;
{ Y mostramos el resultado } writeLn('Los datos tras ordenar son: '); for i := 1 to 6 do write(datos[i], ' '); writeLn;end. (* Resultado:Los datos iniciales son: 20 12 7 35 49 8 Los datos tras ordenar son: 7 8 12 20 35 49 *)
Ejercicio propuesto 4.1.7.1: Modifica e
VECTORES Y MATRICES
J U E V E S , 1 9 D E J U L I O D E 2 0 0 7
Vectores y Matrices
Estructura de datos (arreglos)
Vectores y Matrices
Hasta aquí se han visto distintos tipos de estructuras de control. A partir de este
punto se verá la aplicación de las mismas a distintos tipos de problemas.
Estructura de datos:
Una estructura de datos es una colección de datos que pueden ser caracterizados por
su organi-zación y las operaciones que se definen en ella.
Dentro de ellas encontramos distintos tipos, los tipos de datos más frecuentes en los
diferentes lenguajes son:
Tipos de datos
entero (integer)
estándar real (real)
carácter (char)
simples lógico (boolean)
definidos por el programador subrango (subrange)
(no estándar) enumerativo (enumerated)
arrays (vectores/matrices)
registros
simples o estáticos ficheros
conjuntos
estructurados cadenas (string)
listas (pilas/colas)
compuestos o dinámicos listas enlazadas
árboles
grafos
Las estructuras estáticas son aquellas en las que el tamaño de memoria ocupado se
define an-tes de que el programa se ejecute y no puede modificarse durante la
ejecución
Las estructuras dinámicas son aquellas en las que no se debe definir previamente el
tamaño de memoria
Los datos simples tienen en común que cada variable representa un elemento, en los
estructu-rados un identificador puede representar múltiples datos individuales,
pudiendo cada uno de estos ser referenciados independientemente.
ARRAY UNIDIMENSIONALES: VECTORES
ARRAY (ARREGLO): Es un conjunto finito y ordenado de elementos homogéneos.
• Ordenado : cada elemento del arreglo puede ser identificado
• Homogéneo : son del mismo tipo de dato
El tipo más simple de arreglo es el unidimensional o vector (matriz de una dimensión).
Por ejemplo podría ser un vector denominado NOTAS
NOTAS[1] NOTAS[2] NOTAS[k] NOTAS[j]
5 8 .......... 7 ...... 3
Los subíndices 1, 2, k, n, indican la posición del elemento, en Pascal van entre
corchetes. El pri-mer elemento es el 5, el segundo es el 8, el elemento k es 7 y el
enésimo es 3.
Un array puede ser declarado de dos formas distintas que son:
Declaraciones Tipo Array
En las declaraciones del tipo array usaremos los siguientes pasos.:
1. La estructura del arreglo se describe en Type.
2. Se le asigna ese tipo a una o más variables.
Type
XX = array [1..3000] of real;
Var:
Alfa : XX;
array y of son obligatorias
[1...3000] indica los valores que toman los índices del vector, son del tipo subrango.
real identifica que tipo de elementos almacena el vector.
Variables Tipo Array
En las declaraciones de variable tipo array se hará de la siguiente forma.:
1. En la declaración se describe la variable.
Var:
Alfa : array [1..3000] of real;;
Los elementos cumplen la misma función que en el caso anterior.
Dentro de los distintos tipos que un array puede almacenar en sus posiciones, puede
ser un tipo Array como el del siguiente tipo:
Type
Linea = array [1..40] of char;
Hoja = array [1..30] of Linea;
Libro = array [1..30] of Linea;
Las operaciones que se pueden hacer con un vector son:
• asignación
• lectura/escritura
• recorrido (acceso secuencial)
• actualizar (añadir, borrar, insertar)
• ordenación
• búsqueda
Asignación: Es darle un valor a un elemento de un vector
Pseudocódigo en español Código se programa
A[3] 5 A[3] := 5;
Para la asignación como para otro procesos se debe recurrir a estructuras repetitivas
(desde, mientras o repetir).
Ejemplo:
A cada uno de los 55 elementos del vector CARGA se le debe asignar el valor 0
Algoritmo de asigna
Pseudocódigo en español
desde I = 1 hasta 55 hacer
CARGA[I] 0
fin desde Código se programa
for I = 1 to 55 do
CARGA[I] := 0;
Su estructugrama tiene la siguiente forma
desde I = 1 hasta 55
CARGA[I] 0
Pseudocódigo del programa
Diagrama N-S
nombre vector1(program); nombre selección1
declaraciones (uses)
Crt, Dos; declaraciones
Crt, Dos
constantes(const)
A = 1; Constantes
A, B
B = 55; tipos
matriz [55]
tipo (type)
matriz = array [1..55] de enteros Variables
Y
CARGA
variables (var)
I entero
CARGA matriz funciones y procedimientos
funciones(function)(NO hay); comienzo (programa)
procedimientos (procedure); limpieza
inicio (begin); asigna
limpieza(limpia la pantalla); salida
asigna (hace ciclo y asigna); fin (programa)
salida
fin(end.)
Como se puede ver tenemos la definición del vector en tipo o type.
El código del procedimiento es:
procedure asigna; {* comienzo de la asignación *}
begin
for I := A to B do {* se define el ciclo de 1 a 55*}
CARGA[I] := 0; {* asigna los valores *}
end; {* fin del ciclo *}
Quedándonos el programa de la siguiente manera.
Program Vector_1;
{* Este es el primer programa con vectores *}
uses
Crt, dos; {declaraciones}
const {* constantes *}
A = 1;
B = 55;
type
matriz = array [1..55] of integer;
var
I: integer; {* controla el ciclo *}
CARGA: matriz;
procedure limpieza; {* comienzo de limpieza de la pantalla *}
begin
ClrScr;
end; {* fin de limpieza de la pantalla *}
procedure asigna; {* comienzo de la asignación *}
begin
for I := A to B do {* se define el ciclo de 1 a 55 *}
CARGA[I] := 0; {* asigna la valores *}
end; {* fin de la asignación *}
procedure salida; {* comienzo del procedimiento salida *}
{* solo sirve para ver resultados *}
Var
H :char;
begin
writeln ( 'Presione cualquier tecla ');
readln (H); {* esta instrucción y la anterior son para dar tiempo para *}
{* ver resultados *}
end; {* fin del procedimiento salida *}
begin
limpieza;
asigna;
salida;
end.
Lectura/escritura:
Es una operación de entrada salida sobre un vector. Manejado por es-tructuras
repetitivas.
Ejemplo:
Ingresar por teclado cada uno de los 5 elementos de un vector de nom-bre vec. Y
luego leerlos y presentarlos por pantalla en orden inverso al que entraron (de 5 a 1)
Algoritmo de escribe
Pseudocódigo en español
desde I = 1 hasta 5 hacer
comienzo
imprimo mensaje
leo y escribo en vec[I]
fin desde Código se programa
for I = 1 to 5 do
begin
write (‘ ‘);
read (vec[I] );
end;
Su estructugrama tiene la siguiente forma
desde I = 1 hasta 5
imprimo mensaje
leo vec[I]
El código del procedimiento es:
procedure escribir; {* escribe en el vector *}
begin
for I := A to B do {* se define el ciclo de 1 a 5 *}
begin
write ('Ingrese vec(',I:1,') : ');
readln(vec[I]); {* escribe en el vector *}
end;
end; {* fin de escritura *}
Algoritmo de lee
Pseudocódigo en español
desde I = 1 hasta 5 hacer
leo vec[I]
fin desde Código se programa
for I = 1 to 5 do
read (vec[I] );
Su estructugrama tiene la siguiente forma
desde I = 1 hasta 5
imprimo vec[I]
El código del procedimiento es:
procedure leer; {* lee el vector *}
begin
for I := B downto A do {* se define el ciclo de 5 a 1 *}
writeln ('vec(',I:1,') = ',vec[I]:2);
{* lee el vector y lo saca por pantalla *}
end; {* fin de lectura *}
Pseudocódigo del programa Diagrama N-S
Nombre vector2(program); nombre selección1
Declaraciones (uses)
Crt, Dos; declaraciones
Crt, Dos
Constantes(const)
A = 1; Constantes
A, B
B = 5;
tipo (type) tipos
matriz [5]
Matriz = array [1..5] de enteros
variables (var)
I entero Variables
I
vec
vec matriz funciones y procedimientos
Funciones(function)(NO hay); comienzo (programa)
Procedimientos (procedure); limpieza
inicio (begin); escribe
limpieza(limpia la pantalla); lee
escribir (escribe en el vector) salida
leer (lee del vector y saca por pantalla) fin (programa)
salida
fin(end.)
Program Vector_2
{* Este es el segundo programa con vectores *}
uses
crt, dos; {declaraciones}
const {* constantes *}
A = 1;
B = 5;
type
matriz = array [1..5] of integer;
var
I: integer; {* controla el ciclo *}
vec: matriz;
procedure limpieza; {* comienzo de limpieza de la pantalla *}
begin
ClrScr;
end; {* fin de limpieza de la pantalla *}
procedure escribir; {* escribe en el vector *}
begin
for I := A to B do {* se define el ciclo de 1 a 5 *}
begin
write ('Ingrese vec(',I:1,') : ');
readln(vec[I]); {* escribe en el vector *}
end;
end; {* fin de escritura *}
procedure leer; {* lee el vector *}
begin
for I := B downto A do {* se define el ciclo de 5 a 1 *}
writeln ('vec(',I:1,') = ',vec[I]:2);
{* lee el vector y lo saca por pantalla *}
end; {* fin de lectura *}
procedure salida; {* comienzo del procedimiento salida *}
{* solo sirve para ver resultados *}
Var
H :char;
begin
writeln ( 'Presione cualquier tecla ');
readln (H); {* esta instrucción y la anterior son para dar tiempo para *}
{* ver resultados *}
end; {* fin del procedimiento salida *}
begin
limpieza;
escribir;
leer;
salida;
end.
Recorrer: Esta operación se realiza cuando uno lee el vector, y se aplica tanto cuando
se busca un elemento de un vector o cuando se desea listar el mismo, como lo vimos
en el ejemplo anterior.
Actualizar
Añadir: Se denomina así a la operación de agregar un nuevo, elemento al final del
vector. la única condición necesaria para esta operación consiste en la comprobación
de espacio libre en memo-ria.
Ejemplo:
Dado el vector U de 7 elementos añadir un elemento más al vector
Algoritmo de añade
Pseudocódigo en español
I 0
repetir
I I +1
hasta que U[I] = 0 o i > k
si i es menor o igual a k
entonces
leo nuevo U[I]
sino
imprimo “No más lugar”
fin_si Código se programa
I := 0;
repeat
I := I + 1;
until U[I] = 0 or i >q
if I <= k then
read (U[I] )
else
writeln(“No mas lugar”)
Su estructugrama tiene la siguiente forma
I I +1
U[I] = 0 o i > k
I es menor o igual a k
leo nuevo U[I] imprimo “No más lugar
El código del procedimiento es:
procedure agrega; {* agrega un elemento al vector *}
begin
I:=0;
repeat
I := I + 1;
until (U[I]=0) or (I> 7);
{* Se repite hasta que se encuentre una bandera o se termine el vector *}
if I<= 7 then
begin
writeln ('Ingrese un nuevo elemento al vector');
read ( U[I])
end
else
writeln ('No hay mas lugar en el vector');
end; {* fin de agrega *}
Borrar: Es eliminar un elemento de un vector se puede hacer de dos maneras una es
reempla-zar el elemento por el utilizado como señal. Puede servir pero no es
recomendado en proyectos pe-queños. Pero no así en grandes. El otro método consiste
en mover los elementos que se encuentran debajo de él una posición hacia arriba,
colocando una bandera en la última celda.
Ambos métodos tienen el paso de búsqueda en común utilizado en añadir, lo que
varían son los pasos posteriores al Si. (Solo representaremos estos pasos)
Ejemplo:
Dado el vector U de 7 elementos eliminar un elemento al vector
Método rudimentario
Algoritmo de elimina (rudimentario)
Pseudocódigo en español
Y 0
repetir
I I +1
hasta que U[I] = 0 o I > k
si I es menor o igual a k
entonces
U[I] 0
sino
imprimo “No existe el elemento”
fin_si Código se programa
I := 0;
repeat
I := I + 1;
until U[I] = 0 or I >q
if I <= k then
U[I] := 0;
else
writeln(“No existe el elemento”)
Su estructugrama tiene la siguiente forma
I I +1
U[I] = 0 o I > k
I es menor o igual a k
U[I] 0 imprimo “No existe el elemento”
Método Optimo
Algoritmo de elimina (optimo)
Pseudocódigo en español
I 0
Lee Aux
repetir
I I +1
hasta que U[i] = Aux o I > k
si i es menor o igual a k
entonces
repetir
U[I] U[I + 1]
I I +1
hasta que U[i] = 0 o I > k
sino
imprimo “No existe el elemento”
fin_si Código se programa
I := 0;
Readln(Aux);
repeat
I := I + 1;
until U[i] = Aux or I >q
if I <= k then
repeat
U[I] := U[I+1];
I := I + 1;
until U[I] = 0 or I >q ;
else
writeln(“No existe el elemento”)
Su estructugrama tiene la siguiente forma
I 0
Lee Aux
I I +1
U[I] = Aux o I > k
I es menor o igual a k
U[I] U[I+1]
I I +1 imprimo “No existe el elemento”
U[I] = 0 o I > k
Insertar:
Se debe trabajar sobre un vector ordenado. Consiste en introducir un nuevo elemento
al vector sin que este pierda el orden. Para ello se debe comprobar que haya lugar
libre en el vector, luego de lo cual se deberá desplazar hacia bajo los elementos
necesarios como para generar un espacio libre en la posición adecuada sin que se
pierda el orden.
Algoritmo de inserta (Ordenado creciente)
Pseudocódigo en español
I 0
Lee Aux
repetir
I I +1
hasta que U[i] = 0 o I > B
si i es menor o igual a B
entonces
I I -1
mientras U[i] > Aux
U[I+1] U[I]
I I -1
fin mientras
U[I+1] Aux
sino
imprimo “No hay lugar”
fin_si Código se programa
I := 0;
Read(Aux);
repeat
I := I + 1;
until U[i] = 0 or I >B
if I <= B then
begin
I := I - 1;
while U[I] > Aux
begin
U[I+1] := U[I];
I := I - 1;
end;
U[I+1] = Aux;
end
else
writeln(“No hay lugar”)
Su estructugrama tiene la siguiente forma
I 0
Lee Aux
I I +1
U[I] = Aux o I > k
I es menor o igual a k
I I -1
U[I] > Aux
U[I+1] U[I] imprimo “No hay lugar”
I I -1
U[I+1] Aux
Ordenación:
La ordenación o clasificación es, el proceso de clasificar datos en algún orden o
secuencia espe-cífica como creciente o decreciente. Existen varios métodos de ellos
elegiremos el de intercambio (de-cantación).
Algoritmo de ordena (Ordenado creciente)
Pseudocódigo en español
I 0
repetir
I I +1
hasta que U[i] = 0 o I > B
P I - 1
desde I 1 hasta P -1 hacer
desde J 1 hasta P - I hacer
si U[J] > U[J +1]
entonces (intercambiar)
Aux U[J]
U[J] U[J +1]
U[J +1] Aux
fin si
fin desde
fin desde
Código se programa
I := 0;
repeat
I := I + 1;
until U[i] = 0 or I > B
P := I - 1;
for I = 1 to P-1 do
for J = 1 to P- I do
if U[J] > U[J +1] then
begin
Aux := U[J];
U[J] := U[J +1];
U[J +1] := Aux ;
end;
Su estructugrama tiene la siguiente forma
I 0
I I +1
U[I] = 0 o I > k
P I -1
I 1 hasta P -1
J 1 hasta P - I
U[J] > U[J +1]
Aux U[J]
U[J] U[J +1]
U[J +1] Aux
Búsqueda:
La búsqueda de un dato dentro de un array consiste en determinar si un elemento N
pertenece o no al conjunto de datos y posición que el ocupa en el conjunto.
Los distintos tipos de búsqueda se pueden clasificar en:
búsqueda secuencial
búsqueda binaria
búsqueda por transformación de claves (hash)
En este curso solo se verá el primer tipo, ya que las dos siguientes están fuera del
alcance del mismo.
Búsqueda Secuencial:
Compara cada elemento del vector con el valor deseado. Si se encuentra
es el método que ofrece menor eficiencia pero el más sencillo.
Esto se puede ver en el ejemplo anterior.
Ejemplo general
Hacer un programa que permita operar con un vector de siete posiciones, que opere
con núme-ros naturales. Pudiendo agregar, eliminar o insertar un valor, también se
podrá listar todos los valores que tiene el vector.
Usaremos como centinela el número 0 (cero) por lo cual lo primero que deberá hacer
el progra-ma deberá asignarle a todos los elementos del vector dicho valor .
El programa cuenta con tres llamados.
begin
limpieza; {* limpia la pantalla *}
asigna; {* asigna los 0 al vector *}
menu; {* llama al módulo menú *}
end.
Los módulos limpieza y asigna ya se han detallado. En cuanto a menu es un selector.
Algoritmo de menu
Pseudocódigo en español
repetir
repetir
llama a Limpieza
escribir Titulos
escribir Opciones
leer valor elegido (H)
hasta que H > 0 y H < 7
según sea H hacer
1: llama a Agrega
2: llama a Lista
3: llama a Borra
4: llama a Ordena
5: Inserta
sino limpia pantalla
fin según
mientras H > 6
Código se programa
repeat
repeat
limpieza;
writeln (' M E N U ');
writeln ( ' 1. Ingresar un valor al vector ');
writeln;
write ( ' Elija una opción ');
readln (H); {* lee la opción *}
until (H > 0) and (H < 7);
case H of
1 : Agrega;
2 : Lista;
3 : Borra;
4 : Ordena;
5 : Inserta;
else clrscr;
end;
until H = 6;
En el procedimiento borra, lo que realiza el algoritmo es desplazar cada uno de los
elementos posteriores al que queremos eliminar a una posición anterior a la que
teníamos. Este procedimiento cuenta con dos partes.
a) encuentra el elemento a borrar
b) desplaza los elementos posteriores a una posición anterior, el centinela nos sirve
pa-ra optimizar el proceso.
program vectores; {* Programa de subrutinas de vectores *}
uses
crt, dos; {*declaraciones*}
const {* constantes *}
NL = •#13#10; {* Nueva Línea Carrige Return, Line Feed*}
A = 1;
B = 7;
type
vector = array [1..7] of integer;
var
I: integer; {* controla el ciclo *}
U: vector;
procedure limpieza; {* comienzo de limpieza de la pantalla *}
begin
ClrScr;
end; {* fin de limpieza de la pantalla *}
procedure salida; {* comienzo del procedimiento salida *}
{* solo sirve para ver resultados *}
Var
H :char;
begin
writeln ( 'Presione cualquir tecla ');
readln (H); {* esta instrucci¢n y la anterior son para dar tiempo para *}
{* ver resultados *}
end; {* fin del procedimiento salida *}
procedure Lugar; {* determina cuantos lugares están ocupados del vector *}
begin
I:=0;
repeat
I := I + 1;
until (U[I]=0) or (I> 7);
{* Se repite hasta que se encuentre una bandera o se termine el vector *}
end; {* fin de lugar *}
procedure asigna; {* comienzo de la asignación *}
begin
for I := 1 to 7 do {* se define el ciclo de 1 a 7 *}
U[I] := 0; {* asigna *}
end; {* fin de la asignación *}
procedure Ordena; {* ordena el vector *}
var
J, P, Aux : integer;
begin
I := 0;
repeat
I := I + 1;
until (U[I]=0) or ( I>B ); {* Determina cuantos valores validos hay en el vector *}
P := I - 1;
for I := 1 to P - 1 do {* se define el ciclo hasta el anteúltimo valor cargado *}
for J := 1 to P - I do
if U[J] > U[J+1] then
begin {* Intercambia *}
Aux := U[J];
U[J] := U[J+1];
U[J+1] := Aux;
end
end; {* fin del ordenamiento *}
procedure lista; {* lee y lista el vector *}
begin
I := 1;
while (U[I] <> 0) and (I<= B ) do {* se lee hasta encontrar *}
begin {* un centinela o el final del vector *}
writeln ('U(',I:1,') = ',U[I]:3);
{* lee el vector y lo saca por pantalla *}
I := I + 1;
end;
Salida;
end; {* fin de lectura y listado *}
procedure Borra; {* borra un elemento del vector *}
var
J : integer;
H : char;
begin
I := 1;
write ('Ingrese el valor a borrar : ');
read (J);
while (U[I] <> 0) and (I<= B ) and (U[I] <> J) do {* se hace la búsqueda *}
I := I + 1;
if U[I] <> J then
begin {* No se encontró el valor *}
write (' Elemento no encontrado ');
readln(H);
end
else
begin
while U[I] <> 0 do {* Se borra el valor *}
begin
U[I] := U[I+1];
I := I + 1;
end;
write (' Elemento borrado ');
readln(H);
end;
end; {* fin de borrado *}
procedure agrega; {* agrega un elemento al vector *}
var
H:char;
begin
Lugar;
if I <= 7 then
repeat
write ('Ingrese un nuevo valor al vector : ');
readln ( U[I]);
I := I + 1;
until (U[I-1] = 0) or (I > B)
else
begin
write ('No hay mas lugar en el vector');
Read (H);
end
end; {* fin de agrega *}
procedure inserta; {* inserta un elemento al vector ordenado *}
var
H:char;
K, Aux : integer;
begin
Lugar;
if I <= B then
begin
K := I;
write ('Ordeno el vector ? (S/N) ');
Read (H);
if (H = 'S') or (H = 's') then Ordena;
write ('Ingrese el valor a insertar : ');
Read (Aux);
I := K - 1;
while U[I] > Aux do
begin
U[I+1] := U[I];
I := I - 1;
end;
U[I+1] := Aux;
end
else
begin
write ('No hay mas lugar en el vector');
Read (H);
end
end; {* fin de agrega *}
procedure menu; {* comienzo del procedimiento menu *}
{* genera y maneja un menu de opciones *}
Var
H :integer;
begin
repeat
repeat
limpieza;
writeln (' M E N U ');
writeln (' -----------', NL, NL, NL);
writeln ( ' 1. Ingresar un valor al vector ', NL);
writeln ( ' 2. Listar el vector ', NL);
writeln ( ' 3. Borrar un valor ', NL);
writeln ( ' 4. Ordenar el vector ', NL);
writeln ( ' 5. Insertar un valor ', NL);
writeln ( ' 6. Salir del programa ', NL, NL);
write ( ' Elija una opcion ');
readln (H); {* lee la opción *}
until (H > 0) and (H < 7);
case H of
1 : Agrega; {* Llamada al procedimiento de agregar *}
2 : Lista; {* Llamada al procedimiento de listar *}
3 : Borra; {* Llamada al procedimiento de borrar *}
4 : Ordena; {* Llamada al procedimiento de ordenar *}
5 : Inserta; {* Llamada al procedimiento de insertar *}
else clrscr; {* Llamada a la salida del programa *}
end;
until H = 6;
end; {* fin del procedimiento menu *}
begin {* Comienzo del programa *}
limpieza; {* limpia la pantalla *}
asigna; {* asigna los 0 al vector *}
menu; {* llama al módulo menú *}
end. {* Fin del programa *}
Copia de un array:
Un array puede ser asignado a otro array, si y solo si, ambos tienen el mismo tipo y el
mismo ta-maño. Lo que implica que ambos fueron declarados por el mismo
identificador o por identificadores equivalentes.
Ejemplo:
Type
XX = array [1..30] of byte;
YY = array [1..30] of byte;
Var:
Alfa, Gama: XX;
Beta: YY;
Alfa := Gama; {única expresión válida}.
Beta := Alfa;
Gama := Beta;.
Parámetros de valor y de variable:
Los arrays pueden ser utilizados como parámetros en funciones y procedimientos; sin
embargo, el valor de una función no puede ser un array. Las variables tipo array
pueden ser utilizadas como pa-rámetros en la comunicación entre funciones y
procedimientos. El array local se inicializa de modo que contiene los mismos valores
que el array real correspondiente. El procedimiento manipula el array local y
cualquier cambio que se haga en el array local no se refleja en el array real.
type
Vector = array [1..10] of real;
var
M, N, P : Vector;
R : boolean;
function Identidad (A, B : Vector) : boolean; var
end;
procedure Suma (A; B: Vector;
var C: Vector);
end;
R := Identidad(M,N);
Suma (M,N,P);
Pasaje de elementos individuales:
En lugar de pasar todos los elementos del array, se pasan de uno por vez. Para el
ejemplo ante-rior se puede decir:
function Identidad (A, B : real) : boolean; var
end;
R := Identidad(M[3], N[3]);
Array bidimensionales (Tablas)
Un array bidimensional (tabla o matriz) es un array con dos índices, al igual que los
vectores que deben ser ordinales o tipo subrango. Para localizar o almacenar un valor
en el array se deben especifi-car dos posiciones (dos subíndices), uno para la fila y
otro para la columna. Los elementos se referen-cian con el formato:
T [3,A] elemento de la fila 3 y columna 4 Los diferentes tipos de índices no necesitan
ser subran-go del mismo tipo.
Declaración de los arrays bidimensionales
Al igual que en los arrays de una dimensión (los vectores), los arrays
multidimensionales (tablas) se crean con declaraciones type y var cuando un
programa se codifica en Pascal.
type
Tabla = array [1..10,4..25] of real;
type
Tabla = array [1..10] of array [4..25] of real;
var
M, : array [1..10,4..25] of real;
Manejo de tablas
Para el manejo de tablas, no debemos olvidarnos que las celdas de las mismas se
identifican por dos subíndices. Por lo tanto cualquier proceso que queramos realizar
sobre la misma, involucrará a ambos subíndices.
Por ejemplo cuando se desea leer un array se podrá hacer por filas, según se puede
ver.
var
M, : array [1..10,4..25] of real;
For Fila := 1 to 10
For Columna := 4 to 25
Writeln(A[Fila, Columna]);
Por columnas.
For Columna := 4 to 25
For Fila := 1 to 10
Writeln(A[Fila, Columna]);
Array multidimensionales
Pascal no tiene límite para el número de dimensiones. Pero al usuario corriente no se
le reco-mienda superar las 3 dimensiones, ya que se vuelve complejo su manejo.
Declaración de los arrays multidimensionales
Al igual que en los arrays de bidimensionales (las tablas), los arrays
multidimensionales se crean con declaraciones type y var cuando un programa se
codifica en Pascal.
type
Matriz = array [1..10,4..25,´A¨..¨Z¨] of byte;
type
Vector = array [1..10] of byte;
Matriz = array [4..25,´A¨..¨Z¨] of Vector;
type
Vector = array [1..10] of byte;
Tabla = array [4..25] of Vector;
Matriz = array [´A¨..¨Z¨] of Tabla;
var
M, : array [1..10] of array [4..25,] of array [´A¨..¨Z¨] of byte;
CONSTANTES DE TIPO ARRAY (TIPEADAS)
Turbo Pascal permite que las constantes con tipo (tipeadas) puedan ser de casi
cualquier tipo. Las constantes con tipo, no son constantes en el estricto sentido, sino
variables inicializadas, es decir, variables que tienen un valor inicial específico en la
cabecera del programa.
Ejemplos
const
A : array [1..5] of integer = (10,20,30,40,50);
const ( vectores )
Dias Por Mes : array [l..l2] of integer = (31,28,31,30,31,30,31,31,30,31,30,31);
Práctica Nº 7
1. Leer una lista de 10 valores enteros. Listarlos por pantalla en sentido inverso al que
ingresaron.
2. Dado un vector 15 valores, hacer un programa que pueda obtener, y sacar por
pantalla
el mayor de los valores
el menor de los valores
el más próximo al promedio
3. Suponiendo que los valores del problema anterior fueran mediciones. Se pide
modificarlo de forma tal que sin uso de vectores auxiliares. Se pueda calcular la
desviación media y ña des-viación estándar
Donde Xj, es cada uno de los valores X es el promedio de los valores, y N la cantidad
de valores.
4. Se lee las letras de una palabra carácter a carácter. El último carácter que ingresa
es la barra de dividir(/), que indica que la palabra ha finalizado. Escribir un programa
que imprima la pala-bra en el orden que se ingresó y en sentido inverso (pera arep, la
palabra podrá tener hasta 20 caracteres).
5. Diseñar un algoritmo recursivo, que permita invertir el contenido de un vector.
Como indica el ejemplo:
Vector original: 28 35 12 43 56 77
Vector invertido: 77 56 43 12 35 28
El algoritmo no podrá usar un vector auxiliar.
6. Hacer un programa que permita realizar la suma y el producto de dos vectores.
El usuario puede elegir el tamaño del vector (entre 2 y 10 valores)
El usuario elige la operación a realizar.
7. Dado un vector de 20 posiciones (números enteros). Genere un programa que
permita realizar las siguientes operaciones.
Ingresar un elemento en el final de la cola (primera posición libre del vector).
Comproban-do antes del ingreso que existe una posición libre, sino colocar un
mensaje de aviso.
Sacar el elemento que se encuentra en la primera posición (si hay, sino colocar un
men-saje de aviso), corriendo luego los demás en la cola una posición hacia delante.
Listar en cualquier momento el contenido de la cola del primero al último.
8. Dado un vector de 20 posiciones (números enteros). Genere un programa que
permita realizar las siguientes operaciones.
Ingresar un elemento en la última posición de la pila (primera posición libre del
vector). Comprobando antes del ingreso que existe una posición libre, sino colocar un
mensaje de aviso.
Sacar el elemento que se encuentra en la última posición (si hay, sino colocar un
mensaje de aviso).
Listar en cualquier momento el contenido de la pila del primero al último.
9. Dado un vector de 20 posiciones (números enteros). Genere un programa que
permita realizar las siguientes operaciones.
Ingresar un elemento en la posición que le corresponda de la lista, de manera que la
mis-ma se mantenga en orden creciente. (para lo cual desplaza los demás elementos
una posición para atrás).Comprobando antes del ingreso que existe una posición libre,
sino colocar un mensaje de aviso.
Sacar de la lista el elemento que indica el usuario (si se encuentra, sino colocar un
men-saje de aviso).
Listar en cualquier momento el contenido de la cola del primero al último.
10. Pascal como otros lenguajes operan con números enteros 2,148 109, estos no
tienen errores por redondeo. Para valores más grandes se trabajan con reales, pero
ellos si tienen errores de redondeo. Se le pide a Ud.. Haga un programa que opere con
números que poseen entre 10 y 20 cifras, que puedan hacer:
Suma
Resta
Multiplicación
Sin errores, asegurando todas las cifras
** Se recomienda hacer todos los problemas de esta práctica.
P U B L I C A D O P O R E L M U N D O B L O G E N 1 4 : 5 0 N O H A Y C O M E N T A R I O S :
E T I Q U E T A S : V E C T O R E S Y M A T R I C E S
Página principal
Suscribirse a: Entradas (Atom)
A R C H I V O D E L B L O G
▼ 2007 (1)
o ▼ julio (1)
Vectores y Matrices