Programacion

UNIVERSIDAD TÉCNICA DE AMBATO

FACULTAD CIENCIAS HUMANAS Y DE

LA EDUCACIÓN

CARRERA DE: DOCENCIA EN INFORMÁTICA Y COMPUTACIÓN

NOMBRE: CRISTIAN CRUZ

“PROGRAMACION”

Indicé Matrices y vectores ...................................................................................................................................... 4

Definición de matriz ..................................................................................................................................... 6

Arreglos de Varias Dimensiones ................................................................................................................. 10

................................................................................................................................................ 13 Elemento 2

EJERCICIOS (VECTORES) ............................................................................................................................ 13

Consonantes .............................................................................................................................................. 13

Análisis ......................................................................................................................................................... 13

Codificación .................................................................................................................................................. 14

Corrido ......................................................................................................................................................... 15

Cadena de caracteres ................................................................................................................................. 16

Análisis ......................................................................................................................................................... 16

Codificación .................................................................................................................................................. 17

Corrido ......................................................................................................................................................... 18

Cadena de caracteres (Vocales) ................................................................................................................. 19

Análisis ......................................................................................................................................................... 19

Codificado .................................................................................................................................................... 20

Corrido ......................................................................................................................................................... 22

MATRICES ..................................................................................................................................... 23

Posiciones pares de la matriz ..................................................................................................................... 23

Análisis ......................................................................................................................................................... 23

Codificación .................................................................................................................................................. 24

Corrido ......................................................................................................................................................... 26

MATRIZ CON PRIMOS ............................................................................................................... 27

ANALISIS ....................................................................................................................................................... 27

Codification .................................................................................................................................................. 27

Corrido ......................................................................................................................................................... 31

Fibonacci y factorial .................................................................................................................................. 32

Análisis ......................................................................................................................................................... 32

Codificado .................................................................................................................................................... 33

Corrido ......................................................................................................................................................... 37

MATRIZ DE UN FACTOR ........................................................................................................... 38

Análisis ......................................................................................................................................................... 38

Codificado .................................................................................................................................................... 39

Corrido ......................................................................................................................................................... 41

Matriz con validación ................................................................................................................................. 42

Análisis ......................................................................................................................................................... 42

Codificación .................................................................................................................................................. 43

Corrido. ........................................................................................................................................................ 45

MATRIZ CON EL FIBONACCI Y EL FACTORIAL .................................................................. 46

ANALISIS ....................................................................................................................................................... 46

Codificado .................................................................................................................................................... 47

Corrido ......................................................................................................................................................... 51

ORDENAR LA MATRIZ .............................................................................................................. 52

Codificado .................................................................................................................................................... 52

ANALISIS ....................................................................................................................................................... 52

Corrido ......................................................................................................................................................... 56

PRODUCTO DE UNA MATRIZ ................................................................................................. 57

Codificado .................................................................................................................................................... 57

ANALISIS ....................................................................................................................................................... 57

Corrido ......................................................................................................................................................... 61

Matriz Transpuesta .................................................................................................................................... 62

Análisis ......................................................................................................................................................... 62

Codificación .................................................................................................................................................. 63

Corrido ......................................................................................................................................................... 65

Impares de un matriz ................................................................................................................................. 66

Análisis ......................................................................................................................................................... 66

Codificación .................................................................................................................................................. 67

Corrido ......................................................................................................................................................... 70

Menú de opciones ..................................................................................................................................... 71

De vocales y consonantes .......................................................................................................................... 71

Análisis ......................................................................................................................................................... 71

Codificación .................................................................................................................................................. 73

Corrido ......................................................................................................................................................... 78

Matrices y vectores

En programación, una matriz o vector (llamados en inglés arrays) es una zona de almacenamiento

continuo, que contiene una serie de elementos del mismo tipo, los elementos de la matriz. Desde

el punto de vista lógico una matriz se puede ver como un conjunto de elementos ordenados en fila

(o filas y columnas si tuviera dos dimensiones).

En principio, se puede considerar que todas las matrices son de una dimensión, la dimensión

principal, pero los elementos de dicha fila pueden ser a su vez matrices (un proceso que puede ser

recursivo), lo que nos permite hablar de la existencia de matrices multidimensionales, aunque las

más fáciles de imaginar son los de una, dos y tres dimensiones.

Estas estructuras de datos son adecuadas para situaciones en las que el acceso a los datos se

realice de forma aleatoria e impredecible. Por el contrario, si los elementos pueden estar

ordenados y se va a utilizar acceso secuencial sería más adecuado utilizar una lista, ya que esta

estructura puede cambiar de tamaño fácilmente durante la ejecución de un programa.

Vectores dinámicos y estáticos

Lo habitual es que un vector tenga una cantidad fija de memoria asignada, aunque dependiendo

del tipo de vector y del lenguaje de programación un vector podría tener una cantidad variable de

datos. En este caso, se les denomina vectores dinámicos, en oposición, a los vectores con una

cantidad fija de memoria asignada se los denomina vectores estáticos.

El uso de vectores dinámicos requiere realizar una apropiada gestión de memoria dinámica. Un

uso incorrecto de los vectores dinámicos, o mejor dicho, una mala gestión de la memoria

dinámica, puede conducir a una fuga de memoria. Al utilizar vectores dinámicos siempre habrá

que liberar la memoria utilizada cuando ésta ya no se vaya a seguir utilizando.

Lenguajes más modernos y de más alto nivel, cuentan con un mecanismo denominado recolector

de basura (como es el caso de Java) que permiten que el programa decida si debe liberar el

espacio basándose en si se va a utilizar en el futuro o no un determinado objeto.

Vectores multidimensionales

En Basic, Java y otros lenguajes es posible declarar matrices multidimensionales, entendiéndolas

como un vector de vectores. En dichos casos en número de elementos del vector es el producto

resultante de cada dimensión.

Por ejemplo el vector v(4,1) tiene 10 elementos se calcula del siguiente modo: (0-4) * (0-1). Los

elementos de la primera dimensión del vector contiene 5 elementos que van del '0' al '4' y la 2º

dimensión tiene 2 elementos que van desde '0' a '1'. Los elementos serían accedidos del siguiente

modo:

elemento 1: (0,0)

elemento 2: (0,1)

elemento 3: (1,0)

...

elemento 8: (3,1)

elemento 9: (4,0)

