EJERCICIOS DE ARREGLOS
 
Mis aficiones nuevo
EL HOMBRE QUE CALCULABA ( resumen)
EJERCICIOS DE DECISION SIMPLE
BIENVENIDOS A CANDY_LUNA INFORMATIC
TEORIA DE INFORMATICA
TAREA SEIS
DEFINICION DE ALGORITMO
RESOLUCION DE PROBLEMAS
BIOGRAFIAS DE MATEMATICOS
EJERCICIOS SECUENCIALES
MANUAL DEL DFD
EJERCICIOS DE DECISION MULTIPLE
EJERCICIOS DE CICLOS
EJERCICIOS DE FUNCIONES
EJERCICIOS DE ARREGLOS
TAREA SIETE
TAREA UNO
TAREA TRES
Mis aficiones nuevo
PROGRAMACION ORIENTADA A OBJETOS
EJERCICIOS DE ARREGLOS

ARREGLOS



ARREGLOS (UNIDIMENSIONALES-BIDIMENCIONALES)


algo A1.1;
inicio
# define MAX 10
nulo generar (entero vector [ ],entero dim);
nulo visual (entero vector [ ]; entero dim);
Ppal
inicio
Entero vector [MAX];
generar (vect, MAX);
visual (vect, MAX);
final



Nulo generar(entero vector[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
Escriba ("Digite término en la posición %d: ",a);
lea (vector [a]);
final
final


Nulo visual(entero vector[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
Escriba ("El término %d es: %d" ,b, vector[b]);
final
final
algo A1.2;
inicio
# define MAX 10
nulo generar (entero vect[ ],entero dim);
nulo visual (entero vect[ ], entero dim);
entero sum (entero vect[ ], entero dim);
Ppal
inicio
Entero vect [MAX], suma;
generar (vect, MAX);
visual (vect, MAX);
suma=sum(vect, MAX);
imprima ("La suma del vector es: %d", suma);
final


Nulo generar(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
imprima("Digite término : %d",a);
lea (vector[a]);
final
final


Nulo visual(entero vect[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
imprima("El término %d es: %d" ,b, vect[b]);
final
entero sum(entero vect[ ], entero dim)
inicio
entero total=0, x;
Para (x=0; x < dim; x++)
total =total + vect[x];
devuelva(total);
final
final


algo A1.3;
inicio
# define DIME 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
real promedio(entero vect[ ], entero dim);
Ppal
inicio
Entero vect [DIME];
real prom;
generar (vect, DIME);
visual (vect, DIME);
prom=promedio (vect, DIME);
imprima ("El promedio del vector es: %f", prom);
final


Nulo generar(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
imprima("Digite término : %d",a);
lea (vector[a]);
final
final


Nulo visual(entero vect[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
imprima("El término %d es: %d" ,b, vect[b]);
final
real promedio(entero vect[ ], entero dim)
inicio
entero c, sum;
real prom;
Para (c=0; c < dim; c ++)
inicio
sum=Sum + vect[c];
final
prom=Sum/dim;
devuelva(prom);
final
final

algo A1.4;
inicio
# define par 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
real par(entero vect[ ], entero dim);
Ppal
inicio
Entero arr [par], sum;
generar (arr, par);
visual (arr, par);
sum=par (arr, par);
imprima ("Hay %d pares", sum);
final
Nulo generar(entero vect[ ],entero dim)
inicio
entero j;
Para (j=0; j < dim; j ++)
inicio
imprima("Digite %d término ",j);
lea (vector[j]);
final
final
Nulo visual(entero vect[ ],entero dim)
inicio
entero m;
Para (m=0; m < dim; m ++)
inicio
imprima("El %d término %d" ,m, vect[m]);
final
entero par(entero vect[ ], entero dim)
inicio
entero x, cont=0;
MQ (x%2 == 0)
cont ++;
devuelva(x);
final
final
algo A1.5;
inicio
# define impar 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
real impar(entero vect[ ], entero dim);
Ppal
inicio
Entero arr [impar], sum;
generar (arr, impar);
visual (arr, impar);
sum = impar (arr, impar);
imprima ("Hay %d impares", sum);
final
Nulo generar(entero vect[ ],entero dim)
inicio
entero i;
Para (i=0; i < dim; i ++)
inicio
imprima("Digite %d término ",i);
lea (vector[i]);
final
final
Nulo visual(entero vect[ ],entero dim)
inicio
entero y;
Para (y=0; y < dim; y ++)
inicio
imprima("El %d término %d" ,y, vect[y]);
final
entero impar(entero vect[ ], entero dim)
inicio
entero imp,sum;
MQ (imp %2 !=0)
sum ++;
final
devuelva(imp);
final


algo A1.6;
inicio
# define MAX 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
entero negativo (entero vect[ ], entero dim);
Ppal
inicio
Entero vect [MAX], neg;
generar(vect, MAX);
visual (vect, MAX);
ne=negativo (vect, MAX);
imprima ("La %d números negativos", neg);
final
Nulo generar(entero vect[ ],entero dim)
inicio
entero i;
Para (i=0; i < dim; i ++)
inicio
imprima("Digite término : %d",i);
lea (vector[i]);
final
final


Nulo visual(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
imprima("El término %d es: %d", a, vect[a]);
final
entero negativo (entero vect[ ], entero dim)
inicio
entero b, cont=0;
Para (b=0; b < dim; b ++)
si (vect[b] < 0) entonces
cont ++;
fsi
devuelva(cont);
final
final



algo A1.4.1;
inicio
# define MAX 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
entero negapar (entero vect[ ], entero dim);
Ppal
inicio
Entero vect [MAX], npar;
generar(vect, MAX);
visual (vect, MAX);
npar=negapar (vect, MAX);
imprima ("En el arreglo hay %d negativos pares", npar);
final


Nulo generar(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
imprima("Digite término : %d",a);
lea (vector[a]);
final
final


Nulo visual(entero vect[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
imprima("El término %d es: %d", b, vect[b]);
final
entero negapar (entero vect[ ], entero dim)
inicio
entero c, npar=0;
Para (c=0; c < dim; c ++)
inicio
si (vect[c] %2 == 0) entonces
npar ++;
fsi
final
devuelva (npar);
final
final


algo A.1.8;
inicio
# define MAX 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
entero suminter (entero vect[ ], entero dim);
Ppal
inicio
Entero vect [MAX], suma;
generar(vect, MAX);
visual (vect, MAX);
suma=Suminter (vect, MAX);
imprima ("La suma es: %d", suma);
final

Nulo generar(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
imprima("Digite término : %d",a);
lea (vector[a]);
final
final

Nulo visual(entero vect[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
imprima("El término %d es: %d", b, vect[b]);
final
entero suminter (entero vect[ ], entero dim)
inicio
entero c, suma=0;
Para (c=0; c < dim; c ++)
inicio
si (vect [c] >= 50 && vect [c] <= 100)
entonces
si (vect [c] %2 == 0) entonces
suma=suma+vect[c];
fsi
fsi
final
devuelva (suma);
final
final


algo A1.5.1;
inicio
# define MAX 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
entero suminter (entero vect[ ], entero dim);
Ppal
inicio
Entero vect [MAX], suma;
generar(vect, MAX);
visual (vect, MAX);
suma=suminter (vect, MAX);
imprima ("La suma es: %d", suma);
final


Nulo generar(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
imprima("Digite término : %d",a);
lea (vector[a]);
final
final

Nulo visual(entero vect[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
imprima("El término %d es: %d", b, vect[b]);
final
entero suminter (entero vect[ ], entero dim)
inicio
entero c, suma=0;
Para (c=0; c < dim; c ++)
inicio
si (vect [c] >= 50 && vect [c] <= 100) entonces
si (vect [c] %2!= 0) entonces
suma=suma+vect[c];
fsi
fsi
final
devuelva (suma);
final
final


algo A1.10;
inicio
# define MAX 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
entero mayor (entero vect[ ], entero dim);
Ppal
inicio
Entero vect [MAX], may;
generar(vect, MAX);
visual (vect, MAX);
may=mayor (vect, MAX);
imprima ("El numero mayor del arreglo es: %d", may);
final


Nulo generar(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
imprima("Digite término : %d",a);
lea (vector[a]);
final
final


Nulo visual(entero vect[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
imprima("El término %d es: %d", b, vect[b];
final
entero mayor (entero vect[ ], entero dim)
inicio
entero c, ma;
Para (c=1; c < dim; c ++)
inicio
si (vect [c] > ma) entonces
ma= vect [c];
fsi
final
devuelva (ma);
final
final


algo A1.11;
inicio
# define MAX 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
entero menor (entero vect[ ], entero dim);
Ppal
inicio
Entero vect [MAX], me;
generar(vect, MAX);
visual (vect, MAX);
me=menor (vect, MAX);
imprima ("El numero menor es: %d", me);
final


Nulo generar(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
imprima("Digite término : %d",a);
lea (vector[a]);
final
final


Nulo visual(entero vect[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
imprima("El término %d es: %d", b, vect[b];
final
entero mayor (entero vect[ ], entero dim)
inicio
entero c, me;
me=vect + [o]
Para (c=1; c < dim; c ++)
inicio
si (vect [c] > me) entonces
me= vect [c];
fsi
final
devuelva (me);
final
final


algo A1.13;
inicio
# define MAX 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
entero primo (entero vect[ ], entero dim);
Ppal
inicio
Entero vect [MAX], prim;
generar(vect, MAX);
visual (vect, MAX);
primo=primo (vect, MAX);
imprima ("En el vector hay: %d primos", prim);
final
Nulo generar(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
imprima("Digite término : %d",a);
lea (vector[a]);
final
final

Nulo visual(entero vect[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
imprima("El término %d es: %d", b, vect[b];
final
entero primo (entero vect[ ], entero dim)
inicio
entero pri,c,cont1,cont2;
Para (p=vect [c]; p > 0; p--)
inicio
si (vect [c] % p == 0) entonces
cont1++;
fsi
final
c ++;
si (cont1==2) entonces
cont2 ++;
fsi
devuelva (me);
final
final



algo A1.9;
inicio
# define MAX 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
entero sietes(entero vect[ ], entero dim);
Ppal
inicio
Entero vect [MAX], cin;
generar(vect, MAX);
visual (vect, MAX);
cin=cincos (vect, MAX);
imprima ("En el arreglo hay %d sietes", cin);
final
Nulo generar(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
imprima("Digite término : %d",a); lea (vector[a]);
final
final
Nulo visual(entero vect[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
imprima("El término %d es: %d", b, vect[b];
final
entero sietes (entero vect[ ], entero dim)
inicio
entero cont=1; cnc=0; x, di, re;
MQ (cont < = dim)
inicio
x=cont;
MQ (x>0)
inicio
di=x/10; re=x/10; x=di;
final
si (re ==7) entonces
cnc++;
fsi
cont ++;
final
devuelva (cnc);
final
final


algo A1.16;
inicio
# define MAX 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
entero sumayor (entero vect[ ], entero dim);
Ppal
inicio
Entero vect [MAX], sum;
generar(vect, MAX);
visual (vect, MAX);
sum=sumayor (vect, MAX);
imprima ("La suma %d es mayor que la suma %d", sum);
final
Nulo generar(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
imprima("Digite término : %d",a); lea (vector[a]);
final
final
Nulo visual(entero vect[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
imprima("El término %d es: %d", b, vect[b];
final
entero sumayor (entero vect[ ], entero dim)
inicio
entero f; supar; suimpar;
Para (f=0; f inicio
si (vect [f] %2 == 0) entonces
supar=supar + vect [f];
fsi
si (vect [f] %2 != 0) entonces
suimpar= suimpar + vect [f];
fsi
si (supar > suimpar) entonces
imprima ("La suma de los pares es mayor que la de los impares");
sino
imprima ("La suma de los impares es mayor que la de los pares");
fsi
final
final
final

algo A1.15;
inicio
# define MAX 10
nulo generar (entero vect [ ],entero dim);
nulo visual (entero vect [ ], entero dim);
entero perfecto (entero vect[ ], entero dim);
Ppal
inicio
Entero vect [MAX], perf;
generar(vect, MAX);
visual (vect, MAX);
perf=perfecto (vect, MAX);
imprima ("En el arreglo hay %d números perfectos", perf);
final
Nulo generar(entero vect[ ],entero dim)
inicio
entero a;
Para (a=0; a < dim; a ++)
inicio
imprima("Digite término : %d",a); lea (vector[a]);
final
final
Nulo visual(entero vect[ ],entero dim)
inicio
entero b;
Para (b=0; b < dim; b ++)
imprima("El término %d es: %d", b, vect[b];
final
entero perfecto (entero vect[ ], entero dim)
inicio
entero ñ; per; c=0, b;
Para (ñ=0; ñ inicio
Para (b=1; b< vect [ñ]; b ++)
inicio
si (vect [ñ] % b== 0) entonces
c= c+b;
fsi
final
si (c = = vect[ñ]) entonces
per ++;
fsi
final
devuelva (per);
final
final


algo A.2.1;
inicio
# define MAX 10
nulo generar (char vect [ ],entero dim);
nulo visual (char vect [ ], entero dim);
char reves (char vect[ ], entero dim);
Ppal
inicio
Char vect [MAX], rev;
generar(vect, MAX);
visual (vect, MAX);
rev=reves (vect, MAX);
imprima ("En el arreglo hay %d números al reves", rev);
final
Nulo generar(char vect[ ],entero dim)
inicio
entero o;
Para (o=0; o < dim; o ++)
inicio
imprima("Digite caracter %d",o); lea (vector[o]);
final
final
Nulo visual(char vect[ ],entero dim)
inicio


algo A.3.1;
inicio
# define MAX 10
nulo generar (entero arr [ ],entero dim);
nulo visual (entero arr [ ], entero dim);
nulo burbuja (entero arr[ ], entero dim);
Ppal
inicio
Entero (vect [MAX);
generar(vect, MAX);
visual (vect, MAX);
burbuja(vect, MAX);
visual (arr, MAX);
final
Nulo generar(entero vect[ ],entero dim)
inicio
entero i;
Para (i=0; i < dim; i ++)
inicio
imprima("Digite %d término:",i); lea (vector[i]);
final
final
Nulo visual(entero vect[ ],entero dim)
inicio
entero w;
Para(w=0; w imprima ("Término %d= %d",w,vect [w]);
final
Nulo burbuja (entero vect [ ], entero dim)
inicio
entero i,j,t;
Para(i=0; i < dim-1; i ++)
inicio
Para(j = i + 1; j < dim; j ++)
inicio
si(arr [i] > arr[j]) entonces
inicio
t= arr[i];
arr[i]= arr[j];
arr[j]=t;
final
fsi
final
final
final
final


algo A.3.2;
inicio
# define DIMA 10
nulo generar (entero arr [ ],entero dim);
nulo visual (entero arr [ ], entero dim);
entero impar (entero arr[ ], entero dim);
Ppal
inicio
Entero vect [DIMA], valor;
generar(vect, DIMA);
visual (vect, DIMA);
valor = impar (vect, DIMA);
imprima ("en el vector hay %d impares", valor);
ppal
inicio

final
Nulo generar(entero vect[ ],entero dim)
inicio
entero i;
Para (i=0; i < dim; i ++)
inicio
imprima("Digite %d término:",i); lea (vector[i]);
final
final
Nulo visual(entero vect[ ],entero dim)
inicio
entero w;
Para(w=0; w imprima ("Término %d= %d",w,vect [w]);
final
Nulo burbuja (entero vect [ ], entero dim)
inicio
entero i,j,t;
Para(i=0; i < dim-1; i ++)
inicio
Para(j = i + 1; j < dim; j ++)
inicio
si(arr [i] > arr[j]) entonces
inicio
t= arr[i];
arr[i] = arr[j];
arr[j] = t;
final
fsi
final
final
final
final


algo A.3.6;
inicio
# define MAX 10
nulo generar (entero arr [ ],entero dim);
nulo visual (entero arr [ ], entero dim);
entero ordenar (entero arr[ ], entero dim);
entero bisbin (entero arr[ ], entero dim);
Ppal
inicio
Entero vect [MAX], num, res;
generar(vect, MAX);
visual (vect, MAX);
ordenar (vect, MAX);
imprima ("digite numero a buscar:"); lea (num);
res= busbin (vect, MAX, num);
si (res != (-1)) entonces
imprima ("el numero %d esta en la posición %d", num, res);
sino
imprima ("el numero %d no esta en la posición %d", num);
fsi
final
Nulo generar(entero arr[ ], entero dim)
inicio
entero w;
Para (w=0; w < dim; w ++)
inicio
imprima("Digite %d término:",w); lea (vector[w]);
final
final
Nulo visual(entero arr[ ], entero dim)
inicio
entero v;
Para(v=0; v imprima ("Término %d= %d",v,vect [v]);
final
Nulo ordenar (entero arr [ ], entero dim)
inicio
entero x, y, z;
Para(x=0; x < dim-1; x ++)
inicio
Para(y = i + 1; y < dim; y ++)
inicio
si(arr [x] > arr[y]) entonces
z= arr[x];
arr[x] = arr [y];

arr[y] = z;
fsi
final
final
final






entero busbin (entero arr[ ], entero dim)
inicio
entero izq, der, mit;
izq=0; der=dim-1; mit > (izq + der)/2;
MQ (izq < = der && arr[mit] != n)
inicio
si (n > arr[mit]) entonces
izq= mit + 1;
sino
der= mit - 1;
fsi
mit= (izq + der)/2;
final
si (arr[mit] == n) entonces
devuelva (mit);
sino
devuelva (-1);
fsi
final
final


algo A.4.1;
inicio
# define DIMA 3
nulo generar (entero MAT [DIMA] [DIMA]);
nulo visual (entero MAT [DIMA] [DIMA]);
entero sumadiag (entero MAT [DIMA] [DIMA]);
Ppal
inicio
Entero matriz [DIMA] [DIMA], res;
generar(matriz);
visual (matriz);
res= sum (matriz);
imprima ("La suma de las diagonales es %d", res);
final
Nulo generar(entero MAT [DIMA] [DIMA])
inicio
entero i, j;
Para (i=0; i < DIMA; i ++)
inicio
Para (j=0; j inicio
imprima ("Digite numero",); lea (MAT [i] [j]);
final
final
final
Nulo visual(entero MAT [DIMA] [DIMA])
inicio
entero i, j;
Para (i=0; i < DIMA; i++)
Para (j=0; j < DIMA; j ++)
imprima("El término [%d] [%d] = %d, i, j, MAT [i] [j]);
final
entero sumadiag (entero MAT [DIMA] [DIMA])
inicio
entero ds, dp, sds, i, j;
ds=0; dp=0;
para (i=0; i< dima; i ++)
Para (j=0; j< dima; j ++)
inicio
si (i == j) entonces
dp= dp + MAT [i] [j];
fsi
si ((i + j) = = (dima - 1)) entonces
ds= ds + mat [i] [j];
fsi
sds= dp+ds;
final
devuelva (sds);
final





algo A.1.3;
inicio
# define DIMA 3
nulo generar (entero MAT [DIMA] [DIMA]);
nulo visual (entero MAT [DIMA] [DIMA]);
real promedio (entero MAT [DIMA] [DIMA]);
Ppal
inicio
Entero matriz [DIMA] [DIMA], feroz;
generar(matriz);
visual (matriz);
feroz= promedio (matriz);
imprima ("El promedio es %f", feroz);
final
Nulo generar(entero MAT [DIMA] [DIMA])
inicio
entero i, j;
Para (i=0; i < DIMA; i ++)
inicio
Para (j=0; j inicio
imprima ("Digite numero",); lea (MAT [i] [j]);
final
final
final
Nulo visual(entero MAT [DIMA] [DIMA])
inicio
entero i, j;
Para (i=0; i < DIMA; i++)
Para (j=0; j < DIMA; j ++)
imprima("El término [%d] [%d] = %d, i, j, MAT [i] [j]);
final
real promedio (entero MAT [DIMA] [DIMA])
inicio
real i, j, sum, sm, d;
i=0; j=0; sum=0; d=3*3;
MQ (i < DIMA)
inicio
MQ (j < DIMA)
inicio
sum=sum + MAT [i] [j];
j ++;
final
i ++; j=0;
final
sm= sum/d;
final
devuelva (sm);
final



algo A.1.13;
inicio
# define DIMA 3
nulo generar (entero MAT [DIMA] [DIMA]);
nulo visual (entero MAT [DIMA] [DIMA]);
entero primo (entero MAT [DIMA] [DIMA]);
Ppal
inicio
Entero matriz [DIMA] [DIMA], loco;
generar(matriz);
visual (matriz);
loco= primo (matriz);
imprima ("hay %d números primos", feroz);
final
Nulo generar(entero MAT [DIMA] [DIMA])
inicio
entero i, j;
Para (i=0; i < DIMA; i ++)
inicio
Para (j=0; j inicio
imprima ("Digite numero",); lea (MAT [i] [j]);
final
final
final
Nulo visual(entero MAT [DIMA] [DIMA])
inicio
entero i, j;
Para (i=0; i < DIMA; i++)
Para (j=0; j < DIMA; j ++)
imprima("término [%d] [%d] = %d, i, j, MAT [i] [j]);
final
entero primo (entero MAT [DIMA] [DIMA])
inicio
real i, j, cont, pri, x, y;
i=0; j=0; pri=0; cont=0;
MQ (i < DIMA)
inicio
MQ (j < DIMA)
inicio
y= MAT[i] [j]; x=Y;
MQ (y > 0)
inicio
si (x % y == 0) entonces
cont ++;
fsi
y --;
final
si (cont == 2) entonces
pri ++;
fsi
final
j ++;
final
i ++;
j=0;

final
devuelva (MAT[i] [j]);
final


algo A.4.12;
inicio
# define DIMA 3
nulo generar (entero MAT[DIMA ] [DIMA]);
nulo visual (entero MAT[DIMA] [DIMA]);
entero seis (entero MAT[DIMA] [DIMA]);
Ppal
inicio
Entero matriz [DIMA] [DIMA] comodin;
generar(matriz);
visual (matriz);
comodin = seis (matriz);
imprima ("hay %d números 6", comodin);
final
Nulo generar(entero MAT[DIMA] [DIMA])
inicio
entero i, j;
Para (i=0; i < DIMA; i ++)
inicio
Para (j=0; j < DIMA; j ++)
inicio
imprima("Digite número:",i);
lea (MAT[i] [j);
final
final
final

Nulo visual(entero MAT[DIMA] [DIMA])
inicio
entero i, j;
Para(i=0; i < DIMA; i ++)
imprima ("Término %d= %d",w,vect [w]);
final
Nulo burbuja (entero vect [ ], entero dim)
inicio
entero i, j;
Para(i=0; i < DIMA; i ++)
Para(j = i + 1; j < DIMA; j ++)
imprima ("término [%d] [%d] = %d," i, j, MAT [i] [j]);
final
entero seis (entero MAT[DIMA] [DIMA])
inicio
entero i, j, cont, cns, y, di, re;
i=0;
j=0;
cont=1;
cns=0;
MQ (i < DIMA)
inicio



MQ (j < DIMA)
inicio
MQ (cont < = (DIMA*DIMA));
inicio
y= MAT[i] [j];
si (y > 0) entonces
di= y/10;
re= y/10;
si (re == 6) entonces
cns ++;
fsi
y=di;
sino
cont ++;
fsi
final
j ++;
final
i ++;
j=0;
final
devuelva (MAT[i] [j]);
final
final















Imagen