EJERCICIOS DE PROGRAMACIN

NOMBRE: Mara Fernanda Molina Otero

CDIGO:20141124556

1) Calcular el promedio de 50 valores almacenados en un vector. Determinar adems cuantos son

mayores que el promedio, imprimir el promedio, el nmero de datos mayores que el promedio y
una lista de valores mayores que el promedio.

proceso EJERCICIO_UNO
Dimension prom[50]
sum<-0
Para i<-1 hasta 50 hacer
Escribir "por favor ingrese el valor correspondiente " i
Leer prom[i]
sum<-sum+prom[i]
FinPara
promedio<-sum/50
Escribir ""
Escribir "el promedio de los valores es: " promedio
sum1<-0
para k<-1 Hasta 50 Hacer
si promedio<prom[k] Entonces
sum1<-sum1+1
FinSi
FinPara
Escribir ""
Escribir "las cifras de valores mayores al promedio es igual a: " sum1
Escribir "observe la lista a continuacion"
Escribir ""
para k<-1 Hasta 50 Hacer
si promedio<prom[k] Entonces
Escribir "cifra", k "que es:", prom[k] "es mayor que el
promedio que corresponde a:", promedio
FinSi
FinPara
FinProceso
2) Llenar dos vectores A y B de 45 elementos cada uno, sumar el elemento uno del vector A con el
elemento uno del vector B y as sucesivamente hasta 45, almacenar el resultado en un vector C,
e imprimir el vector resultante.

Proceso EJERCICIO_2
Dimension x[45]
Dimension h[45]
Para i<-1 Hasta 45 Hacer
Escribir "Digite por favor el valor correspondiente al " i "
vector X"
Leer x[i]
Escribir "Digite por favor el valor correspondiente al " i
"vector H"
Leer h[i]
FinPara
Escribir ""
Dimension z[45]
Para j<-1 Hasta 45 Hacer
z[j]<-x[j]+h[j]
Escribir "El resultado obtenido para la adicion " j " de los
vectores X y H es: ", Z[j]
FinPara
FinProceso

3) Llenar un vector de 20 elementos, imprimir la posicin y el valor del elemento mayor

almacenado en el vector. Suponga que todos los elementos del vector son diferentes.

Proceso EJERCICIO_3
Dimension posicion[20]
Para i<-1 Hasta 20 Hacer
Escribir "DIGITE EL VALOR POR FAVOR " i
Leer posicion[i]
FinPara
Escribir ""
Para l<-1 hasta 20 hacer
Escribir "LA POSICION QUE CORRESPONDE" l " ES DEL
LUGAR: " posicion[l]
FinPara
Para j<-1 Hasta i-1 Hacer
posicion_mayor<-j
 Para k<-j Hasta i-1 Hacer
Si posicion[k]>posicion[posicion_mayor] Entonces
posicion_mayor<-k
FinSi
FinPara
aux<-posicion[j]
posicion[j]<-posicion[posicion_mayor]
posicion[posicion_mayor]<-aux
FinPara
Escribir ""
Escribir "EL DATO QUE ES MAYOR ES: " posicion[1]
FinProceso

4) Almacenar 500 nmeros en un vector, elevar al cuadrado cada valor almacenado en el vector,
almacenar el resultado en otro vector. Imprimir el vector original y el vector resultante.

Proceso EJERCICIO_4
Dimension W[500]
Para i<-1 Hasta 500 Hacer
Escribir "POR FAVOR DIGITE EL VALOR " i
Leer W[i]
FinPara
Escribir ""
Para k<-1 hasta 500 hacer
Escribir "EL DIGITO" k " QUE USTED INGRES ES: " W[k]
FinPara
Escribir ""
Dimension T[500]
Para j<-1 hasta 500 Hacer
T[j]<-(W[j])^2
Escribir "EL RESULTADO DEL DIGITO" j " ELEVADO AL
CUADRADO ES: " T[j]
FinPara
FinProceso

5) Almacenar 300 nmeros en un vector, imprimir cuantos son ceros, cuntos son negativos,
cuantos positivos. Imprimir adems la suma de los negativos y la suma de los positivos.