elemento 10: (4,1)

Las matrices aparecen por primera vez hacia el año 1850, introducidas por J.J. Sylvester. El

desarrollo inicial de la teoría se debe al matemático W.R. Hamilton en 1853. En 1858, A. Cayley

introduce la notación matricial como una forma abreviada de escribir un sistema de m ecuaciones

lineales con n incógnitas.

Las matrices se utilizan en el cálculo numérico, en la resolución de sistemas de ecuaciones lineales,

de las ecuaciones diferenciales y de las derivadas parciales. Además de su utilidad para el estudio

de sistemas de ecuaciones lineales, las matrices aparecen de forma natural en geometría,

estadística, economía, informática, física, etc...

La utilización de matrices (arrays) constituye actualmente una parte esencial dn los lenguajes de

programación, ya que la mayoría de los datos se introducen en los ordenadores como tablas

organizadas en filas y columnas: hojas de cálculo, bases de datos.

Definición de matriz

Se llama matriz de orden m×n a todo conjunto rectangular de elementos aij dispuestos en m líneas

horizontales (filas) y n verticales (columnas) de la forma:

Abreviadamente suele expresarse en la forma A =(aij), con i =1, 2, ..., m, j =1, 2, ..., n. Los subíndices indican

la posición del elemento dentro de la matriz, el primero denota la fila (i) y el segundo la columna (j). Por

ejemplo el elemento a25 será el elemento de la fila 2 y columna 5.

Dos matrices son iguales cuando tienen la misma dimensión y los elementos que ocupan el mismo lugar en

ambas son iguales.

Algunos tipos de matrices

Vamos a describir algunos tipos de matrices que aparecen con frecuencia debido a su utilidad, y de los que es conveniente recordar su nombre.

Atendiendo a la forma

Matriz fila: Es una matriz que solo tiene una fila, es decir m =1 y por tanto es de orden 1´n.

Ejemplo

Matriz columna: Es una matriz que solo tiene una columna, es decir, n =1 y por tanto es de orden m ´1.

Ejemplo

Matriz cuadrada: Es aquella que tiene el mismo número de filas que de columnas, es decir m = n. En estos casos se dice que la matriz cuadrada es de orden n, y no n ´ n.

Los elementos aij con i = j, o sea aii forman la llamada diagonal principal de la matriz cuadrada, y los elementos aij con i + j = n +1 la diagonal secundaria.

Ejemplo

Matriz traspuesta: Dada una matriz A, se llama traspuesta de A, y se representa por At, a la matriz que se obtiene cambiando filas por columnas. La primera fila de A es la primera fila de At , la segunda fila de A es la segunda columna de At, etc.

De la definición se deduce que si A es de orden m ´ n, entonces At es de orden n ´ m.

Ejemplo

Matriz simétrica: Una matriz cuadrada A es simétrica si A = At, es decir, si aij = aji " i, j.

Ejemplos

Matriz anti simétrica: Una matriz cuadrada es anti simétrica si A = –At, es decir, si aij = –aji " i, j.

Ejemplos

Atendiendo a los elementos

Matriz nula es aquella que todos sus elementos son 0 y se representa por 0.

Ejemplos

Matriz diagonal: Es una matriz cuadrada, en la que todos los elementos no pertenecientes a la diagonal principal son nulos.

Ejemplos

Matriz escalar: Es una matriz diagonal con todos los elementos de la diagonal iguales.

Ejemplos

Matriz unidad o identidad: Es una matriz escalar con los elementos de la diagonal principal iguales a 1.

Ejemplos

Matriz Triangular: Es una matriz cuadrada que tiene nulos todos los elementos que están a un mismo lado de la diagonal principal. Las matrices triangulares pueden ser de dos tipos:

Triangular Superior: Si los elementos que están por debajo de la diagonal principal son todos nulos. Es decir, aij =0 " i<j.

Triangular Inferior: Si los elementos que están por encima de la diagonal principal son todos nulos. Es decir, aij =0 "j<i.

Un array en PHP es realmente un mapa ordenado. Un mapa es un tipo de datos que asocia valores

con claves. Este tipo es optimizado para varios usos diferentes; puede ser usado como una matriz

real, una lista (vector), una tabla asociativa (una implementación de un mapa), diccionario,

colección, pila, cola, y posiblemente más. Ya que los valores de un array pueden ser otros arrays,

árboles y también son posibles arrays multidimensionales.

Una explicación sobre tales estructuras de datos está fuera del alcance de este manual, pero

encontrará al menos un ejemplo de cada uno de ellos. Para más información, consulte la extensa

literatura que existe sobre este amplio tema.

La clave puede ser un integer o un string. El valor puede ser de cualquier tipo.

Además, los siguientes moldeados de tipo en la clave producirán:

• Strings que contienen integers válidos serán moldeados a el tipo integer. P.e.j. la clave "8"

en realidad será almacenada como 8. Por otro lado "08" no será convertido, ya que no es un

número integer decimal válido.

• Floats también serán moldeados en integers, lo que significa que la parte fraccionaria se

elimina. P.e.j. la clave 8.7 en realidad será almacenada como 8.

• Bools son moldeados a integers, también, p.e.j. la clave true en realidad será almacenada

como 1 y la clave false como 0.

• Null será moldeado a un string vacío, p.e.j. la clave null en realidad será almacenada como

"".

• Arrays y objects no pueden ser usados como claves. Si lo hace, dará lugar a una

advertencia: Illegal offset type.

Si varios elementos en la declaración del array usan la misma clave, sólo la última será usada y los

demás son sobrescritos.

Arreglos de Varias Dimensiones

Existen conjuntos de datos que por su naturaleza son mejor representados mediante tablas o

matrices multidimensionales que por vectores.

Por ejemplo, se puede representar las calificaciones de 4 asignaturas cursadas por 6 estudiantes

mediante una tabla como la que abajo se ilustra:

Columna 1 Columna 2 Columna 3 Columna 4

Fila 1

Fila 2

Fila 3

Fila 4

Fila 5

Fila 6

donde cada fila correspondería a un estudiante y cada columna a una asignatura. Cada dato

individual (la calificación de un estudiante en una asignatura dada) es un elemento de esta tabla y

ocupa una celda identificable por el número de la fila y el número de la columna.

Columna 1 Columna 2 Columna 3 Columna 4

