UNIVERSIDAD DE LAS FUERZAS ARMADAS – ESPE

Departamento de Ciencias de la Computación Fundamentos de la Programación.

Nombre: Juan Francisco Rueda Mesías. Fecha de Entrega: 06/08/2021.

Actividad: Realizar la Tarea sobre los ejercicios enviados en clase.
1: Realizar una función implementando Arreglos, que permita la opción de determinar y ubicar
la posición y el número de repeticiones de los valores existentes en las matrices creadas.
#include <stdio.h>
#include <stdlib.h>
//Mediante la implementación de arreglos-posición del número ingresado por el usuario y las veces que se
repite en el arreglo
//Declarar arreglos para la formación de matrices con valores random (rand)
//Implementar las funciones y ecuaciones para ubicar la posición y repetición de los valores
int main(){
int arrBid[10][10];
int vec[10*10];
for(int i = 0;i<100;i++){
vec[i] =0;
}
for(int i = 0; i < 10; i++)
{
printf("\n");
for(int j = 0; j < 10; j++){
arrBid[i][j] = rand() % 50;
vec[arrBid[i][j]]++;
} }
int w = 0;
for(int i = 0; i<100;i++){
if(vec[i]!=0){
w+=vec[i];
printf("El valor %d se repite %d veces\n",i,vec[i]);
}
}
 printf("%d",w);

for(int i = 0; i < 10; i++)

{
printf("\n");
for(int j = 0; j < 10; j++)
printf("\t%d",arrBid[i][j]);
}
int num;
printf("\nIngrese el valor que desea hallar: ");
scanf("%d", &num);
int rep;
for(int i = 0; i < 10; i++){
for(int j = 0; j < 10; j++){
if (arrBid[i][j] == num){
printf("\nEl valor se ubico en la posicion [%d][%d]", i, j);
rep ++;
}
}
}
printf("\nLa cantidad de veces que se repite es %d",rep);
}
Explicación: Los arreglos son estructuras de datos consistentes en un conjunto de datos del mismo tipo.
Los arreglos tienen un tamaño de los datos que pueden almacenar. Se va a trabajar con este tipo de
almacén además de conocer la opción random que permiten la existencia de valores aleatorios para su
trabajo. Permitiendo contar las veces que se repite los números, inicializando una variable con cero con
lazo de repeticiones que va desde la variable inicializada hasta un valor asignado.

2: Realizar una función implementando Arreglos, que permita la creación de matrices por medio
del valor asignado por el usuario en número de filas y columnas. Continuando con la suma de los
valores y asignando la posición para que la suma se realice correctamente.
#include <stdio.h>
#include <stdlib.h>
//Implementar un programa mediante la implementación de Arreglos
//Designar las variables e imprimir y escribir el número de filas y columnas para la creación de
matrices
//(Cabe recalcar que para la suma de matrices deben tener ambas el mismo número en filas y
columnas en ambas matrices)
//Luego permitir que el usuario escriba la cantidad en cada posición de la matriz
//Finalmente con las ecuaciones, asignar la suma de los valores dados y en cada posición
respectiva terminen sumándose
int main(){
int valor = 0;
int aux = 0;
int rows = 0;
int col = 0;
int rows2 = 0;
int col2 = 0;
printf("Ingrese el # de filas de la matriz a:\n");
scanf("%d",&rows);
printf("Ingrese el # de columnas de la matriz a:\n");
scanf("%d",&col);
printf("Ingrese el # de filas de la matriz b:\n");
scanf("%d",&rows2);
printf("Ingrese el # de columnas de la matriz b:\n");
scanf("%d",&col2);
int arrBid[rows][col];
int arrBid2[rows2][col2];
for(int i = 0; i < rows; i++)
{
printf("\n");
for(int j = 0; j < col; j++){
printf("Ingrese el valor de matriz1[%d][%d]:\n",i,j);
scanf("%d",&arrBid[i][j]);
} }
for(int i = 0; i < rows2; i++)
{
printf("\n");
for(int j = 0; j < col2; j++){
printf("\nIngrese el valor de matriz2[%d][%d]:\n",i,j);
scanf("%d",&arrBid2[i][j]);
} }
printf("\n----- MATRIZ A -----\n");
for(int i = 0; i < rows; i++)
{
printf("\n");
for(int j = 0; j < col; j++)
printf("\t%d",arrBid[i][j]);
} printf("\n----- MATRIZ B -----\n");

for(int i = 0; i < rows; i++)

{
printf("\n");
for(int j = 0; j < col; j++)
printf("\t%d",arrBid2[i][j]);
} printf("\n----- SUMA DE MATRIZ A + MATRIZ B -----\n");

for(int i = 0; i < rows; i++)

{
 printf("\n");
for(int j = 0; j < col; j++)
printf("\t%d",(arrBid2[i][j]+arrBid[i][j])); }
}

