Sunteți pe pagina 1din 45

3.1

III. VECTORES Y MATRICES

3.1. Conceptos

Interna:

(Reside en la memoria central del computador)

Interna: (Reside en la memoria central del computador) Externa: (Depende de un soporte externo)

Externa:

(Depende de un soporte externo)

Estructura de datos

Estáticos: Tiene un número fijo de elementos que queda determinado desde la declaración en la
Estáticos: Tiene un número fijo de
elementos que queda determinado desde
la declaración en la estructura del
programa.
Dinámicos: Tienen un número de
elementos que varía a lo largo de la
ejecución del programa.

Un arreglo consiste en un número fijo, finito y ordenado de elementos, todos del mismo tipo y bajo un nombre común para todos ellos.

Nombre

Valor

Valor

Valor

Valor

Valor

Valor

Valor

Valor

1

2

3

4

5

6

7

N

≠≠≠≠

Primer

enésimo

elemento

elemento

3.2

Tipos de arreglos:

Tipos de Arreglos

Unidimensionales Bidimensionales Multidimensionales
Unidimensionales
Bidimensionales
Multidimensionales

a) Arreglos unidimensionales (vectores) Son arreglos de una dimensión. También se denominan vectores. Tiene un solo índice. Cada componente del vector se direcciona mediante un nombre seguido del número correspondiente al índice entre paréntesis cuadrados.

1 2 3 4 5 6 7 8 9 10
1
2
3
4
5
6
7
8
9
10

En Java el primer elemento está en la posición 0.

entre paréntesis cuadrados. 1 2 3 4 5 6 7 8 9 10 En Java el

3.3

Para trabajar con vectores se necesita:

Declarar el vector

Crear el vector

Insertar elementos al vector

Obtener elementos del vector

Ejemplo: para trabajar con un vector de números enteros.

Declaración del Vector

int [] vecNum;

de números enteros. Declaración del Vector int [] vecNum; Crea una referencia para utilizar el arreglo.
de números enteros. Declaración del Vector int [] vecNum; Crea una referencia para utilizar el arreglo.

Crea una referencia para utilizar el arreglo.

Creación del Vector

vecNum = new int[26];

el arreglo. Creación del Vector vecNum = new int[26]; Crea un arreglo que puede almacenar 26
el arreglo. Creación del Vector vecNum = new int[26]; Crea un arreglo que puede almacenar 26

Crea un arreglo que puede almacenar 26 elementos de tipo int

3.4

Inserción de elementos en el Vector

for(int i=0; i<26;i++) {

vecNum[i]=i+1;

}
}

Obtener elementos Desplegar los elementos del vector en la pantalla.

for(int i=0; i<26;i++) { PantallaSalida.println(vecNum[i]);

}

Ejemplo:

Programa que lee la nota final de un alumno para cada una de 10 asignaturas, las almacena en un vector y calcula e imprime su media.

Refino:

PROGRAM NOTA MEDIA

Begin “Leer notas y dejarlas en un vector de 10 posiciones” “Sumar las notas” “Calcular e imprimir el promedio”

end

En Java:

3.5

import java.io.IOException; import disc.PantallaEntrada; import disc.PantallaSalida;