Fila 1 M(1,1) M(1,2) M(1,3) M(1,4)

Fila 2 M(2,1) M(2,2) M(2,3) M(2,4)

Fila 3 M(3,1) M(3,2) M(3,3) M(3,4)

Fila 4 M(4,1) M(4,2) M(4,3) M(4,4)

Fila 5 M(5,1) M(5,2) M(5,3) M(5,4)

Fila 6 M(6,1) M(6,2) M(6,3) M(6,4)

De esta manera, cada elemento de la tabla queda completamente identificado mediante dos

subíndices: el primero para identificar la fila y el segundo para identificar la columna.

M( i , j )

Cada elemento de la matriz representaría la calificación de un estudiante dado en una asignatura

dada. Por ejemplo:

M(4,2) = C

Significa que el estudiante número 4 obtuvo C en la asignatura 2. La posición del elemento dentro

de la matriz corresponde a la celda sombreada en la tabla de la figura de arriba.

La matriz de arriba representa un arreglo bidimensional con (6x4) 24 elementos, donde

i = 1, 2, 3,...,6

j = 1, 2, 3, 4

En una matriz multidimensional cada dimensión tiene su propio rango.

Con frecuencia se manejan arreglos de más de dos dimensiones, correspondiendo un subíndice a

cada dimensión.

El programador debe tener presente que la memoria de las computadoras es lineal, por lo que la

mayoría de los compiladores almacenan en memoria los elementos de una matriz lineal izándola

por filas; es decir, todos los elementos de la primera fila primero, los de la segunda después y así

sucesivamente.

En programación, una matriz o vector (llamados en inglés arrays) es una zona de almacenamiento

continuo, que contiene una serie de elementos del mismo tipo, los elementos de la matriz. Desde

el punto de vista lógico una matriz se puede ver como un conjunto de elementos ordenados en fila

(o filas y columnas si tuviera dos dimensiones).

En principio, se puede considerar que todas las matrices son de una dimensión, la dimensión

principal, pero los elementos de dicha fila pueden ser a su vez matrices (un proceso que puede ser

recursivo), lo que nos permite hablar de la existencia de matrices multidimensionales, aunque las

más fáciles de imaginar son los de una, dos y tres dimensiones.

Estas estructuras de datos son adecuadas para situaciones en las que el acceso a los datos se

realice de forma aleatoria e impredecible. Por el contrario, si los elementos pueden estar

ordenados y se va a utilizar acceso secuencial sería más adecuado utilizar una lista, ya que esta

estructura puede cambiar de tamaño fácilmente durante la ejecución de un programa.

EJERCICIOS (VECTORES)

Consonantes

Realice un programa que me permita generar una cadena de caracteres utilizando vectores,

donde se ingresa una palabra y se imprime sus consonantes.

Aná lisis

Primero colocamos las librerías que necesitamos, después declaramos las variables globales para

el desarrollo del programa. Seguido hacemos una función que la llamaremos borde para realizar

el margen de nuestro programa.

Ingresamos títulos que nos sirvan para la identificación de nuestros ingresos y del programa, en el

char declaramos los vectores por que son letras las que vamos ingresar para que se busquen las

consonantes, utilizando un for para recorrer el vector para hacer el proceso de verificación y

ordenamiento.

Al final utilizamos otro for para recorrer el nuevo vector e imprimirlo.

Realizamos la opción de continuar o finalizar y cerramos el programa verificando si no hay errores

en nuestro programa.

Elemento 2

Codificácio n

# include<stdio.h>

# include<conio.h>

# include<string.h>

void main()

{

int aux,i,j,fil,col,lim,cont;

char vector[15],vector2[15];

clrscr();

flushall();

gotoxy(5,6);printf("INGRESE UNA CADENA");

gotoxy(5,8);gets(vector);

lim=strlen(vector);

fil=10;

col=10;

cont=0;

for(i=0;i<lim;i++)

{

if(vector[i]!='a' && vector[i]!='e' && vector[i]!='i' && vector[i]!='o' && vector[i]!='u')

{

vector2[cont]=vector[i];

cont++;

}

}

for(i=0;i<cont;i++)

{

gotoxy(col,fil);printf("%c",vector2[i]);

fil=fil+1;

}

getch();

}

Corrido

Cadena de caracteres

Realice un programa con funciones que me permita realizar una cadena de caracteres donde se

imprima la cadena en forma ascendente y descendente.

Aná lisis

Para este programa primero ingresamos las librerías que vamos a utilizar, seguido ingresamos la

variable que vamos a utilizar en el programa, asemos una función llamada BORDE para nuestro

margen del programa con el proceso enseñado.

Después hacemos el programa principal donde ingresamos los vectores en un char así mismo

ingresamos títulos en nuestro programa para ver que se realiza , después utilizamos un for para

recorrer el vector y poder imprimir primero en forma ascendente y lo imprimimos.

Para imprimir el vector en forma descendente utilizamos otro for donde i es igual a limite y va

excrementando hasta llegar a 0 así se imprimirá en esa forma.

Finalizamos con la opción de continuar o no y cerramos el programa verificando que no exista

errores.

Codificácio n

# include<stdio.h>

# include<conio.h>

void borde()

{

int j,i;

for(i=1;i<80;i++)

{

gotoxy(i,1);printf("*");


}

for(i=1;i<24;i++)

{

gotoxy(1,i);printf("*");


}

}

void main()

{

int i,limite,fila;

char nombre[15];

clrscr();

borde();

gotoxy(9,3);printf("C A D E N A D E C A R A C T E R E S");

gotoxy(9,9);printf("Ingrese una cadena=>");

gotoxy(10,35);gets(nombre);

limite=strlen(nombre);

fila=13;

for(i=limite;i>=0;i--)

{

gotoxy(10,fila);printf("%c",nombre[i]);

fila=fila+1;

}

getch();

}

Corrido

Cadena de caracteres (Vocales)

Diseñe un programa que me permita leer una cadena de caracteres y encontrar todas aquellas que

sean consonantes ,pasarlos a un nuevo vector y presentarlos en forma ordenada..

Aná lisis

Primero ingresamos las librerías principales, después realizamos una función llamada borde para

el margen de nuestro programa.

Realizamos el programa principal para realizar el proceso de nuestro programa donde ingresamos

las variables que vamos a utilizar y los vectores también ingresamos pero un char, ingresamos