Explicación: El Arreglo Bidimensional es un conjunto de valores (variables) del mismo tipo a los
que se puede acceder mediante dos dimensiones por lo tanto el número de variables de ese
mismo tipo que se pueden tener en memoria en un arreglo bidimensional va ser igual a la
multiplicación de las dos dimensiones del arreglo. El programa realiza la impresión de números
randomicos en las posiciones de variables (i, j) asignando valores para evitar el ingreso de
información basura que tenía la memoria anteriormente. Permitiendo la creación de matrices,
asignando los valores y su posición permitir la sumatoria.
3: Realizar una función implementando Arreglos y comprendiendo las clases comprendidas del
Método Burbuja, que permita la creación del Ordenamiento por Selección.
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define TAM 10
//Plantear el Orden por selección mediante la utilización de Arreglos y tipos de Ordenamiento
using namespace std;
void ordenarMenorAMayor(int arr[])
{
int aux;
for (int it=1; it<TAM; it++)
for (int i=0; i<TAM-1; i++){
if (arr[i]>arr[i+1])
{
 aux=arr[i];
arr[i] = arr[i+1];
arr[i+1] = aux;
} }}
//Ingreso para el Ordenamiento por Selección
void ordenarMenorAMayorSelecion(int arr[])
{
int aux,min;
for (int it=0; it<TAM; it++){
min=it;
for (int i=it+1; i<TAM; i++){
if (arr[i]< arr[min])
{
min=i;
} }
aux=arr[it];
arr[it]=arr[min];
arr[min]=aux;
} }
int buscar(int arr[], int x){
for(int i=0; i<TAM; i++)
if(x == arr[i])
return i;
return -1;
}
void imprimir(int arr[]){
printf("\n");
for(int i=0; i<TAM; i++)
printf("%d\t", arr[i]);
}
void encerar(int arr[]){
for(int i=0; i<TAM; i++)
arr[i] = 0;
}
void llenarDeAleatorios(int arr[]){
for(int i=0; i<TAM; i++)
arr[i] = rand() % 10;
}
int main()
{
int vector[TAM];
imprimir(vector);
encerar(vector);
imprimir(vector);
llenarDeAleatorios(vector);
imprimir(vector);
ordenarMenorAMayor(vector);
imprimir(vector);
printf("\n-----ordenamiento por seleccion-----");
ordenarMenorAMayorSelecion(vector);
imprimir(vector);
int num;
printf("\nIngrese un valor a buscar: ");
scanf("%d", &num);
int pos = buscar(vector, num);
if (pos == -1)
printf("No se encontró el valor dentro del arreglo");
else
printf("Se encontro %d en la posición %d: ", num, pos);
}
Explicación: El Arreglo por Selección consiste en hallar el menor de todos los elementos o
valores asignados en el arreglo o vector e intercambiarlo con el que está en la primera posición.
Luego continuar con una serie de repeticiones (bucle) y así sucesivamente hasta ordenarlo todo.
4: Realizar una función implementando Arreglos y comprendiendo las clases comprendidas del
Método Burbuja, que permita la creación del Ordenamiento por Inserción.
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define TAM 10
//Plantear el Orden por inserción mediante la utilización de Arreglos
using namespace std;
//Ordenamiento Burbuja
void ordenarMenorAMayor(int arr[])
{
int aux;
for (int it=1; it<TAM; it++)
for (int i=0; i<TAM-1; i++){

if (arr[i]>arr[i+1])
{
aux=arr[i];
arr[i] = arr[i+1];
arr[i+1] = aux;
}}}
//Ingreso para el Ordenamiento por inserción
void ordenarMenorAMayorinserccion(int arr[]){
int aux;
for(int i=0; i<TAM; i++){
if(arr[i-1]>arr[i]){
aux=arr[i];
arr[i]=arr[i-1];
}
 aux=arr[i-1];
}}

int buscar(int arr[], int x){

for(int i=0; i<TAM; i++)
if(x == arr[i])
return i;
return -1;
}
void imprimir(int arr[]){
printf("\n");
for(int i=0; i<TAM; i++)
printf("%d\t", arr[i]);
}
void encerar(int arr[]){
for(int i=0; i<TAM; i++)
arr[i] = 0;
}
void llenarDeAleatorios(int arr[]){
for(int i=0; i<TAM; i++)
arr[i] = rand() % 10;
}

int main()
{
int vector[TAM];
imprimir(vector);
encerar(vector);
imprimir(vector);
llenarDeAleatorios(vector);
imprimir(vector);
 ordenarMenorAMayor(vector);
imprimir(vector);
printf("\n-----ordenamiento por insercion-----");
ordenarMenorAMayorinserccion(vector);
imprimir(vector);
int num;
printf("\nIngrese un valor a buscar: ");
scanf("%d", &num);
int pos = buscar(vector, num);
if (pos == -1)
printf("No se encontro el valor dentro del arreglo");
else
printf("Se encontro %d en la posición %d: ", num, pos);
}

Explicación: El Arreglo por Inserción consiste en el ordenamiento de una serie de valores

realizando un recorrido por la serie seleccionando en cada interacción o repetición un valor como
“clave” y compararlo con el resto insertándolo en el lugar correspondiente hasta ordenarlo.