Proceso EJERCICIO_5
 Dimension num[300]
suma1<-0
suma2<-0
suma3<-0
suma4<-0
suma5<-0
Para x<-1 Hasta 300 Hacer
Escribir "ingrese el valor " x
Leer num[x]
si num[x]=0 Entonces
sum1<-sum1+1
Sino
si num[x]<0 Entonces
suma2<-suma2+1
suma3<-suma3+num[x]
Sino
suma4<-suma4+1
suma5<-suma5+num[x]
FinSi
FinSi
FinPara
Escribir ""
Escribir "CANTIDAD DE CEROS: " suma1
Escribir "CANTIDAD DE NEGATIVOS: " suma2
Escribir "CANTIDAD DE POSITIVOS: " suma3
Escribir ""
Escribir "SUMA DE NEGATIVOS: " suma4
Escribir "SUMA DE POSITIVOS: " suma5
FinProceso

6) Almacenar 150 nmeros en un vector, almacenarlos en otro vector en orden inverso al vector
original e imprimir el vector resultante.

Proceso EJERCICIO_6
Dimension x[150]
Para l<-1 Hasta 150 Hacer
Escribir "DIGITE EL VALOR POR FAVOR " l
Leer x[l]
FinPara
Dimension h[150]
 Para g<-150 Hasta 1 Con Paso -1 Hacer
h[g]<-x[g]
Escribir "EL VALOR QUE USTED INGRES: " h[g]
FinPara
FinProceso

7) Se tienen almacenados en la memoria dos vectores M y N de cien elementos cada uno. Hacer
un algoritmo que escriba la palabra Iguales si ambos vectores son iguales y Diferentes si no
lo son.
Sern iguales cuando en la misma posicin de ambos vectores se tenga el mismo valor para
todos los elementos.

Proceso EJERCICIO_7
Dimension M[100]
Dimension N[100]
Para x<-1 Hasta 100 Hacer
Escribir "DIGITE EL VALOR " x " DEL VECTOR M"
Leer M[x]
Escribir "DIGITE EL VALOR " x " DEL VECTOR N"
Leer N[x]
si M[x]=N[x] Entonces
Escribir "!SON IGUALES :)"
Sino
Escribir "SON DIFERENTES :("
FinSi
Escribir ""
FinPara
FinProceso

8) Se tiene el vector A con 100 elementos almacenados. Disee un algoritmo que escriba SI si el
vector esta ordenado ascendentemente o NO si el vector no est ordenado

Proceso EJERCICIO_8
Escribir "ALGORITMO"
Dimension x[100]
suma1<-0
suma2<-0
Escribir "DIGITE POR FAVOR EL PRIMER VALOR"
Leer x[1]
Para h<-2 Hasta 100 Hacer
Escribir "DIGITE EL VALOR " i
Leer x[h]
 si x[h]>x[h-1] Entonces
suma1<-suma1+1
Sino
suma2<-suma2+1
FinSi
FinPara
Escribir ""
si suma2=0 Entonces
Escribir "SI :)"
Sino
Escribir "NO :("
FinSi
FinProceso

9) Disee un algoritmo que lea un nmero cualquiera y lo busque en el vector X, el cual tiene
almacenados 80 elementos. Escribir la posicin donde se encuentra almacenado el nmero en el
vector o el mensaje NO si no lo encuentra. Bsqueda secuencial.

Proceso EJERCICIO_9
Escribir que inici la bsqueda :)
Dimension s[80]
busqueda<-0
Para i<-1 Hasta 80 Hacer
Escribir "POR FAVOR INGRESE EL VALOR " i
Leer s[i]
FinPara
Escribir ""
Escribir "CUL DATO DESEA BUSCAR EN EL VECTOR S?"
Leer dato
Escribir ""
suma<-0
Para j<-1 hasta 80 hacer
si dato=s[j] entonces
Escribir "POSICIN! " j
Sino
suma<-suma+1
FinSi
FinPara
si suma=80 Entonces
Escribir "NO :("
FinSi
FinProceso
10) Disee un algoritmo que lea dos vectores A y B de 20 elementos cada uno y multiplique el
primer elemento de A con el ltimo elemento de B y luego el segundo elemento de A por el
diecinueveavo elemento de B y as sucesivamente hasta llegar al veinteavo elemento de A por
el primer elemento de B. El resultado de la multiplicacin almacenarlo en un vector C.