títulos y el ingreso de la cadena mediante el vector. Colocamos un for para recorrer el vector y

mediante if preguntaremos si el vector es igual alas 5 vocales (un if para cada vocal), donde cada

pregunta que realizamos si es verdadera tenemos que pasar a otro vector

Al final utilizamos otro for para recorrer el nuevo vector e imprimirlo.

Realizamos la opción de continuar o finalizar y cerramos el programa verificando si no hay errores

en nuestro programa.

Codificádo

# include<stdio.h>

# include<conio.h>

# include<string.h>

void main()

{

int aux,i,j,fil,col,lim,cont;


clrscr();

flushall();

gotoxy(5,6);printf("INGRESE UNA CADENA");

gotoxy(5,8);gets(vector);

lim=strlen(vector);

fil=10;

col=10;

cont=0;

for(i=0;i<lim;i++)

{

if(vector[i]=='a')

{


cont++;

}

if(vector[i]=='e')

{


cont++;

}

if(vector[i]=='i')

{


cont++;

}

if(vector[i]=='o')

{


cont++;

}

if(vector[i]=='u')

{


cont++;

}

}

for(i=0;i<cont;i++)

{

for(j=0;j<cont;j++)

{

if(vector2[j]<vector[i])

{

aux=vector2[i];

vector2[i]=vector[j];

vector[j]=aux;

}

}

}

for(i=0;i<cont;i++)

{


fil=fil+1;

}

getch();

}

Corrido

MATRICES

Posiciones pares de la matriz

Realice un programa con funciones que me permita encontrar las posiciones

pares de la matriz, y guárdelas en un vector.

Aná lisis

Primero elaboro las librerías que voy a utilizar, seguido creo funciones

como el borde para elaborar el margen de nuestro programa.

Después creo otra función llamado factor donde programamos para generar

el factor de la matriz según el limite deseado, para ello vamos a necesitar

declarar variables ya sean globales o dentro de cada función, necesitaremos

dos for para crear la matriz y elaborar el factor en la misma.

Cuando ya hemos ingresado la matriz o generado, debemos crear otra

función donde recorreremos la matriz y buscaremos las posiciones pares,

donde al igual necesitaremos 2 for y usaremos if para preguntar cada ve que

i y j estén o sean pares para que imprima la matriz.

Una vez hecho todo esto debemos hacer el programa principal donde

llamaremos a todas las funciones y crearemos títulos e ingresos de limite y la

repetición n veces del programa y listo.

Verificaremos que nuestro programa este correctamente sin errores y

mandamos a correr.

Codificácio n

#include<string.h>

#include<conio.h>

#include<stdio.h>

int matriz[10][10],vector[10],fact,limite,a,b,col,fil,i,j,op,cont;

void borde()

{

for(i=1;i<=80;i++)

{



}

for(i=1;i<=24;i++)

{



}

}

void factor()

{

col=10;

fil=10;

a=0;

b=1;

for(i=1;i<=limite;i++)

{

for(j=1;j<=limite;j++)

{

a=fact*b;

matriz[i][j]=a;

gotoxy(col,fil);printf("%d",matriz[i][j]);

b++;

col=col+3;

}

fil=fil+3;

col=10;

}

}

void vect()

{

cont=0;


{


{

if(i%2==0 || j%2==0)

{

vector[cont]=matriz[i][j];

cont++;

}

}

}

}

void imprimir()

{

fil=10;

col=30;

for(i=0;i<cont;i++)

{

gotoxy(col,fil);printf("%d",vector[i]);

fil=fil+2;

if(fil==22)

{

fil=10;

col=col+5;

}

}

}

void main()

{

do

{

clrscr();

borde();

gotoxy(15,2);printf(" P O S I C I O N E S P A R E S D E L A M A T R I Z");

gotoxy(15,3);printf("_________________________________________________________");

gotoxy(5,5);printf("Ingrese el limite =>");scanf("%d",&limite);

gotoxy(5,7);printf("Ingrese el factor =>");scanf("%d",&fact);

factor();

vect();

imprimir();

gotoxy(6,23);printf("Presione 1 para continuar 0 para finalizar=>");scanf("%d",&op);

}

while(op==1);

}

Corrido

Matriz con primos

Realice un programa con funciones que me permita

generar una matriz con primos

ANALISIS

Primero colocamos las librerías después las variables globales.

Comenzamos con la función borde donde realizamos el proceso, cerramos

la función seguido creamos otra función para la matriz donde realizamos

el proceso para encerar a la matriz, después se realizar 2 for para que

después con un if preguntemos si i=j para encontrar la diagonal principal

y realizamos el Fibonacci con su proceso, así mismo otro if para preguntar

si el límite es igual a j y hacemos otro proceso para el factorial.

Luego otra función donde tenemos que imprimir en la matriz y ya está las

funciones completas, luego el programa principal donde llamamos el

programa.

Codificátion

include<stdio.h>

#include<conio.h>

#include<math.h>

#include<string.h>

int matriz1[10][10],i,j,f1=0,t=0,op=0,f=0,primo=1,x=1,conpri=0,sw=0;

void encerar(int n)

{

for(i=1;i<=n;i++)

{

for(j=1;j<=n;j++)

{

matriz1[i][j] = 0;

}

}

}

void primos(int n)

{

primo=1;

sw=0;

for(i=1;i<=n;i++)

{

for(j=1;j<=n;j++)

{

do

{

conpri=0;

sw=0;

for(x=1;x<=primo;x++)

{

if((primo%x)==0)

{

conpri++;

}

}

if(conpri<=2)

{

matriz1[i][j] = primo;

primo++;

sw=1;

}

else

{

sw=0;

primo++;

}

}

while (sw==0);

}

}

}

void imprimir(int a)

{

t=5;

f1=7;

for(i=1;i<=a;i++)

{

for(j=1;j<=a;j++)

{

gotoxy(t,f1);printf("%d",matriz1[i][j]);

t=t+6;

}

t=5;

f1=f1+2;

}

}

void borde()

{

clrscr();

for (i=1;i<=80;i++)

{

gotoxy(i,1); printf("*");


}

for (i=1;i<=24;i++)

{

gotoxy(1,i); printf("*");


}

}

void main()