public class EjemploVector{ //Declaración y creación del vector double [] notas = new double[10]; //Lectura
public class EjemploVector{ //Declaración y creación del vector double [] notas = new double[10]; //Lectura

public class EjemploVector{

public class EjemploVector{ //Declaración y creación del vector double [] notas = new double[10]; //Lectura de
public class EjemploVector{ //Declaración y creación del vector double [] notas = new double[10]; //Lectura de

//Declaración y creación del vector double [] notas = new double[10];

//Lectura de las notas e ingreso al vector for(int i = 0; i < 10; i++) { PantallaSalida.print (“Ingrese nota “ +(i+1));

}

Notas[i] = nota;

//Calculo del promedio duble suma = 0; for(int i = 0;i<10; i++) { suma = suma + notas[i];

}

double prom = suma/10; PantallaSalida.println(“Promedio: “ + prom);

} //Fin main }//Fin EjemploVector

notas[i] = PantallaEntrada.getDouble();

notas[i] = PantallaEntrada.getDouble();

notas[i] = PantallaEntrada.getDouble();
notas[i] = PantallaEntrada.getDouble();
notas[i] = PantallaEntrada.getDouble();

public static void main(String args[])throws IOException{

double nota = PantallaEntrada.getDouble();

3.6

b) Arreglos Bidimensionales (Matrices) Son las tablas de 2 dimensiones. Tienen dos índices, por lo cual cada componente de la matriz se direccionan mediante su nombre seguido de los dos índices, donde cada uno se encuentra entre paréntesis cuadrados.

A

1

2

3

M

1

2

3

N

MxN

Matriz A de M filas y N columnas

En Java, la primera fila es la 0 y la primera columna es la 0.

3 … M 1 2 3 … N MxN Matriz A de M filas y N

Declaración de la matriz int [][] m;

Creación d ela matriz m=new int[13][2];

3.7

int [][] m; Creación d ela matriz m=new int[13][2]; 3.7 Direccionamiento de un elemento A [fila]

Direccionamiento de un elemento

A[fila] [columna] Identificador

3.7 Direccionamiento de un elemento A [fila] [columna] Identificador ≠ ≠ Valor variable o expresión numérica

Valor variable o expresión numérica entera

3.8

Ejemplos:

int val = 0; for(int f=0; f<13; f++) {

for(int c=0; c<2; c++){ m[f][c]= val; val++;

}

}

3.8 Ejemplos: … int val = 0; for(int f=0; f<13; f++) { for(int c=0; c<2; c++){

3.9

int val = 0; for(int c=0; c<2; c++) {

for(int f=0; f<13; f++){ m[f][c]= val; val++;

}

}

3.9 … int val = 0; for(int c=0; c<2; c++) { for(int f=0; f<13; f++){ m[f][c]=

3.10

En general, los elementos de una matriz se almacenan en la memoria interna de la computadora por columnas es decir:

A(1,1), A(2,1), A(3,1), …, A(N,1), A(N,2), A(N,3), A(N,4), …, A(N,M)

A

1

2

3

M

1 2 3 … N
1
2
3
N

Ejemplo:

Matriz de 7 filas y 9 columnas (no se ocupará ni la fila ni columna 0) que contiene el número de alumnos matriculados a cada grupo de un centro docente, por asignatura. Las filas corresponden a los grupos y las columnas a las asignaturas. Asignatura 7

a los grupos y las columnas a las asignaturas. Asignatura 7 MATRICULA Grupo 6 1 2

MATRICULA

y las columnas a las asignaturas. Asignatura 7 MATRICULA Grupo 6 1 2 3 4 5

Grupo 6

1

2

3

4

5

6

1 2 3 4 5 6 7 8 35 30 32 32 34 35 34
1
2
3
4
5
6
7
8
35
30
32
32
34
35
34
28
40
33
40
37
36
39
40
29
25
23
26
21
24
24
25
15
33
33
33
32
34
30
32
20
45
44
45
44
43
40
44
33
24
20
22
22
24
25
24
12
Hay 21 alumnos del grupo 3 en la asignatura 4

3.11

Se debe construir un algoritmo que cargue la tabla del ejemplo anterior y a continuación calcule e imprima el total de alumnos matriculados por asignatura. El nombre de las asignaturas es el siguiente:

Asignatura Número 1: Matemáticas Asignatura Número 2: Lengua Española Asignatura Número 3: Formación Humanística Asignatura Número 4: Ciencias Naturales Asignatura Número 5: Inglés Asignatura Número 6: Informática Básica Asignatura Número 7: Estructura de la Información Asignatura Número 8: Metodología de la Programación Suponemos que los seis grupos son del mismo nivel y tienen las mismas asignaturas.

Program Matricula Begin “Leer matriz” for cada asignatura:

“Calcular el total de alumnos” “Imprimir el total de alumnos” endfor end

3.12

import java.io.IOException;

import disc.PantallaEntrada; import disc.PantallaSalida;

public class TotalAlumnos{

public static void main(String args[])throws IOException{

int [][] matriz = new int[7][9];

String [] asig = new String [9];

asig[1] = “Matemáticas”; asig [2] = “Lengua Española”; asig [3] = “Formación Humanista”; asig [4] = “Ciencias Naturales”; asig [5] = “Inglés”; asig [6] = “Información Básica”; asig [7] = “Estructura de la Información”; asig [8] = “Metodología de la Programación”;

for(int f = 1; f <= 6; f++) { for (int c = 1; c <= 8; c++){ PantallaSalida.println(“Grupo: “+ f + “ Asignatura: “+asig[c]); matriz[f][c]= PantallaEntrada.getInt();

}

}

3.13

PantallaSalida.println(“Alumnos matriculados”);

PantallaSalida.println(“Asignatura

PantallaSalida.println(“------------- ---------------------”);

for(int c = 1; c<=8; c++) { int suma = 0; for(int f = 1; f<=6;f++){ suma = suma + matriz[f][c];

Número Alumnos”);

}

PantallaSalida.println(asign [c]+ “

}

} //Fin main

} //Fin TotalAlumnos

“+ suma);

3.2 Algoritmos de búsqueda

Concepto de búsqueda:

3.14

Entrada:

A[I], I = 0, N-1

y Valor

Salida:

Posición donde se encuentra Valor. Si no está, se envía un mensaje.

Datos se encuentran desordenados

Búsqueda Secuencial

BEGIN

N = PantallaEntrada.getInt():

FOR i = 0 TO N-1 Leer (A[i]) END FOR READ (VALOR) i 0;

Alternativa

i -1;

do{ i i + 1

} while (A[i] !=VALOR && i < N-

1);

if (A[i] == VALOR){ PantallaSalida.println (i);

}

else { PantallaSalida.println (“valor no

encontrado”);

Evaluación cortocircuito

(“valor no encontrado”); Evaluación cortocircuito while (i<=N-1 && A[i]!=VALOR) { i i + 1 } if

while (i<=N-1 && A[i]!=VALOR) { i i + 1

}

if

}

(i == N) { PantallaSalida.println(“valor no encontrado”);

else {

PantallaSalida.println(i);

}

Alternativa

for(int i = 0; i < N; i++){ if (A[i] == VALOR){ PantallaSalida.println(i); break;

}

}

if (i == N) { PantallaSalida.println (“valor no

encontrado”);

END

3.15

Búsqueda Secuencial Rápida

BEGIN READ (N) FOR I = 0 TO N -1 READ (A[I]) END FOR

Rápida BEGIN READ (N) FOR I = 0 TO N -1 READ (A[I]) END FOR READ

READ (VALOR) A[N] VALOR

i 0; while (A[i] != VALOR) { i i + 1;

}

if (i == N){ PantallaSalida.println (‘valor no encontrado’);

}

Alternativa

i -1;

do{ i i + 1

} while (A[i] != VALOR);

if (i == N) { PantallaSalida.println (“valor no encontrado”);

}

else { PantallaSalida.println (i);

}

else { PantallaSalida.println (VALOR, I);

}

END

3.16

Datos se encuentran ordenados de menor a mayor

Búsqueda Secuencial

BEGIN READ (N) FOR I = 0 TO N-1 READ (A[I]) END FOR READ (valor)

READ (N) FOR I = 0 TO N-1 READ (A[I]) END FOR READ (valor) i 0;
READ (N) FOR I = 0 TO N-1 READ (A[I]) END FOR READ (valor) i 0;

i 0; while (i <= N-1 && A[i] < valor) { i i + 1;

}

if (i == N | |

A[i] > valor) {

PantallaSalida.println (‘valor

}

no encontrado’);

Else { PantallaSalida.println(VALOR, I);

}

END

Alternativa

i -1;

do{ i i + 1;

} while (A[i] < valor && i < N-1);

if (A[i] == valor ) { PantallaSalida.println (i);

}

else{ PantallaSalida.println (“valor no

}

encontrado”);

3.17

Búsqueda Binaria K: Posición de al medio del arreglo

I K J
I
K
J

Si Valor = A[K] ==> Búsqueda Positiva

Si Valor > A[K], Calcular I K + 1

Si Valor < A[K], Calcular J K – 1

BEGIN READ (N)

FOR I = 0 TO N-1 READ (A[I]) END FOR READ (VALOR)

I 0;

J N-1

do

K ( I + J ) / 2 IF(VALOR > A[K])

   

I

K + 1

ELSE

J

K – 1

ENDIF while (A[K] != VALOR && I <= J); IF (A[K] == VALOR) {

PantallaSalida.println (VALOR, K)

}

ELSE {

PantallaSalida.println (“VALOR NO ENCONTRADO”);

}

END

3.18

Problema:

Determinar el ganador de una elección. El programa recibe inicialmente el listado de 50 candidatos y luego 1000 votos (los votos contienen el nombre del candidato).

 

candidatos

votos

0

   

1

   

2

   

   

49

   

Refino:

PROGRAM VOTOS

BEGIN “Leer a los 50 candidatos y dejarlos en un vector de 50 posiciones”

“Inicializar el contador de votos de cada candidato en 0”

FOR I 1 TO 1000 READ (VOTO) “Buscar a que candidato corresponde ese voto” “Incrementar el contador correspondiente”

endfor

“Determinar al candidato con la mayor cantidad de votos” “Imprimir al candidato ganador”

END

3.19

import java.io.IOException; import disc.PantallaEntrada; import disc.PantallaSalida; public class Votos{ public static
import java.io.IOException;
import disc.PantallaEntrada;
import disc.PantallaSalida;
public class Votos{
public static void main(String args[]) throws IOException{
String [] candidatos = new String[50];
int [] votos = new int[50];
Alternativa
for(int i = 1 <= 50; i++) {
String nombre = PantallaEntrada.getString();
candidatos[i-1] = nombre;
votos[i-1] = 0;
int i;
for(i = 0; i <= 49; i++){
if (candidatos[j].equals(nombre))
}
break;
for (int i = 1 ; i<=1000; i++){
}
String nombre = PantallaEntrada.getString();
if (i <= 49)
votos [i] ++;
int j= 0;
while(j < 50 && !candidatos[j].equals(nombre))
j = j +1;
Alternativa
if (j == 50) {
PantallaSalida.println
int j = -1;
do {
(“Candidato no existe”);
j ++;
}
}while(!candidatos[j].equals(nombre)
else {
votos[j]= votos[j] +1;
&&
j<49);
}
if (candidatos[j].equals(nombre))
votos[j] ++ ;
} //fin for
int mayor = 0;
String mejorCandidato = null;
for(int i = 0; i<= 49; i++){
if (votos[i] > mayor) {
mayor = votos[i];
mejorCandidato = candidatos[i];
}
}
PantallaSalida.println (mejorCandidato + mayor);
} // fin main
}//Fin votos

3.20

3.3. Algoritmos de Ordenamiento

Entrada:Arreglo Desordenado

Salida:

Ordenamiento Simple

Arreglo Ordenado de menor a mayor

BEGIN //Lectura del vector PantallaSalida.println (“Ingrese valor de N: ”); int N =PantallaEntrada.getInt(); for (int i=0; i <N; i++) { PantallaSalida.print (“Ingrese valor de A[“+i+”]: ”); A[i]= PantallaEntrada.getInt();

}

//Ordenamiento del vector for (int i=0; i <=N-2; i++) { for (int j=i+1; j<=N-1; j++) {

}

if (A[i] > A[j]) { AUX A[i]; A[i] A[j]; A[j] AUX;

}

}

//Despliegue del arreglo ordenado for (int i=0; i <N; i++) { PantallaSalida.println (A[i]); }
//Despliegue del arreglo ordenado
for (int i=0; i <N; i++) {
PantallaSalida.println (A[i]);
}

END

3.21

Ordenamiento de Burbujas

BEGIN //Lectura del vector PantallaSalida.println (“Ingrese valor de N: ”); int N = PantallaEntrada.getInt(); for (int i=0; i <N; i++) { PantallaSalida.print (“Ingrese valor de A[“+i+”]: ”); A[I]= PantallaEntrada.getInt();

}

//Ordenamiento del vector

for(int i = 0; i <=N -2; i++){ for( int L = N -1; L
for(int i = 0; i <=N -2; i++){
for( int L = N -1; L >= i+1; L--) {
if (A[L] < A[L – 1]) {
AUX = A[L];
A[L] = A[L – 1];
A[L – 1] = AUX;
}
}
}
//Despliegue del arreglo ordenado
for (int i=0; i <N; i++) {
PantallaSalida.println (A[i]);
}

END

3.22

3.4. Algoritmos de Inserción y Eliminación

Eliminación

Eliminar de un arreglo A de N elementos, el valor

X.

El arreglo y X deben ser leídos. Imprimir el arreglo resultante. El arreglo podría estar ordenado o no.

PROGRAM Eliminar BEGIN “Leer arreglo” “Leer X” “Buscar la posición donde está X en el arreglo”

IF (X está en el arreglo) “Corrimiento” N N - 1 “Imprimir arreglo resultante”

ENDIF END

Primera posición a correr

Segunda posición a correr

Tercera posición a correr

x

0

N-1

3.23

import java.io.IOException; import disc.PantallaEntrada; import disc.PantallaSalida;

public class Eliminar{ public static void main(String args[])throws IOException{

PantallaSalida.print (“Ingrese cantidad de elementos: ”); int N = PantallaEntrada.getInt() int [] A = new int[N]; for(int i = 0; i < N; i++){ PantallaSalida.print (“Ingrese datos del vector: ” ); A[i] = PantallaEntrada.getInt();

}

PantallaSalida.print (“Ingrese valor a eliminar:”); int X = PantallaEntrada.getInt();

//Se busa el elemento a eliminar int i = 0;

while (i < N && X != A[i]) { i++;

}

if (i == N) { PantallaSalida.println (‘Valor no encontrado’);

}

else { //Corrimiento for(int k = i ; k <N-1; k++) { A[k] = A[k
else { //Corrimiento
for(int k = i ; k <N-1; k++) {
A[k] = A[k + 1];
}
N--; //El vector tiene un elemento menos
}

for (int

I = 0 ; I<= N-1; I++) {

PantallaSalida.println (A[I]);

}

}//Fin main }//Fin Eliminar

3.24

Inserción Leer un arreglo de N elementos que está ordenado. Leer un valor X e insertarlo en el arreglo de manera que se conserve el orden. Imprimir el nuevo arreglo.

PROGRAM Insertar BEGIN “Leer arreglo” “Leer X” “Buscar la posición donde se debe insertar X para que el arreglo siga ordenado” “Corrimiento” “Insertar X” N N + 1 “Imprimir arreglo resultante” END

0 Posición a insertar x N-1 N
0
Posición a insertar x
N-1
N

Tercera posición a correr

Segunda posición a correr

Primera posición a correr

3.25

import java.io.IOException; import disc.PantallaEntrada; import disc.PantallaSalida;

public class Insertar{ public static void main(String args[])throws IOException{

PantallaSalida.print (“Ingrese cantidad de elementos: ”); int N = PantallaEntrada.getInt() int [] A = new int[N+1];

for(int i = 0; i < N; i++){ PantallaSalida.print (“Ingrese datos del vector: ” ); A[i] = PantallaEntrada.getInt();

}

PantallaSalida.println (“Ingrese valor a insertar: ”); int x = PantallaEntrada.getInt();

//Búsqueda de la posición donde hacer la inserción, //de manera de mantener el orden de los datos, //de mayor a menor int i = 0; while (i <= N-1 && x > A[i]){ i++; //Búsqueda de la posición donde hacer la inserción, //de manera de mantener el orden de los
}

//Corrimiento for(int k = N ; k >= i + 1; k--){ A[k] = A[k – 1]; //Corrimiento }
}

A[i] = x; N ++; for(int i = 0; i < N; i++){ PantallaSalida.println (A[i]);

}

}//Fin main }//Fin Insertar

3.26

3.5. Ejercicios

1. Leer

1000

datos

numéricos

enteros

desde

pantalla

y

cargarlos en un vector de 12000 posiciones.

2. Leer 300 números reales desde pantalla y ubíquelos en las posiciones pares de un vector de 1000 posiciones.

3. Diseñe un algoritmo que genere un vector, de tal manera que en cada posición del vector coloque el subíndice respectivo. El tamaño del vector es N y debe ser leído desde pantalla.

4. Leer 100 valores enteros desde pantalla y almacenarlos en un vector A. Calcular e imprimir la suma de estos valores.

Program cuatro

begin “Leer datos y cargarlos en vector” “Sumar los elementos del vector” “Imprimir el resultado”

end

3.27

5. Leer desde pantalla un arreglo de reales cuyo tamaño es N, donde N viene como primer dato. Calcular e imprimir el promedio de los elementos del arreglo que se encuentran entre 10 y 25.

Program cinco begin “Leer N”

end

for

“Leer valor y dejarlo en el vector” “Acumular el valor si corresponde” end for “Calcular e imprimir el promedio si corresponde”

I = 1 to N

6. Leer a, b, c, d, e (reales) desde pantalla y cargarlos en las primeras 5 posiciones de un vector. Calcular ((a + b) * c) / (d – e) y almacenar el resultado en la posición 6 del vector. Considere que (d – e) puede ser

0.

Program seis begin “Leer a, b, c, d, e y dejarlas en las cinco primeras posiciones del vector ”

end

if ( (d – e) <> 0) then “Calcular valor y dejarlo en posicion 6 del arreglo”

end if

3.28

7. Leer desde pantalla los datos de un vector de enteros de tamaño N. Se debe calcular el promedio y luego determinar e imprimir los datos y la posición de los que sobrepasan en 5 al promedio. N es el primer dato a leer.

Program siete begin “Leer N”

for

I = 1 to N “Leer dato y dejarlo en el vector”

“Acumular dato” end for

“Calcular promedio”

for

I = 1 to N

“Determinar si el elemento I del vector es mayor en 5 unidades que el promedio” “Imprimir posición I si corresponde”

end for end

3.29

8. Inicializar el vector A, de tamaño N, con 1 en las posiciones correspondientes a K, donde K se determina según la serie de Fibonacci, cuyos 2 primeros términos son F1 y F2 (F1 < F2). Las otras posiciones del vector deben ser inicializadas con 0. Los valores de F1, F2 y N deben ser leídos desde pantalla.

Program ocho begin “Leer N, f1 y f2” “Inicializar vector A con ceros” A[f1] 1 A[f2] 1 “Calcular valor (Fibonacci)”

while (valor <= N) A[valor] 1 “Actualizar f1 y f2” “Calcular valor”

end while end

3.30

9. Leer un vector de reales de tamaño N. N es el primer dato. Listar los 3 valores mayores y los 2 menores.

Program nueve_version1 begin “Leer N” “Leer vector ” “Ordenar vector de mayor a menor” “Imprimir los tres mayores” “Imprimir los dos menores” end

Program nueve_version2 begin “Leer N” “Leer vector ” “Inicializar los tres mayores y los dos menores” “Determinar los tres mayores” “Imprimir los tres mayores” “Determinar los dos menores” “Imprimir los dos menores”

end

3.31

10. Calcular e imprimir:

S =

N

i = 1

X

i

X

2

N

;

N

X i

X

=

i = 1

N

Valores de N y X i deben ser leídos desde pantalla.

Program diez begin “Leer datos del vector” “Sumar los elementos del vector” “Sacar promedio” “Calcular e imprimir S” end

11. Inicializar la matriz de 10 x 10 con 1 en la diagonal principal y 0 en las restantes posiciones.

12. Dada la matriz A de NxM, sumar los elementos de las filas y el resultado almacenarlo en el vector FILA(I), con I=0,N-1

Program doce

begin

for

I = 0 to N-1 “Sumar los elementos de la fila I” Fila[I] suma

end for

end

3.32

13. Leer un vector de 10*M elementos desde teclado. M es el primer dato a leer, los datos vienen ordenados de mayor a menor. Luego, leer un archivo “datos.txt”, donde cada registro consta de dos campos, el primero es el dato y el segundo es el código de una operación. Las acciones a seguir según el código de operación son:

Código 1

Código 2

Código 3

Código 4

Ingresar el dato al vector

Eliminar el dato del vector

Imprimir el vector

Finalizar

Nota: El vector siempre debe permanecer ordenado de mayor a menor, los datos en el archivo no necesariamente están ordenados.

3.33

14.

Program trece begin “Leer M” “Leer vector de 10*M elementos” “Definir el archivo de lectura Datos.txt” “Leer dato”

ok true while ((no sea fin de archivo) and ok = true) “Leer codigo”

case codigo 1: “Ingresar en orden el valor al vector” 2: “eliminar en orden el valor del vector” 3: “Imprimir vector”

4: ok false

“Leer dato” end while end

Calcular la suma de dos matrices M1 de NxM y M2 de NxM. Ambas matrices deben leerse previamente. Se debe imprimir la matriz resultante. Program catorce begin “Leer N y M” “Leer M1” “Leer M2” “Sumar matrices” “Imprimir matriz resultante”

end

3.34

15. Realizar un algoritmo que, utilizando un vector, genere los 100 primeros números de la serie de Fibonacci, los cuales deben quedar almacenados en el vector.

16. Escribir un algoritmo que permita rotar hacia la derecha k veces los valores de un vector V de 1000 posiciones. El valor de k debe leerse. Ejemplo: Para K = 1

a

b c d e f

b

c d e f

a

Program diezyseis_version1

begin “Leer vector” “Leer K” “Rotar el vector”

End

17. Invertir un vector dado, sin usar otro vector.

Program diezysiete begin “Leer vector” “Invertir vector” end

3.35

18. Dada una matriz de NxM a) Almacenar en un vector llamado FILA, la suma de cada fila de la matriz b) Almacenar en un vector llamado COLUMNA, la suma de cada columna de la matriz c) Determinar las posiciones de la matriz que contienen valores menores que 7

Program diezyocho begin

for

“Sumar fila i-esima de la matriz” Fila[I] sumaF end for

for

I = 0 to N-1

J = 0 to M-1

“Sumar columna i-esima de la matriz” Columna[J] sumaC end for “Recorrer la matriz y determinar las posiciones que contienen valores menores que siete “ end

3.36

19. Leer la edad y nombre de 200 personas y almacenarlas en los vectores EDAD y NOMBRE respectivamente, de manera que EDAD[i] corresponda a NOMBRE[i]. Luego ordenar los vectores por edad en orden decreciente, teniendo cuidado de no perder la relación Edad-Nombre.

Program diezynueve

begin “Leer vectores edad y nombre” “Ordenar vector edad, cambiando cuando corresponda también en el vector nombre”

end

3.37

20. Para el ejercicio anterior, implementar algoritmos que permitan eliminar o insertar datos en los vectores, en forma ordenada. Los datos a eliminar o insertar se leen desde el archivo “Alumnos.txt”, cuyos registros tienen tres campos, una operación, la edad y el nombre. Si la operación es igual a 1, los datos se deben insertar en los vectores. Si la operación es igual a 2 los datos se deben eliminar. Si la operación es igual a 3, finalizar.

Program veinte begin ok true “Definir el archivo de lectura Alumnos.txt” “Leer operacion” while ((no sea fin de archivo) and ok) “Leer edad” “Leer nombre”

case op 1: “ingresar en orden los datos en los vectores” 2: “eliminar en orden los datos de los vectores” 3: ok falso.

endcase “Leer operacion” endwhile

end

21. Se tiene un vector V con 500 números, determinar cuántos números se repiten y eliminar todas las repeticiones.

3.38

22. Se necesita un programa que controle la entrada a una fiesta universitaria. A cada persona que ingrese, se le pedirá la cédula universitaria, la cual posee un código numérico. Para el proceso, el programa recibirá un archivo llamado “Fiesta.txt”, con los 6500 códigos válidos (los códigos son enteros). El programa debe cautelar que sólo ingresen universitarios verdaderos y que no puedan ingresar más de una persona con la misma cédula. Invente un buen fin de fiesta.

univ: matriz de 6500 filas y 2 columnas

0

1

.

.

.

6499

En la segunda columna, se almacena un valor que indica si el alumno ingresó o no a la fiesta. Por ejemplo, se puede almacenar un cero para indicar que el alumno no ha entrado a la fiesta y un 1 cuando el alumno entre a la fiesta.

3.39

Program veintidos begin “Definir una matriz de 6500 filas y 2 columnas” “Definir el archivo de lectura Fiesta.txt”

   

“Leer codigo” while (no sea fin de archivo) “Guardar el código y en la matriz” “Leer codigo”

 

endwhile “Leer datos de una entrada”

while (No sea fin de datos) “Buscar el código en el vector” “Si está, se debe chequear si ya había ingresado” “Leer datos de una entrada”

endwhile

end

3.40

23. Se posee una lista de factores de corrección de temperaturas, en una archivo de 5000 registros, con el siguiente formato: factor, temperatura (ºC). Procesar un archivo de datos con registros que contienen: Código muestra, Volumen, Presión y Factor. Para cada registro de este archivo, se debe calcular la fórmula R = (Volumen*Presión)/Temperatura, para realizar este cálculo, se debe convertir el factor de cada registro a la temperatura correspondiente. Si no existe un factor igual, no calcular R.

 

factor

tra

0

   

1

   

2

   

   

4999

   

Program veintitres begin “Leer archivo con factores de corrección y dejarlo en 2 vectores de 5000 posiciones (factor y tra)” while (not eof (archivo de muestras)) “Leer registro” “Buscar el factor en el vector” “Si existe”: “obtener la temperatura “ “calcular R” “imprimir R”

endwhile

end

3.41

24. Realizar el mismo proceso anterior, pero suponiendo que la lista de factores está ordenada en el archivo de menor a mayor. Si el factor a convertir no está en la lista, aproximar al más cercano existente.

Program venticuatro begin “Leer archivo con factores de corrección y dejarlo en un vector de 5000 posiciones” while (not eof archivo muestras) “Leer registro” “Buscar el factor en el vector” “Si está, obtener la temperatura” “Si no está, aproximar la temperatura” “Calcular e imprimir R” end while

end

3.42

25. Un alumno de Ingeniería Civil de la U.C.N., al término de su carrera desea saber cómo fue su desempeño en la

Para esto solicitó a un alumno de

Introducción a la Programación que le confeccione un

Universidad.

algoritmo que determine:

a) Cuántas de sus notas son mayores que 5.5

b) Cuántas de sus notas son menores que 4.5

c) El promedio de notas

d) El porcentaje que representan las notas mayores que

6.0

e) La nota menor y la nota mayor