Proceso EJERCICIO_10
//vector A=F
//vector B=E
//vector C=R
Dimension F[20]
Dimension E[20]
Dimension R[20]
Para i<-1 Hasta 20 Hacer
Escribir "DIGITE EL VALOR" i "DEL VECTOR F"
Leer F[i]
Escribir "DGITE EL VALOR " i "DEL VECTOR E"
Leer E[i]
Escribir ""
FinPara
Escribir ""
operacion<-20
para j<-1 hasta 20 hacer
R[j]<-F[j]*E[operacion]
Escribir "la multiplicacin de los vectores es de: " R[j]
operacion<-operacion-1
FinPara
FinProceso

11) Disee un algoritmo que almacene en un vector llamado FIB[100] los 100 primeros nmeros de
la serie fibonacci.

Proceso EJERCICIO_11
Dimension FIB[100]
num1<-0
num2<-1
Para x<-1 Hasta 100 Hacer
Escribir "El " i " NUMERO DE LA SUCESION ES " num2
num3<-num1+num2
num1<-num2
num2<-num3
FinPara
FinProceso
12) Desarrollar un algoritmo que permita almacenar la cedula y el nombre de 10 estudiantes. 2. El
usuario puede ingresar un numero de cedula a buscar en el vector y el algoritmo debe mostrar
el nombre que corresponde al nmero de documento ingresado, siempre y cuando haya sido
almacenado previamente.

Proceso EJERCICIO_12
Dimension date[10,2]
Escribir "INGRESE EN DATO 1:ESTUDIANTE Y EN DATO 2:N DE CDULA"
Para i<-1 Hasta 10 Hacer
Para j<-1 Hasta 2 Hacer
Escribir "INGRESAR DATO" j " DEL ESTUDIANTE " i
Leer date[i,j]
FinPara
Escribir ""
FinPara
Borrar Pantalla
Para i<-1 Hasta 10 Hacer
Para j<-1 Hasta 2 Hacer
Escribir "DATO " j " DEL ALUMNO " i ": " date[i,j]
FinPara
Escribir ""
FinPara
Escribir ""
Escribir "INGRESAR CDULA DEL ESTUDIANTE QUE USTED QUIERE"
Leer bus
Para k<-1 Hasta 10 Hacer
Para l<-1 Hasta 2 Hacer
si bus=date[k,l] Entonces
Escribir "LA CEDULA PERTENECE AL
ESTUDIANTE/ALUMNO " k
FinSi
FinPara
FinPara
FinProceso

EJERCICIOS MATRICES

1) Hacer un algoritmo que almacene nmeros en una matriz de 5 * 6. Imprimir la suma de los
nmeros almacenados en la matriz.

Proceso EJERCICIO_1
Dimension sumas[5,6]
suma1<-0
 Para k<-1 hasta 5 hacer
Para f<-1 hasta 6 hacer
Escribir "INGRESE EL DATO DE LA COLUMNA " f " Y FILA " k
Leer sumas[k,f]
suma1<-suma1+sumas[k,f]
FinPara
Escribir ""
FinPara
Escribir "LA SUMA ES:" suma
FinProceso

2) Hacer un algoritmo que llene una matriz de 10 * 10 y determine la posicin [rengln,columna]

del nmero mayor almacenado en la matriz. Los nmeros son diferentes.

Proceso EJERCICIO_2
Dimension valores[10,10]
mayorE<-0
Para i<-1 hasta 10 hacer
Para j<-1 hasta 10 hacer
Escribir "INGRESE DATO COLUMNA " j " Y FILA " i
Leer valores[i,j]
si valores[i,j]>mayorE entonces
mayorE<-valores[i,j]
Sino
mayorE<-mayorE
FinSi
FinPara
Escribir ""
FinPara
Para k<-1 hasta 10 hacer
Para l<-1 hasta 10 hacer
si mayorE=valores[k,l] Entonces
Escribir "VALOR ENCONTRADO EN LA COLUMNA " l "
Y LA FILA " k
FinSi
FinPara
FinPara
FinProceso