{

do

{

clrscr();

borde();

borde();

gotoxy(12,2); printf(" M A T R I Z C O N P R I M O S ");

gotoxy(12,3); printf("__________________________________");

do

{

gotoxy(55,5); printf(" ");

gotoxy(10,5); printf("Ingrese el limite => ");scanf("%d",&f);

}

while (f<1 || f >9);

encerar(f);

primos(f);

imprimir(f);

gotoxy(5,23); printf("Presione 1 para continuar 0 para finalizar =>");scanf("%d",&op);

}

while (op==1);

}

Corrido

Fibonacci y factorial

Diseñe un programa utilizando matrices y funciones que me permita llenar una matriz con valores

0 a acepción de sus diagonales principales y secundarias, la misma que se llena con valores pares

principal y con valores impares, guarde los datos de las diagonales en un vector, presente la matriz

original sus diagonales en forma de x el vector original y el vector resultante.

Aná lisis



Después creo otra función llamado ingreso donde programamos para

generar el ingreso de las matrices según el limite deseado, para ello vamos a

necesitar declarar variables ya sean globales o dentro de cada función,

necesitaremos dos for para crear la matriz y elaborar la validación.

Cuando ya hemos ingresado la matriz o generado, debemos también en cada

ingreso utilizar un if para preguntar si i=j, si es verdadera se creara el

Fibonacci dentro del if ya que ello lleva a ala impresión de la diagonal

principal y también preguntar si c=j sabiendo que c es igual al limite que

quiere decir que se busca la diagonal secundaria donde aremos el factorial.

Creamos otra función donde recorreremos la matriz y buscaremos las

diagonales, donde al igual necesitaremos 2 for y usaremos if par que solo se

impriman las diagonales.


llamaremos a todas las funciones y crearemos títulos e ingresos de límite y la



mandamos a correr.

Codificádo

#include<stdio.h>

#include<conio.h>

#include<string.h>

int c,matriz[10][10],vect[10],b,d,i,j,h,fil,col,conta=0,limite,op,a,par;

void borde ()

{

for (i=1;i<=80;i++)

{



}

for (i=1;i<=24;i++)

{



}

}

void ingreso()

{

col=10;fil=9;

a=2;

b=0;

d=1;

c=limite;


{


{

if(i==j)

{

matriz[i][j]=a;

gotoxy(col,fil);printf("%d", matriz[i][j]);

a=a+2;

}

else

{

if(c==j)

{

matriz[i][j]=d;


d=d+2;

}

else

{

matriz[i][j]=b;


}

}

col=col+3;

}

col=10;

c=c--;

fil=fil+3;

}

}

void diagonal()

{

col=40;

fil=9;

c=limite;

for (i=1;i<=limite;i++)

{

for (j=1;j<=limite;j++)

{

if (i==j)

{

vect[h]=matriz[i][j];

h=h+1;


col=col+3;

fil=fil+3;

}

}

}

col=50;

fil=9;


{


{

if(c==j)

{


col=col-4;

fil=fil+3;

c=c-1;

}

}

}

}

void vector()

{

col=60;

fil=9;


{


{

if (i==j)

{

vect[h]=matriz[i][j];

h=h+2;


col=60;

fil=fil+2;

}

}

}

}

void main()

{

do

{

conta=par;

clrscr();

borde();

par=par;

matriz[i][j]=par;

gotoxy(30,2); printf("MATRIS");

gotoxy(10,4); printf(" Ingrese un limite = ");scanf("%d",&limite);

gotoxy(4,7); printf("MATRIZ PRINCIPAL ");

ingreso();

diagonal();

vector();

gotoxy(2,23);printf(" PRECIONE 1 PARA CONTINUAR o 0 PARA SALIR = ");scanf("%d",&op);

}

while(op==1);

}

Corrido

Matriz de un factor

Realice un programa con funciones donde se genere una matriz mediante un factor.

Aná lisis



Después creo otra función llamado factor donde programamos para generar

el factor de la matriz según el limite deseado, para ello vamos a necesitar


dos for para crear la matriz y elaborar el factor en la misma.

Cuando ya hemos ingresado la matriz, debemos crear otra función donde

recorreremos la matriz para imprimir la matriz llena del factor.

Debemos también hacer en el programa principal el ingreso del límite para la

matriz y el ingreso de un número para que se genere en la matriz del factor

del mismo.


llamaremos a todas las funciones y crearemos títulos e ingresos de límite y la



mandamos a correr.

Codificádo

# include<stdio.h>

# include<conio.h>

int a,matriz[10][10],i,j,col,fil,op,factor,limite;

void borde()

{

for(i=1;i<=80;i++)

{



}

for(i=1;i<=24;i++)

{



}

}

void proceso()

{

a=0;

fil=11;

col=30;

gotoxy(5,7);printf("Ingrese el limite=>"); scanf("%d",&limite);

gotoxy(5,9);printf("Ingrese el factor=>"); scanf("%d",&factor);


{


{

a=a+factor;

matriz[i][j]=a;


col=col+3;

}

fil=fil+3;

col=30;

}

}

void main()

{

do

{

clrscr();

borde();

gotoxy(20,3);printf("M A T R I Z D E U N F A C T O R");

gotoxy(20,4);printf("_____________________________________");

proceso();

gotoxy(5,23);printf("Presione 1 para continuar 0 parea finalizar=>");scanf("%d",&op);

}

while(op==1);

getch();

}

Corrido

Matriz con validación

Realice un programa que me permita ingresa una matriz vialidad entre 5 y 35.

Aná lisis




generar el ingreso de la matriz según el limite deseado, para ello vamos a

necesitar declarar variables ya sean globales o dentro de cada función,

necesitaremos dos for para crear la matriz y también utilizaremos el do while

para poder validar la matriz y cada numero que se ingrese sea entre 5 y 35.


función donde recorreremos la matriz para imprimir, donde al igual

necesitaremos 2 for.





mandamos a correr.

Codificácio n

# include<stdio.h>

# include<conio.h>

int a,matriz[10][10],i,j,col,fil,op,factor,limite;

void borde()

{

for(i=1;i<=80;i++)

{



}

for(i=1;i<=24;i++)

{



}

}

void proceso()

{

a=0;

fil=11;

col=30;

gotoxy(5,7);printf("Ingrese el limite=>"); scanf("%d",&limite);


{


{

do

{

gotoxy(col,fil);printf(" ");

gotoxy(col,fil);scanf("%d",&matriz[i][j]);

}

while(matriz[i][j]<5 ||matriz[i][j]>35 );

col=col+3;

}

fil=fil+3;

col=30;

}

}