f) Un listado de notas de mayor a menor.

Program veinticinco begin “Leer datos del archivo y cargarlos en un vector” “Determinar cuántas notas son mayores que 5.5” “Determinar cuántas notas son menores que 4.5” “Determinar el promedio de notas” “Determinar el porcentaje de notas mayores que 6.0” “Determinar la nota mayor” “Determinar la nota menor” “Obtener un listado de notas de mayor a menor”

end

3.43

26. Llenar un vector con datos desde un archivo, y determinar cuál es el dato que más se repite. El vector es de largo N.

Program veinteyseis begin “Leer archivo y llenar el vector original” “Determinar cuál es el dato que más se repite. Para eso se usará otro vector (num) que no tiene datos repetidos ” “Determinar al mayor del vector (cont) que cuenta los numeros”

end

 

num

cont

0

   

1

   

   

m-1

   

27. Se dispone de un archivo que contiene una matriz A de NxM y un vector B de M elementos. Calcular e imprimir el producto entre el arreglo bidimensional y el vector. Precediendo a los datos, el archivo contiene los valores de N y M. El resultado debe almacenarse en un vector C de largo N. Program veintisiete

begin “Leer datos” “Calcular producto y dejarlo en un vector C” “Imprimir el vector C”

end

3.44

28. En un archivo se dispone de los arreglos A de N1xN2 y B de N2xN3. Calcular e imprimir el arreglo C = A*B. Precediendo a los datos en el archivo, se dispone de los valores de N1, N2 y N3.