3) Hacer un algoritmo que llene una matriz de 7 * 7. Calcular la suma de cada rengln y
almacenarla en un vector, la suma de cada columna y almacenarla en otro vector.

Proceso EJERCICIO_3
Dimension X[7,7]
Para i<-1 Hasta 7 Hacer
Para j<-1 Hasta 7 Hacer
 Escribir "INGRESAR DATO COLUMNA " j " INGRESAR FILA " i
Leer X[i,j]
FinPara
Escribir ""
FinPara
sumaa<-0
sumab<-0
sumac<-0
sumad<-0
sumae<-0
sumaf<-0
sumag<-0
Para i<-1 hasta 7 hacer
suma<-0
sumb<-0
sumc<-0
sumd<-0
sume<-0
sumf<-0
sumg<-0
Para j<-1 hasta 7 hacer
suma<-suma+X[1,j]
sumb<-sumb+X[2,j]
sumc<-sumc+X[3,j]
sumd<-sumd+X[4,j]
sume<-sume+X[5,j]
sumf<-sumf+X[6,j]
sumg<-sumg+X[7,j]
FinPara
sumaa<-sumaa+X[i,1]
sumab<-sumab+X[i,2]
sumac<-sumac+X[i,3]
sumad<-sumad+X[i,4]
sumae<-sumae+X[i,5]
sumaf<-sumaf+X[i,6]
sumag<-sumag+X[i,7]
FinPara
Dimension F[7]
F[1]<-sumaa
F[2]<-sumab
F[3]<-sumac
F[4]<-sumad
F[5]<-sumae
 F[6]<-sumaf
F[7]<-sumag
Para k<-1 hasta 7 hacer
Escribir "SUMA COLUMNA " k "ES: " F[k]
FinPara
Escribir ""
Dimension R[7]
R[1]<-suma
R[2]<-sumb
R[3]<-sumc
R[4]<-sumd
R[5]<-sume
R[6]<-sumf
R[7]<-sumg
Para l<-1 Hasta 7 Hacer
Escribir "SUMA FILA " l " ES: " R[l]
FinPara
FinProceso

4) Hacer un algoritmo que llene una matriz de 20 * 20. Sumar las columnas e imprimir que
columna tuvo la mxima suma y la suma de esa columna.

Proceso EJERCICIO_4
Dimension F[20,20]
Para i<-1 Hasta 20 Hacer
Para j<-1 Hasta 20 Hacer
Escribir "INGRESAR DATO COLUMNA " j "FILA " i
Leer F[i,j]
FinPara
Escribir ""
FinPara
Para i<-1 hasta 20 hacer
suma1<-0
suma2<-0
suma3<-0
suma4<-0
suma5<-0
suma6<-0
suma7<-0
suma8<-0
suma9<-0
suma10<-0
suma11<-0
suma12<-0
 suma13<-0
suma14<-0
suma15<-0
suma16<-0
suma17<-0
suma18<-0
suma19<-0
suma20<-0
Para j<-1 hasta 20 hacer
suma1<-suma1+F[j,1]
suma2<-suma2+F[j,2]
suma3<-suma3+F[j,3]
suma4<-suma4+F[j,4]
suma5<-suma5+F[j,5]
suma6<-suma6+F[j,6]
suma7<-suma7+F[j,7]
suma8<-suma8+F[j,8]
suma9<-suma9+F[j,9]
suma10<-suma10+F[j,10]
suma11<-suma11+F[j,11]
suma12<-suma12+F[j,12]
suma13<-suma13+F[j,13]
suma14<-suma14+F[j,14]
suma15<-suma15+F[j,15]
suma16<-suma16+F[j,16]
suma17<-suma17+F[j,17]
suma18<-suma18+F[j,18]
suma19<-suma19+F[j,19]
suma20<-suma20+F[j,20]
FinPara
FinPara
Dimension E[20]
E[1]<-suma1
E[2]<-suma2
E[3]<-suma3
E[4]<-suma4
E[5]<-suma5
E[6]<-suma6
E[7]<-suma7
E[8]<-suma8
E[9]<-suma9
E[10]<-suma10
E[11]<-suma11
 E[12]<-suma12