void imprimir()

{

fil=11;

col=30;


{


{


col=col+3;

}

fil=fil+3;

col=30;

}

}

void main()

{

do

{

clrscr();

borde();

gotoxy(20,3);printf("M A T R I Z C O N V A L I D A C I O N");

gotoxy(20,4);printf("_________________________________________");

proceso();

gotoxy(5,23);printf("Presione 1 para continuar 0 parea finalizar=>");scanf("%d",&op);

}

while(op==1);

getch();

}

Corrido.

Matriz con el Fibonacci y el factorial

Realice un programa con funciones que me permita ingresar una matriz cuadrática donde su diagonal principal sea con el Fibonacci y el secundario con el factorial.

ANALISIS

Primero colocamos las librerías después las variables globales. Comenzamos con la función borde donde realizamos el proceso, cerramos la función seguido creamos otra función para la matriz donde realizamos el proceso para encerar a la matriz, después se realizar 2 for para que después con un if preguntemos si i=j para encontrar la diagonal principal y realizamos el Fibonacci con su proceso, así mismo otro if para preguntar si el límite es igual a j y hacemos otro proceso para el factorial. Luego otra función donde tenemos que imprimir en la matriz y ya está las funciones completas, luego el programa principal donde llamamos el programa.

Codificádo

#include<stdio.h> #include<conio.h> int matriz[15][15],i,j,limit,a,b,c,l,f,d,op1,col,fila; void borde() { for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("+"); } for(j=1;j<=24;j++) { gotoxy(1,j);printf("*"); gotoxy(80,j);printf("+"); } } void entrada(int limi) { col=8; fila=8; for(i=1;i<=limi;i++) { for(j=1;j<=limi;j++) { l=0; matriz[i][j]=l; gotoxy(col,fila);printf("%d",matriz[i][j]); col=col+2; } fila=fila+1; col=8; } } void entradaprincipal(int limi) { col=8; fila=8; a=1; b=0; c=0; for(i=1;i<=limi;i++)

{ for(j=1;j<=limi;j++) { if(i==j) { c = a+b; a = b; b = c; matriz[i][j]=c; gotoxy(col,fila);printf("%d",matriz[i][j]); } col=col+2; } fila=fila+1; col=8; } } void entradasecundaria(int limi) { col=8; fila=8; f=1; d=limit; for(i=1;i<=limi;i++) { for(j=1;j<=limi;j++) { if(d==j) { f=f*i; matriz[i][j]=f; gotoxy(col,fila);printf("%d",matriz[i][j]); d=d-1; } col=col+2; } fila=fila+1; col=8; } } void diagonalprincipal1(int limi) { col=30; fila=8; a=1; b=0; c=0; for(i=1;i<=limi;i++)

{ for(j=1;j<=limi;j++) { if(i==j) { c = a+b; a = b; b = c; matriz[i][j]=c; gotoxy(col,fila);printf("%d",matriz[i][j]); } col=col+2; } fila=fila+1; col=30; } } void diagonalsecundaria1(int limi) { col=30; fila=8; f=1; d=limit; for(i=1;i<=limi;i++) { for(j=1;j<=limi;j++) { if(d==j) { f=f*i; matriz[i][j]=f; gotoxy(col,fila);printf("%d",matriz[i][j]); d=d-1; } col=col+2; } fila=fila+1; col=30; } } void main() { do { clrscr(); borde(); gotoxy(25,2);printf("MATRIZ FACTORIAL Y FIVONASSI"); gotoxy(10,5);printf("Ingrese el limite => ");scanf("%d",&limit);

entrada (limit); entradaprincipal(limit); entradasecundaria(limit); diagonalprincipal1(limit); diagonalsecundaria1(limit); scanf("%d",&op1); } while(op1==1); getch(); }

Corrido

Ordenar la matriz

Realice un programa con funciones que me permita ingresar una matriz de

cualquier valor para después ordenarla en forma descendente.

ANALISIS


Comenzamos con la función borde donde realizamos el proceso, cerramos

la función seguido creamos otra función para ingresar la matriz en la cual

debemos hacer el proceso normal. Después creamos otra función donde

vamos hacer la ordenación de la matriz con la cual hacemos el proceso

que está en el codificado. Una vez terminado esta función hemos

terminado con las funciones.


funciones completas, luego el programa principal donde llamamos a las

funciones y listo.

Codificádo

#include<stdio.h>

#include<conio.h>

#include<math.h>

#include<string.h>

int f,c,aux,op,i1,j1,matriz1[10][10],i,j,f1=0,t=0,l=0,f2=0;

void encero(int a)

{

for(i=1;i<=a;i++)

{

for(j=1;j<=a;j++)

{

matriz1[i][j] = 0;

}

}

}

void ingreso(int a)

{

t=3;

f1=9;

for(i=1;i<=a;i++)

{

for(j=1;j<=a;j++)

{

gotoxy(t,f1);scanf("%d",&matriz1[i][j]);

t=t+4;

}

t=3;

f1=f1+2;

}

}

void ordena(int a)

{

for(i=1;i<=a;i++)

{

for(j=1;j<=a;j++)

{

for(i1=1;i1<=a;i1++)

{

for(j1=1;j1<=a;j1++)

{

if(matriz1[i][j]<matriz1[i1][j1])

{

aux=matriz1[i][j];

matriz1[i][j]=matriz1[i1][j1];

matriz1[i1][j1]=aux;

}

}

}

}

}

}

void impre1(int a)

{

t=50;

f1=9;

for(i=1;i<=a;i++)

{

for(j=1;j<=a;j++)

{

gotoxy(t,f1);printf("%d",matriz1[i][j]);

t=t+6;

}

t=50;

f1=f1+2;

}

}

void borde ()

{

clrscr();

for (i=1;i<=80;i++)

{



}

for (i=1;i<=24;i++)

{



}

}

void main()

{

do

{

clrscr();

borde();

gotoxy(15,2); printf(" M A T R I Z O R D E N A D A ");

gotoxy(15,3); printf("______________________________");

do

{

gotoxy(55,5); printf(" ");

gotoxy(5,5); printf(" Ingrese el limite => ");scanf("%d",&f);

}

while (f<1 || f >7);

encero(f);

ingreso(f);

ordena(f);

impre1(f);

gotoxy(4,23); printf("Precione 1 para contunuar 0 para finalizar =>");scanf("%d",&op);

}

while (op==1);

}