Nota:

C

ij

=

N 2

h = 1

a b

ik

kj

Program veintiocho

begin “Leer datos” “Multiplicar matrices” “Imprimir matriz resultante”

end

29. Construya un programa que a partir de un archivo de ventas (ventas.txt) de una empresa, determine los diez productos más vendidos, ordenando los resultados de menor a mayor; y los productos que no se vendieron. El archivo de ventas contiene por cada registro el código del producto (entero) y la cantidad vendida. Además, se tiene un archivo inventarios.txt, que contiene en cada registro el código del producto y su stock.

Considere que cada vez que procesa un registro del archivo de ventas debe actualizar el stock del producto correspondiente.

3.45

Refino 1

Begin. “Generar los 3 vectores a partir del archivo inventarios” “Procesar archivo de ventas” “Emitir salidas” End.

Refino 2 “Generar los 3 vectores a partir del archivo inventarios”

Begin “Cargar en tabla el archivo de inventarios” “Dejar vector cantidad en 0” End.

Producto

Stock cantidad
Stock
cantidad

Procesar archivo de ventas”

Begin while (not EOF de ventas) do “ Leer registro” “Sacar el campo código del registro” “Sacar el campo cantidad del registro” “Buscar el código en vector de productos” “Disminuir stock asociado” “Actualizar vector cantidad” end while

End

“Emitir salidas”

Begin “Ordenar vector cantidad, manteniendo consistencia de los 3 vectores” “Seleccionar 10 mayores” “Emitir listado mayores” “Seleccionar productos no vendidos (cantidad = 0)” “Emitir listado no vendidos” End.