E[13]<-suma13
E[14]<-suma14
E[15]<-suma15
E[16]<-suma16
E[17]<-suma17
E[18]<-suma18
E[19]<-suma19
E[20]<-suma20
mayor1<-0
Para k<-1 hasta 20 hacer
si E[k]>mayor1 entonces
mayor1<-E[k]
Sino
mayor1<-mayor1
FinSi
FinPara
Para l<-1 hasta 20 hacer
si mayor1=E[l] entonces
Escribir "SUMA MAYOR " l "ES: " E[l]
FinSi
FinPara
FinProceso

5) Hacer un algoritmo que llene una matriz de 5 * 5 y que almacene la diagonal principal en un
vector. Imprimir el vector resultante.

Proceso EJERCICIO_5
Dimension F[5,5]
Para i<-1 Hasta 5 Hacer
Para j<-1 Hasta 5 Hacer
Escribir "INGRESAR DATO COLUMNA " j " Y DATO FILA " i
Leer F[i,j]
FinPara
Escribir ""
FinPara
Dimension E[5]
E[1]<-F[1,1]
E[2]<-F[2,2]
E[3]<-F[3,3]
E[4]<-F[4,4]
E[5]<-F[5,5]
Escribir "DIAGONAL PRINCIPAL ES"
 Para k<-1 hasta 5 hacer
mostrar E[k]
FinPara
FinProceso

6) Hacer un algoritmo que llene una matriz de 10 * 10 y que almacene en la diagonal principal
unos y en las dems posiciones ceros.

Proceso EJERCICIO_6
dimension F[10,10]
Para i<-1 Hasta 10 Hacer
Para j<-1 Hasta 10 Hacer
Escribir "DATO COLUMNA " j " FILA " i
Leer F[i,j]
FinPara
Escribir ""
FinPara
F[1,1]<-F[1,1]/F[1,1] ; F[1,2]<-0/F[1,2] ; F[1,3]<-0/F[1,3] ; F[1,4]<-
0/F[1,4] ; F[1,5]<-0/F[1,5] ; F[1,6]<-0/F[1,6] ; F[1,7]<-0/F[1,7] ; F[1,8]<-0/F[1,8]
; F[1,9]<-0/F[1,9] ; ;
F[2,1]<-0/F[2,1] ; F[2,2]<-F[2,2]/F[2,2] ; F[2,3]<-0/F[2,3] ; F[2,4]<-
0/F[2,4] ; F[2,5]<-0/F[2,5] ; F[2,6]<-0/F[2,6] ; F[2,7]<-0/F[2,7] ; F[2,8]<-0/F[2,8]
; F[2,9]<-0/F[2,9] ; F[2,10]<-0/F[2,10] ;
F[3,1]<-0/F[3,1] ; F[3,2]<-0/F[3,2] ; F[3,3]<-F[3,3]/F[3,3] ; F[3,4]<-
0/F[3,4] ; F[3,5]<-0/F[3,5] ; F[3,6]<-0/F[3,6] ; F[3,7]<-0/F[3,7] ; F[3,8]<-0/F[3,8]
; F[3,9]<-0/F[3,9] ; F[3,10]<-0/F[3,10] ;
F[4,1]<-0/F[4,1] ; F[4,2]<-0/F[4,2] ; F[4,3]<-0/F[4,3] ; F[4,4]<-
F[4,4]/F[4,4] ; F[4,5]<-0/F[4,5] ; F[4,6]<-0/F[4,6] ; F[4,7]<-0/F[4,7] ; F[4,8]<-
0/F[4,8] ; F[4,9]<-0/F[4,9] ; F[4,10]<-0/F[4,10] ;
F[5,1]<-0/F[5,1] ; F[5,2]<-0/F[5,2] ; F[5,3]<-0/F[5,3] ; F[5,4]<-
0/F[5,4] ; F[5,5]<-F[5,5]/F[5,5] ; F[5,6]<-0/F[5,6] ; F[5,7]<-0/F[5,7] ; F[5,8]<-
0/F[5,8] ; F[5,9]<-0/F[5,9] ; F[5,10]<-0/F[5,10] ;
F[6,1]<-0/F[6,1] ; F[6,2]<-0/F[6,2] ; F[6,3]<-0/F[6,3] ; F[6,4]<-
0/F[6,4] ; F[6,5]<-0/F[6,5] ; F[6,6]<-F[6,6]/F[6,6] ; F[6,7]<-0/F[6,7] ; F[6,8]<-
0/F[6,8] ; F[6,9]<-0/F[6,9] ; F[6,10]<-0/F[6,10] ;
F[7,1]<-0/F[7,1] ; F[7,2]<-0/F[7,2] ; F[7,3]<-0/F[7,3] ; F[7,4]<-
0/F[7,4] ; F[7,5]<-0/F[7,5] ; F[7,6]<-0/F[7,6] ; F[7,7]<-F[7,7]/F[7,7] ; F[7,8]<-
0/F[7,8] ; F[7,9]<-0/F[7,9] ; F[7,10]<-0/F[7,10] ;
F[8,1]<-0/F[8,1] ; F[8,2]<-0/F[8,2] ; F[8,3]<-0/F[8,3] ; F[8,4]<-
0/F[8,4] ; F[8,5]<-0/F[8,5] ; F[8,6]<-0/F[8,6] ; F[8,7]<-0/F[8,7] ; F[8,8]<-
F[8,8]/F[8,8] ; F[8,9]<-0/F[8,9] ; F[8,10]<-0/F[8,10] ;
 F[9,1]<-0/F[9,1] ; F[9,2]<-0/F[9,2] ; F[9,3]<-0/F[9,3] ; F[9,4]<-