Corrido

Producto de una matriz

Realice un programa con funciones que me permita ingresar una matriz

cuadrática donde me permita realizar el producto matricial.

ANALISIS


Comenzamos con la función borde donde realizamos el proceso con dos for

realizaremos el margen, cerramos la función seguido creamos otra función para la

matriz donde realizamos el proceso para hacer el ingreso de la matriz 1 y 2 , las

dos tendrán que ser validadas, después se realizar otra función donde

realizaremos el proceso para el producto matricial donde necesitamos tres

matrices y tres for, cada una cumple una función específica para el control de filas

y columnas que me permitirán realizar el producto de matrices .


funciones completas, luego el programa principal donde primero utilizamos el

clrscr() para blanquear pantalla seguido de un do para que al último preguntemos

si deseamos continuar o no, ingresamos también el limite seguido llamamos a las

funciones y ponemos títulos si deseamos.

Para finalizar cerramos el programa principal con el while y listo verificamos si

corre el programa o no.

Codificádo

#include<conio.h>

#include<stdio.h>

#include<string.h>

int matriz1[10][10] ,matriz2[10][10] ,prod[10][10],fila,col,i,j,h,op,limite;

void borde()

{

for(i=1;i<=80;i++)

{



}

for(i=1;i<=24;i++)

{



}

for(i=8;i<=20;i++)

{



}

}

void ingreso()

{

fila=10;

col=7;


{


{

gotoxy(col,fila);scanf("%d",&matriz1[i][j]);

col=col+4;

}

fila=fila+2;

col=7;

}

Librerías

Proceso borde

Proceso para el ingreso

de la primera matriz

fila=10;

col=37;


{


{

gotoxy(col,fila);scanf("%d",&matriz2[i][j]);

col=col+4;

}

fila=fila+2;

col=37;

}

}

void producto()

{


{


{

prod[i][h]=0;

for(h=1;h<=limite;h++)

{

prod[i][j]=prod[i][j]+(matriz1[i][h]*matriz2[h][j]);

}

}

}

}

void imprimir()

{

fila=10;

col=62;

gotoxy(45,8);printf("");


{


{

gotoxy(col,fila);printf("%d",prod[i][j]);

col=col+4;

}

fila=fila+2;

col=62;

}

Proceso para el

ingreso de la segunda

matriz

Proceso para el

producto matricial.

Proceso para

imprimir la matriz

}

void main()

{

do

{

clrscr();

borde();

gotoxy(25,2);printf("PRODUCTO DE UNA MATRIZ");

gotoxy(25,3);printf("______________________");

gotoxy(5,5);printf("Ingrese limite => ");scanf("%d",&limite);

ingreso();

producto();

imprimir();

gotoxy(9,20);printf("MATRIZ UNO");

gotoxy(37,20);printf("MATRIZ DOS");

gotoxy(60,20);printf("MATRIZ RESULTANTE");

gotoxy(5,23);printf("Presione 1 para continuar 0 para finalizar => ");scanf("%d",&op);

}

while(op==1);

getch();

}

Proceso ingreso del

límite.

Llamado de las

funciones.

Títulos

Función

para

regresar o

no

Corrido

Matriz Transpuesta

Realice un programa con funciones donde ingreso una matriz y la con vierta

en una matriz traspuesta.

Aná lisis




generar la matriz según el limite deseado, para ello vamos a necesitar


declarar dos matrices. Para ella primero inicializamos las variables y

utilizaremos 2 for para crear la matriz que tenemos que validar.


función donde recorreremos la matriz y diremos que la

matriz2 [j][i]=matriz1[i][j] , donde al igual necesitaremos 2 for y la

imprimimos a la matriz2.





mandamos a correr.

Codificácio n

# include<stdio.h>

# include<conio.h>

# include<string.h>

int matriz[10][10],i,j,op,fil,col,lim1,lim2,matriz2[10][10];

void borde()

{

for(i=1;i<=80;i++)

{



}

for(i=1;i<=24;i++)

{



}

}

void ingreso()

{

fil=10;

col=10;

for(i=1;i<=lim1;i++)

{

for(j=1;j<=lim2;j++)

{


col=col+3;

}

fil=fil+3;

col=10;

}


{


{

matriz2[j][i]=matriz[i][j];

}

}

}

void imprimo()

{

col=40;

fil=10;


{


{

gotoxy(col,fil);printf("%d",matriz2[i][j]);

col=col+3;

}

fil=fil+3;

col=40;

}

}

void main()

{

do

{

clrscr();

borde();

for(i=1;i<20;i++)

{

gotoxy(2+i,2);printf(" M A T R I Z T R A N S P U E S T A");

gotoxy(2+i,3);printf(" ___________________________________");

delay(50);

}

gotoxy(5,5);printf("Ingrese el numero de columnas=>");scanf("%d",&lim2);

gotoxy(5,7);printf("Ingrese el numero de filas=>");scanf("%d",&lim1);

ingreso();

imprimo();


}

while(op==1);

}

Corrido

Impares de un matriz

Realice un programa con funciones que me permita ingresar una matriz

validada entre 5 y 35, recorra la matriz y identifique los valores impares y

guárdelos en un vector y ordéneles en forma ascendente. Esta programa se

repite n beses.

Aná lisis



Después creo otra función llamado ingreso donde programamos para el

ingreso de la matriz según el limite deseado, para ello vamos a necesitar


dos for para crear la matriz donde tenemos también que validar.


función donde recorreremos la matriz y buscaremos los valores impares y a

pasaremos a un vector donde al igual necesitaremos 2 for y un contador

para el vector, usaremos if para preguntar si la matriz[i][j]%2==1, si dice que

si, quiere decir que el numero es impar.

Aremos otra función donde necesitamos un for y el límite será hasta el

contador que pusimos anteriormente e imprimimos el vector donde se

guardo los valores impares.





mandamos a correr.

Codificácio n

#include<stdio.h>

#include<conio.h>

#include<string.h>

int matriz[10][10],aux,i,j,col,fil,a,b,limite,op,vect[10];

void borde()

{

for(i=1;i<=80;i++)

{



}

for(i=1;i<=24;i++)

{



}

}

void ingreso()

{

col=10;

fil=10;

gotoxy(5,8);printf("Ingreso de la matriz");


{


{

do

{

gotoxy(col,fil);printf(" ");


}

while(matriz[i][j]<5 || matriz[i][j]>35);

col=col+3;

}

fil=fil+3;

col=10;

}

a=0;


{


{

if(matriz[i][j]%2==1)

{

vect[a]=matriz[i][j];

a++;

}

}

}

}

void imprimir()

{

col=35;

fil=10;

for(i=0;i<a;i++)

{

gotoxy(col,fil);printf("%d",vect[i]);

fil=fil+2;

}

}

void ordenar()

{

for(i=0;i<a;i++)

{

for(j=0;j<a;j++)

{

if(vect[i] < vect[j])

{

aux=vect[i];

vect[i]=vect[j];

vect[j]=aux;

}

}

}

col=45;

fil=10;

for(i=0;i<a;i++)

{


fil=fil+2;

}

}

void decen()

{

for(i=0;i<a;i++)

{

for(j=0;j<a;j++)

{

if(vect[i] > vect[j])

{

aux=vect[i];

vect[i]=vect[j];

vect[j]=aux;

}

}

}

col=55;

fil=10;

for(i=0;i<a;i++)

{


fil=fil+2;

}

}

void main()

{

do

{

clrscr();

borde();

gotoxy(20,2);printf("I M P A R E S D E L A M A T R I Z ");

gotoxy(20,3);printf("_______________________________________ ");

gotoxy(5,5);printf("Ingrese el limite=>");scanf("%d",&limite);

ingreso();

imprimir();

ordenar();

decen();


}

while(op==1); }

Corrido

Menú de opciones De vocales y consonantes

Diseñe un programa utilizando funciones que me permita diseñar un menú

de opciones con las siguientes alternativas

1.- cadenas con vocales

2.- cadenas con consonantes

3.- salir

Aná lisis



Después creo otra función llamado vocales donde realizamos el proceso de

nuestro programa donde ingresamos las variables que vamos a utilizar y los

vectores también ingresamos pero en un char, ingresamos títulos y el ingreso

de la cadena mediante el vector.

Colocamos un for para recorrer el vector y mediante if preguntaremos si el

vector es igual alas 5 vocales (un if para cada vocal), donde cada pregunta

que realizamos si es verdadera tenemos que pasar a otro vector.

Y al imprimimos al vector donde se guardo las vocales.

Seguido hacemos una función que la llamaremos consonantes, ingresamos

títulos que nos sirvan para la identificación de nuestros ingresos y del

programa, en el char declaramos los vectores por que son letras las que

vamos ingresar para que se busquen las consonantes, utilizando un for para

recorrer el vector para hacer el proceso de verificación y ordenamiento.


aremos la mascara de nuestro menú e ingresamos el limite, las funciones

llamaremos en los case y en cada función de vemos hacer un blanqueo de

pantalla.

También necesitaremos que el programa se repita n veces y listo


mandamos a correr

Codificácio n

# include<stdio.h>

# include<conio.h>

# include<string.h>

# include<dos.h>

int op,num1,num2,sum,res,mult,div,aux,i,j,fil,col,lim,cont;


void borde()

{

for(i=1;i<=80;i++)

{



}

for(i=1;i<=24;i++)

{



}

}

void pantalla(void)

{

clrscr();

gotoxy(30,3);printf("Menu de Opciones");

gotoxy(30,4);printf("________________");

gotoxy(10,7);printf("[1]...VOCALES");

gotoxy(10,10);printf("[2]...CONSONANTES");

gotoxy(10,13);printf("[3]...SALIR");

gotoxy(30,22);printf(" ESCOJA UNA OPCION...[ ]");

}

void vocales()

{

int aux,i,j,fil,col,lim,cont,op;


do

{

clrscr();

flushall();

for(i=1;i<=80;i++)

{



}

for(i=1;i<=24;i++)

{



}

gotoxy(26,3);printf("******* V O C A L E S ********");

gotoxy(5,6);printf("INGRESE UNA CADENA=> "); gets(vector);

lim=strlen(vector);

fil=10;

col=15;

cont=0;

for(i=0;i<lim;i++)

{

if(vector[i]=='a')

{


cont++;

}

if(vector[i]=='e')

{


cont++;

}

if(vector[i]=='i')

{


cont++;

}

if(vector[i]=='o')

{


cont++;

}

if(vector[i]=='u')

{


cont++;

}

}

gotoxy(9,9);printf("VISUALIZACION");

for(i=0;i<cont;i++)

{


fil=fil+1;

}

for(i=0;i<cont;i++)

{

for(j=0;j<cont;j++)

{

if(vector2[j]>vector2[i])

{

aux=vector2[i];

vector2[i]=vector2[j];

vector2[j]=aux;

}

}

}

fil=10;

col=36;

gotoxy(30,9);printf("VECTOR ORDENADO");

for(i=0;i<cont;i++)

{


fil=fil+1;

}

gotoxy(5,23);printf("presione 1 para continuar 0 para finalizar=>");scanf("%d",&op);

}

while(op==1);

}

void consonantes(void)

{

int aux,i,j,fil,col,lim,cont,op;


do

{

clrscr();

borde();

flushall();

gotoxy(26,3);printf("******* C O N S O N A N T E S ********");

gotoxy(5,6);printf("INGRESE UNA CADENA=> ");gets(vector);

lim=strlen(vector);

fil=10;

col=10;

cont=0;

for(i=0;i<lim;i++)

{

if(vector[i]!='a' && vector[i]!='e' && vector[i]!='i' && vector[i]!='o' && vector[i]!='u')

{


cont++;

}

}

for(i=0;i<cont;i++)

{


fil=fil+1;

}

gotoxy(5,23);printf("presione 1 para continuar 0 para finalizar=>");scanf("%d",&op);

}

while(op==1);

getch();

}

void salir()

{

}

void main(void)

{

clrscr();

do

{

pantalla();

borde();

gotoxy(65,22);scanf("%d",&op);

switch(op)

{

case 1: vocales();break;

case 2: consonantes();break;

case 3: salir();break;

}

}

while(op<=2);

getch();

}

Corrido

Documents

Programacion