0/F[9,4] ; F[9,5]<-0/F[9,5] ; F[9,6]<-0/F[9,6] ; F[9,7]<-0/F[9,7] ; F[9,8]<-0/F[9,8]
; F[9,9]<-F[9,9]/F[9,9] ;F[9,10]<-0/F[9,10] ;
F[10,1]<-0/F[10,1] ; F[10,2]<-0/F[10,2] ; F[10,3]<-0/F[10,3] ;
F[10,4]<-0/F[10,4] ; F[10,5]<-0/F[10,5] ; F[10,6]<-0/F[10,6] ; F[10,7]<-0/F[10,7]
; F[10,8]<-0/F[10,8] ; F[10,9]<-0/F[10,9] ; F[10,10]<-F[10,10]/F[10,10] ;
Para k<-1 Hasta 10 Hacer
Para l<-1 Hasta 10 Hacer
Escribir F[k,l] "" sin bajar
FinPara
Escribir ""
FinPara
FinProceso

7) Hacer un algoritmo que llene una matriz de 6 * 8 y que almacene toda la matriz en un vector.
Imprimir el vector resultante.

Proceso EJERCICIO_7
Dimension F[6,8]
Para i<-1 Hasta 6 Hacer
Para j<-1 Hasta 8 Hacer
Escribir "INGRESE DATO COLUMNA" j " FILA " i
Leer F[i,j]
FinPara
Escribir ""
FinPara
Escribir "VECTOR:"
Dimension E[6*8]
aux<-1
Para k<-1 Hasta 8 Hacer
Para l<-1 Hasta 6 Hacer
E[aux]<-F[l,k]
Mostrar E[aux] " " sin bajar
aux<-aux+1
FinPara
FinPara
FinProceso

8) Hacer un algoritmo que llene una matriz de 8 * 8, que almacene la suma de los renglones y la
suma de las columnas en un vector. Imprimir el vector resultante.

Proceso EJERCICIO_8
Dimension F[8,8]
Para i<-1 Hasta 8 Hacer
Para j<-1 Hasta 8 Hacer
Escribir "INGRESAR DATOS " j " Y FILA " i
Leer F[i,j]
FinPara
Escribir ""
FinPara
sumaR<-0
Para x<-1 hasta 8 hacer
para T<-1 hasta 8 hacer
sumaR<-sumaR+F[T,x]
FinPara
finpara

finproceso