diff --git a/ADAS/.DS_Store b/ADAS/.DS_Store
new file mode 100644
index 0000000..aeeab9c
Binary files /dev/null and b/ADAS/.DS_Store differ
diff --git a/ADAS/Canul/ADA4_ConVisualizacion.c b/ADAS/Canul/ADA4_ConVisualizacion.c
new file mode 100644
index 0000000..053ebdc
--- /dev/null
+++ b/ADAS/Canul/ADA4_ConVisualizacion.c
@@ -0,0 +1,383 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#define N 5
+
+
+void asignarArreglo (int arr [][N]);
+void imprimirArreglo (int arr [][N]);
+void recorrerDiagonalPrincipal (int arr [][N]);
+void recorrerDiagonalInvertida (int arr [][N]);
+void recorrerMatriz12Ascendente (int arr [][N]);
+void recorrerMatriz12Descendente (int arr [][N]);
+void recorrerMatriz34Ascendente (int arr [][N]);
+void recorrerMatriz34Descendente (int arr [][N]);
+void recorrerMatriz14Ascendente (int arr [][N]);
+void recorrerMatriz14Descendente (int arr [][N]);
+void recorrerMatriz23Ascendente (int arr [][N]);
+void recorrerMatriz23Descendente (int arr [][N]);
+void recorrerMatriz1Ascendente (int arr [][N]);
+void recorrerMatriz1Descendente (int arr [][N]);
+void recorrerMatriz2Ascendente (int arr [][N]);
+void recorrerMatriz2Descendente (int arr [][N]);
+void recorrerMatriz3Ascendente (int arr [][N]);
+void recorrerMatriz3Descendente (int arr [][N]);
+void recorrerMatriz4Ascendente (int arr [][N]);
+void recorrerMatriz4Descendente (int arr [][N]);
+
+int main () {
+	int arreglo[N][N];
+	time_t t; 
+	/* inicializacion del generador de numeros random*/
+	srand((unsigned) time(&t));
+	
+	asignarArreglo(arreglo);
+	imprimirArreglo(arreglo); 
+	recorrerDiagonalPrincipal(arreglo);
+	recorrerDiagonalInvertida(arreglo);
+	recorrerMatriz12Ascendente(arreglo);
+	recorrerMatriz12Descendente(arreglo);
+	recorrerMatriz34Ascendente(arreglo);
+	recorrerMatriz34Descendente(arreglo);
+	recorrerMatriz14Ascendente(arreglo);
+	recorrerMatriz14Descendente(arreglo);
+	recorrerMatriz23Ascendente(arreglo);
+	recorrerMatriz23Descendente(arreglo);
+	recorrerMatriz1Ascendente (arreglo);
+	recorrerMatriz1Descendente(arreglo);
+	recorrerMatriz2Ascendente (arreglo);
+	recorrerMatriz2Descendente(arreglo);
+	recorrerMatriz3Ascendente (arreglo);
+	recorrerMatriz3Descendente(arreglo);
+	recorrerMatriz4Ascendente (arreglo);
+	recorrerMatriz4Descendente (arreglo);
+	
+	return(0);
+}
+
+/*asignar valores a la matriz*/
+void asignarArreglo(int arr[][N]){
+	for (int i = 0; i < N; i++){
+		for (int j = 0; j < N; j++){
+			arr[i][j] = rand() % 10;
+		}
+	}
+}
+	
+/*Imprimir la matriz */	
+void imprimirArreglo (int arr[][N]){
+	for(int i = 0; i < N; i++) {
+		for(int j = 0; j < N; j++) {
+			printf(" %d ",  arr[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer la diagonal principal */ 
+void recorrerDiagonalPrincipal (int arr[][N]) { 
+	printf("Diagonal Principal\n");
+	for(int i = 0; i<N; i++) {
+		for(int j=0; j<N; j++){
+			if(i==j){
+				printf(" %d ", arr[j][j]);
+				printf("\n");
+			}
+			else {
+				printf(" "); 
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer la diagonal invertida*/ 
+void recorrerDiagonalInvertida (int arr[][N]) {
+	printf("Diagonal Invertida\n");
+	for (int i=0; i<N; i++) {
+		for (int j=0; j<(N-i);j++){
+			if(j==(N-1-i)){
+			printf("%d",arr[i][j]);
+			printf("\n");
+			}
+			else {
+				printf(" ");
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 1 y 2 de la matriz de forma ASCENDENTE*/
+void recorrerMatriz12Ascendente (int arr[][N]){
+	printf("Region 1 y 2 Ascendente\n");
+	for (int i=0;i<N;i++){
+		for (int j=0; j<(N-i);j++){
+			printf("%d ", arr[i][j]);
+			printf("\t");
+		}
+		printf("\n");
+	}
+	printf("\n");	
+}
+
+/*Recorrer las regiones 1 y 2 de la matriz de forma DESCENDENTE*/
+void recorrerMatriz12Descendente (int arr [][N]) {
+	printf("Region 1 y 2 Descendente\n");
+	for (int i=N-1;i>=0;i--){
+		for (int j=0; j<(N-i);j++){
+			printf("%d ", arr[i][j]);
+			printf("\t");
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 3 y 4 de la matriz de forma ASCENDENTE*/
+void recorrerMatriz34Ascendente (int arr [][N]){
+	printf("Region 3 y 4 Ascendente\n");
+	for(int i=0; i<N;i++) {
+		for(int j=0;j<N ;j++) {
+			if(j>=(N-1-i)){
+				printf("%d ", arr[i][j]);
+				printf("\t");
+			}
+			else {
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 3 y 4 de la matriz de forma DESCENDENTE*/
+void recorrerMatriz34Descendente (int arr [][N]){
+	printf("Region 3 y 4 Descendente\n");
+	for(int i=N-1; i>=0;i--) {
+		for(int j=N-1; j>=0 ;j--) {
+			if(j>=(N-1-i)) {
+				printf("%d ", arr[i][j]);
+				printf("\t");
+			}
+			else {
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 1 y 4 de la matriz de forma ASCENDENTE*/
+void recorrerMatriz14Ascendente (int arr [][N]){
+	printf("Region 1 y 4 Ascendente\n");
+	for(int i = 0; i < N; i++) {
+		for(int j = 0; j < (1+i); j++) {
+			printf("%d ", arr[i][j]);
+			printf("\t");
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 1 y 4 de la matriz de forma DESCENDENTE*/
+void recorrerMatriz14Descendente (int arr [][N]){
+	printf("Region 1 y 4 Descendente\n");
+	for(int i = (N-1); i>=0; i--) {
+		for(int j =0; j<=i; j++) {
+			printf("%d ", arr[i][j]);
+			printf("\t");
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 2 y 3 de la matriz de forma ASCENDENTE*/
+void recorrerMatriz23Ascendente (int arr [][N]) {
+	printf("Region 2 y 3 Ascendente\n");
+	for(int i = 0; i<N; i++) {
+		for(int j =0;j<N ; j++) {
+			if (j<=(N-1) && j>=i){
+				printf("%d ", arr[i][j]);
+				printf("\t");
+			}
+			else {
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}	
+	printf("\n");
+}
+	
+/*Recorrer las regiones 2 y 3 de la matriz de forma DESCENDENTE*/
+void recorrerMatriz23Descendente (int arr [][N]){
+	printf("Region 2 y 3 Descendente\n");
+	for(int i = (N-1); i>=0; i--) {
+		for(int j =(N-1); j>=0; j--) {
+			if (j<=(N-1) && j>=i){
+				printf("%d ", arr[i][j]);
+				printf("\t");
+			}
+			else {
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+
+/*Recorrer la region 1 de forma ASCENDENTE*/
+void recorrerMatriz1Ascendente (int arr [][N]){
+	printf("Region 1 Ascendente\n");
+	/*Para imprimir la región se dividira en 2*/
+	for(int i=0; i<N; i++){
+		if(i<=N/2) {
+			for (int j=0;j<(1+i);j++){
+				printf("%d ", arr[i][j]);
+				printf("\t");
+			}
+		}
+		else {
+			for(int j=0;j<=(N-1-i);j++){
+				printf("%d ", arr[i][j]);
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer la region 1 de forma DESCENDENTE*/
+void recorrerMatriz1Descendente (int arr [][N]){
+	printf("Region 1 Descendente\n");
+	for(int i=(N-1); i>=0; i--){
+		if(i<=N/2) {
+			for (int j=0;j<(1+i);j++){
+				printf("%d ", arr[i][j]);
+				printf("\t");
+			}
+		}
+		else {
+			for(int j=0;j<=(N-1-i);j++){
+				printf("%d ", arr[i][j]);
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+/*Recorrer la region 2 de forma ASCENDENTE*/
+void recorrerMatriz2Ascendente (int arr [][N]) {
+	printf("Region 2 Ascendente\n");
+	for(int i = 0; i<=N/2; i++) {
+		for(int j=0; j<N;j++){
+			if(j<N-i && j>=i) { 
+				printf("%d ", arr[i][j]);
+				printf("\t");
+			}
+			else {
+			printf("\t");
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer la region 2 de forma DESCENDENTE*/
+void recorrerMatriz2Descendente (int arr [][N]) {
+	printf("Region 2 Descendente\n");
+	for(int i =N/2; i>=0; i--) {
+		for(int j=0; j<N;j++){
+			if(j<N-i && j>=i) { 
+				printf("%d", arr[i][j]);
+				printf("\t");
+			}
+			else {
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+	
+/*Recorrer la region 3 de forma ASCENDENTE*/
+void recorrerMatriz3Ascendente (int arr [][N]) {
+	printf("Region 3 Ascendente\n");
+	for(int i = 0; i <N; i++) {
+		for(int j=0;j<N;j++){
+			if(j>=i && j>=N-1-i && j>=(N-1)/2){
+				printf("%d", arr[i][j]);
+				printf("\t");
+			}
+			else {
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}	
+	
+/*Recorrer la region 3 de forma DESCENDENTE*/
+void recorrerMatriz3Descendente (int arr [][N]) {
+	printf("Region 3 Descendente\n");
+	for (int i=(N-1); i>=0;i--){
+		for(int j=0; j<N; j++){
+			if(j>=(N-1)/2 && j>=N-1-i && j>=i){
+				printf("%d", arr[i][j]);				
+				printf("\t");
+			}
+			else {
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer la region 4 de forma ASCENDENTE*/
+void recorrerMatriz4Ascendente (int arr [][N]){
+	printf("Region 4 Ascendente\n");
+	for(int i =0; i < N; i++) {
+		for(int j=0; j<N;j++){
+			if (i>=(N-1)/2 && j>=N-1-i && j<=i){
+				printf("%d", arr[i][j]);
+				printf("\t");
+			}
+			else { 
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}	
+}
+
+/*Recorrer la region 4 de forma DESCENDENTE*/
+void recorrerMatriz4Descendente (int arr [][N]) {
+	printf("Region 4 Descendente\n");
+	for(int i =(N-1); i>=0;i--){
+		for(int j=0;j<N;j++){
+			if(j<=i && i>=(N-1)/2 && j>=N-1-i) { 
+				printf("%d", arr[i][j]);
+				printf("\t");
+			}
+			else {
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
diff --git a/ADAS/Canul/ADA4_SinVisualizacion.c b/ADAS/Canul/ADA4_SinVisualizacion.c
new file mode 100644
index 0000000..41f4155
--- /dev/null
+++ b/ADAS/Canul/ADA4_SinVisualizacion.c
@@ -0,0 +1,316 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#define N 8
+
+
+void asignarArreglo (int arr [][N]);
+void imprimirArreglo (int arr [][N]);
+void recorrerDiagonalPrincipal (int arr [][N]);
+void recorrerDiagonalInvertida (int arr [][N]);
+void recorrerMatriz12Ascendente (int arr [][N]);
+void recorrerMatriz12Descendente (int arr [][N]);
+void recorrerMatriz34Ascendente (int arr [][N]);
+void recorrerMatriz34Descendente (int arr [][N]);
+void recorrerMatriz14Ascendente (int arr [][N]);
+void recorrerMatriz14Descendente (int arr [][N]);
+void recorrerMatriz23Ascendente (int arr [][N]);
+void recorrerMatriz23Descendente (int arr [][N]);
+void recorrerMatriz1Ascendente (int arr [][N]);
+void recorrerMatriz1Descendente (int arr [][N]);
+void recorrerMatriz2Ascendente (int arr [][N]);
+void recorrerMatriz2Descendente (int arr [][N]);
+void recorrerMatriz3Ascendente (int arr [][N]);
+void recorrerMatriz3Descendente (int arr [][N]);
+void recorrerMatriz4Ascendente (int arr [][N]);
+void recorrerMatriz4Descendente (int arr [][N]);
+
+int main () {
+	int arreglo[N][N];
+	time_t t; 
+	/* inicializacion del generador de numeros random*/
+	srand((unsigned) time(&t));
+	
+	asignarArreglo(arreglo);
+	imprimirArreglo(arreglo); 
+	recorrerDiagonalPrincipal(arreglo);
+	recorrerDiagonalInvertida(arreglo);
+	recorrerMatriz12Ascendente(arreglo);
+	recorrerMatriz12Descendente(arreglo);
+	recorrerMatriz34Ascendente(arreglo);
+	recorrerMatriz34Descendente(arreglo);
+	recorrerMatriz14Ascendente(arreglo);
+	recorrerMatriz14Descendente(arreglo);
+	recorrerMatriz23Ascendente(arreglo);
+	recorrerMatriz23Descendente(arreglo);
+	recorrerMatriz1Ascendente (arreglo);
+	recorrerMatriz1Descendente(arreglo);
+	recorrerMatriz2Ascendente (arreglo);
+	recorrerMatriz2Descendente(arreglo);
+	recorrerMatriz3Ascendente (arreglo);
+	recorrerMatriz3Descendente(arreglo);
+	recorrerMatriz4Ascendente (arreglo);
+	recorrerMatriz4Descendente (arreglo);
+	
+	return(0);
+}
+
+/*asignar valores a la matriz*/
+void asignarArreglo(int arr[][N]){
+	for (int i = 0; i < N; i++){
+		for (int j = 0; j < N; j++){
+			arr[i][j] = rand() % 10;
+		}
+	}
+}
+	
+/*Imprimir la matriz */	
+void imprimirArreglo (int arr[][N]){
+	for(int i = 0; i < N; i++) {
+		for(int j = 0; j < N; j++) {
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer la diagonal principal */ 
+void recorrerDiagonalPrincipal (int arr[][N]) { 
+	printf("Diagonal Principal\n");
+	for(int j = 0; j<N; j++) {
+		printf("%d,%d : %d ", j,j, arr[j][j]);
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer la diagonal invertida*/ 
+void recorrerDiagonalInvertida (int arr[][N]) {
+	printf("Diagonal Invertida\n");
+	for (int i=0; i<N; i++) {
+		for (int j=(N-1-i); j<(N-i);j++){
+			printf("%d,%d :%d ", i,j,arr[i][j]);
+			printf("\n");
+		}
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 1 y 2 de la matriz de forma ASCENDENTE*/
+void recorrerMatriz12Ascendente (int arr[][N]){
+	printf("Region 1 y 2 Ascendente\n");
+	for (int i=0;i<N;i++){
+		for (int j=0; j<(N-i);j++){
+			printf("%d,%d :%d ", i,j,arr[i][j]);
+			printf(" ");
+		}
+		printf("\n");
+	}
+	printf("\n");	
+}
+
+/*Recorrer las regiones 1 y 2 de la matriz de forma DESCENDENTE*/
+void recorrerMatriz12Descendente (int arr [][N]) {
+	printf("Region 1 y 2 Descendente\n");
+	for (int i=N-1;i>=0;i--){
+		for (int j=0; j<(N-i);j++){
+			printf("%d,%d :%d ", i,j,arr[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 3 y 4 de la matriz de forma ASCENDENTE*/
+void recorrerMatriz34Ascendente (int arr [][N]){
+	printf("Region 3 y 4 Ascendente\n");
+	for(int i=0; i<N;i++) {
+		for(int j=N-1; j>=(N-1-i);j--) {
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 3 y 4 de la matriz de forma DESCENDENTE*/
+void recorrerMatriz34Descendente (int arr [][N]){
+	printf("Region 3 y 4 Descendente\n");
+	for(int i=N-1; i>=0;i--) {
+		for(int j=N-1; j>=(N-1-i);j--) {
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 1 y 4 de la matriz de forma ASCENDENTE*/
+void recorrerMatriz14Ascendente (int arr [][N]){
+	printf("Region 1 y 4 Ascendente\n");
+	for(int i = 0; i < N; i++) {
+		for(int j = 0; j < (1+i); j++) {
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 1 y 4 de la matriz de forma DESCENDENTE*/
+void recorrerMatriz14Descendente (int arr [][N]){
+	printf("Region 1 y 4 Descendente\n");
+	for(int i = (N-1); i>=0; i--) {
+		for(int j =0; j<=i; j++) {
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer las regiones 2 y 3 de la matriz de forma ASCENDENTE*/
+void recorrerMatriz23Ascendente (int arr [][N]) {
+	printf("Region 2 y 3 Ascendente\n");
+	for(int i = 0; i<N; i++) {
+		for(int j =i; j<=(N-1); j++) {
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}	
+	printf("\n");
+}
+	
+/*Recorrer las regiones 2 y 3 de la matriz de forma DESCENDENTE*/
+void recorrerMatriz23Descendente (int arr [][N]){
+	printf("Region 2 y 3 Descendente\n");
+	for(int i = (N-1); i>=0; i--) {
+		for(int j =(N-1); j>=i; j--) {
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+/*Recorrer la region 1 de forma ASCENDENTE*/
+void recorrerMatriz1Ascendente (int arr [][N]){
+	printf("Region 1 Ascendente\n");
+	/*Para imprimir la región se dividira en 2*/
+	for(int i=0; i<N; i++){
+		if(i<=N/2) {
+			for (int j=0;j<(1+i);j++){
+				printf("%d,%d : %d ", i,j, arr[i][j]);
+			}
+		}
+		else {
+			for(int j=0;j<=(N-1-i);j++){
+				printf("%d,%d : %d ", i,j, arr[i][j]);
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer la region 1 de forma DESCENDENTE*/
+void recorrerMatriz1Descendente (int arr [][N]){
+	printf("Region 1 Descendente\n");
+	for(int i=(N-1); i>=0; i--){
+		if(i<=N/2) {
+			for (int j=0;j<(1+i);j++){
+				printf("%d,%d : %d ", i,j, arr[i][j]);
+			}
+		}
+		else {
+			for(int j=0;j<=(N-1-i);j++){
+				printf("%d,%d : %d ", i,j, arr[i][j]);
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+/*Recorrer la region 2 de forma ASCENDENTE*/
+void recorrerMatriz2Ascendente (int arr [][N]) {
+	printf("Region 2 Ascendente\n");
+	for(int i = 0; i<=N/2; i++) {
+		for(int j=i; j<=(N-1)-i;j++){
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer la region 2 de forma DESCENDENTE*/
+void recorrerMatriz2Descendente (int arr [][N]) {
+	printf("Region 2 Descendente\n");
+	for(int i =N/2; i>=0; i--) {
+		for(int j=i; j<=(N-1)-i;j++){
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+	
+/*Recorrer la region 3 de forma ASCENDENTE*/
+void recorrerMatriz3Ascendente (int arr [][N]) {
+	printf("Region 3 Ascendente\n");
+	for(int i = 0; i <(N-1)/2; i++) {
+		for(int j=(N-1-i);j<=N-1;j++){
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+	for(int i=(N-1)/2;i<=N-1;i++){
+		for(int j=i;j<=N-1;j++){
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+	printf("\n");
+	}
+	printf("\n");
+}
+	
+	
+/*Recorrer la region 3 de forma DESCENDENTE*/
+void recorrerMatriz3Descendente (int arr [][N]) {
+	printf("Region 3 Descendente\n");
+	for (int i=(N-1); i>=0;i--){
+		if (i<=N/2){
+			for(int j=(N-1)-i;j<N;j++){
+				printf("%d,%d : %d ", i,j, arr[i][j]);
+			}
+		}
+		else {
+			for(int j=i; j<N;j++){
+				printf("%d,%d : %d ", i,j, arr[i][j]);
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+
+/*Recorrer la region 4 de forma ASCENDENTE*/
+void recorrerMatriz4Ascendente (int arr [][N]){
+	printf("Region 4 Ascendente\n");
+	for(int i =N/2; i < N; i++) {
+		for(int j=(N-1)-i; j<=i;j++){
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}	
+}
+
+/*Recorrer la region 4 de forma DESCENDENTE*/
+void recorrerMatriz4Descendente (int arr [][N]) {
+	printf("Region 4 Descendente\n");
+	for(int i =(N-1); i>=N/2;i--){
+		for(int j=(N-1)-i;j<=i;j++){
+			printf("%d,%d : %d ", i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
diff --git a/ADAS/Canul/ADA6-Listas.c b/ADAS/Canul/ADA6-Listas.c
new file mode 100644
index 0000000..86c61a4
--- /dev/null
+++ b/ADAS/Canul/ADA6-Listas.c
@@ -0,0 +1,147 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+typedef struct nodo 
+{
+    char dato; //Caracter en la seccion dato
+    struct nodo *siguientePtr; //Puntero al siguiente
+
+}nodo;
+
+typedef nodo *NodoPtr; 
+
+void menu();
+int estaVacia (NodoPtr *sPTR);
+void imprimeLista(NodoPtr actualPtr);
+void insertaOrdenado(NodoPtr*sPtr, char valor);
+NodoPtr borrarNodo (NodoPtr actualPtr, char datoA);
+
+int main (){
+    NodoPtr inicioPtr=NULL; /*Puntero inicial*/
+    int eleccion; /*Seleccion de usuario*/
+    char dato; /*char teclado*/ 
+
+    menu(); 
+    printf("Selecciona una opcion :)"); 
+    scanf("%d", &eleccion); 
+
+    while (eleccion !=3){
+        switch (eleccion)
+        {
+        case 1:
+            printf("Introducir un caracter:");
+            scanf("\n%c",&dato);
+            insertaOrdenado(&inicioPtr, dato); 
+            imprimeLista(inicioPtr);
+            break;
+        case 2: 
+            printf("Eliminar el caracter: "); 
+            scanf("\n%c",&dato);
+            borrarNodo(&inicioPtr, dato); 
+            imprimeLista(inicioPtr); 
+            break;
+        default: 
+            printf("opcion invalida.\n\n"); 
+            menu(); 
+            break;
+        }/*Fin Switch*/
+        
+        printf("Selecciona una opcion nuevamente :)");
+        scanf("%d",&eleccion); 
+    }/*Fin while*/
+
+    printf("Fin de ejecución\n"); 
+    
+    return 0; 
+}/*Fin del main*/
+
+//Funciones
+
+//Funcion de impresion de menú
+void menu(){
+    printf("Eleccion: \n"
+    "1. Agregar un elemento a la lista. \n"
+    "2. Borrar un elemento de la lista. \n"
+    "3. Fin del programa.\n");
+}//Fin del menu
+
+//Funcion para verificar si la lista esta vacia
+int estaVacia (NodoPtr*sPtr){
+    return sPtr==NULL; 
+}//Fin esta vacia
+
+//Impresion de la lista
+void imprimeLista(NodoPtr actualPtr){
+    /*Verifica si esta vacia*/ 
+    if(actualPtr==NULL){
+        printf("Lista vacía. \n\n"); 
+    }
+    //Si hay datos en la lista 
+    else {
+        printf("Contenido de la lista: \n");
+
+        /*Mientras no sea el fin de la lista*/ 
+        while(actualPtr!=NULL){
+            printf("%c-->", actualPtr->dato);
+            actualPtr=actualPtr->siguientePtr;
+        }
+        //Fin de la lista
+        printf("\n"); 
+    }
+}
+
+//Funcion para borrar el Nodo
+NodoPtr borrarNodo (NodoPtr actualPtr, char datoA){
+    NodoPtr borrNodo = NULL; 
+    if (actualPtr !=NULL){
+        if (actualPtr ->dato == datoA){
+            borrNodo = actualPtr;
+            actualPtr= actualPtr->siguientePtr;
+            free(borrNodo);
+        }
+        else {
+            actualPtr->siguientePtr = borrarNodo (actualPtr ->siguientePtr, datoA);
+        }
+    }
+}
+
+//Funcion InsertaOrdenado
+void insertaOrdenado(NodoPtr*sPtr, char valor){
+    NodoPtr nuevoPtr; //Puntero al nodo nuevo
+    NodoPtr anteriorPtr; //Puntero al nodo anterior
+    NodoPtr actualPtr; //Puntero al nodo actual
+    //Creacion de nodo
+    nuevoPtr=(nodo*)malloc(sizeof(nodo));
+    //Se verifica si hay espacio
+    if(nuevoPtr != NULL){
+        //Se coloca los datos de escritura
+        nuevoPtr->dato=valor;
+        nuevoPtr->siguientePtr=NULL;
+
+        anteriorPtr=NULL;
+        actualPtr=*sPtr; 
+
+        //While para colocarlo en la lista 
+        while (actualPtr != NULL && valor > actualPtr->dato)
+        {
+            /*Se avanza en el recorrido de la lista*/ 
+            anteriorPtr = actualPtr;
+            actualPtr = actualPtr->siguientePtr;
+        }
+        
+        //Inserción del nodo al inicio de la lista
+        if(anteriorPtr==NULL){
+            nuevoPtr->siguientePtr=*sPtr;
+            *sPtr=nuevoPtr;
+        }
+        else{
+            //Insesión entre anterior y actual
+            anteriorPtr->siguientePtr=nuevoPtr;
+            nuevoPtr->siguientePtr=actualPtr;
+        }
+    }
+    else {
+        printf("%c No hay memoria disponible \n", valor);
+    }
+}
diff --git a/ADAS/Canul/ADA6-Sudoku.c b/ADAS/Canul/ADA6-Sudoku.c
new file mode 100644
index 0000000..998c8ca
--- /dev/null
+++ b/ADAS/Canul/ADA6-Sudoku.c
@@ -0,0 +1,183 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+//Verificar si un Sudoku generado automaticamente cumple con las reglas del Sudoku: 
+//Reglas: 
+//que solo sean números del 1 al 9
+//Que los numeros no se repitan, horizontal, vertical y en la submatriz
+//Autor: Pamela Canul 
+
+//Definicion de las estructuras de datos
+typedef struct submatriz
+{
+    int matrizMenor[3][3];    
+}submatriz;
+
+typedef struct sudoku
+{
+    submatriz matrizMayor[3][3];
+}sudoku;
+
+//Prototipos de las funciones
+void asignarValores (sudoku* tablero);
+void imprimirSudoku (sudoku* tablero);
+int checarVertical (sudoku* tablero); 
+int checarHorizontal (sudoku* tablero); 
+int checarSubmatriz (sudoku* tablero); 
+void resultado (sudoku* tablero); 
+
+int main ( ){
+
+    time_t t; 
+	/* inicializacion del generador de numeros random*/
+	srand((unsigned) time(&t));
+
+    sudoku sudok; 
+
+    //Asignar valores al sudoku e imprimirlo
+    asignarValores(&sudok); 
+    imprimirSudoku(&sudok);
+
+    //Imprimir si se trata de un Sudoku o no
+    resultado (&sudok); 
+
+    return 0; 
+}
+
+//Funcion para asignar los valores al Sudoku
+void asignarValores (sudoku* tablero){
+    //La i y la j son para el tablero mayor
+    for (int i=0;i<3;i++){
+        for (int j=0;j<3; j++){
+            //La p y la q son para el tablero menor
+            for (int p=0;p<3; p++){
+                for(int q=0;q<3;q++){
+                    (*tablero).matrizMayor[i][j].matrizMenor[p][q]= rand() % 9 + 1;
+                }
+            }
+        }
+    }
+}
+
+//Funcion para imprimir los valores del Sudoku
+void imprimirSudoku (sudoku* tablero){
+    //La i y la j son para el tablero mayor
+    for (int i=0;i<3;i++){
+        for (int j=0;j<3; j++){
+            //La p y la q son para el tablero menor
+            for (int p=0;p<3; p++){
+                printf(" ");
+
+                for(int q=0;q<3;q++){
+                    printf("%d",(*tablero).matrizMayor[i][p].matrizMenor[j][q]);
+                    printf(" ");
+                }
+                printf("\t");
+            }
+            printf("\n");
+        }
+        printf("\n");
+    }
+}
+
+//Funcion para verificar los valores del Sudoku de manera vertical
+int checarVertical (sudoku* tablero){
+    //Se usa una bandera para dar valores verdaderos o falsos
+    int verificar=1; 
+    for (int i=0;i<3;i++){
+        for (int j=0;j<3; j++){
+            int num=0;
+            int N[9];
+            for (int p=0;p<3; p++){
+                for(int q=0;q<3;q++){
+                    N[num]=(*tablero).matrizMayor[j][i].matrizMenor[q][p];
+                    num++;
+                }
+            }
+            //Se ferifica que no se repita el numero del lugar p,q
+            for (int e=0; e<9;e++){
+                for (int f=0;f<9;f++){
+                    if(N[e]==N[f] && f!=e){
+                        verificar=0;
+                    }
+                }
+                num=0;
+            }
+        }
+    }
+    return verificar;
+}
+
+//Funcion para verificar los valores del Sudoku de manera horizontal
+int checarHorizontal (sudoku* tablero){
+    //Se usa una bandera para dar valores verdaderos o falsos
+    int verificar=1; 
+    for (int i=0;i<3;i++){
+        for (int j=0;j<3; j++){
+            int num=0;
+            int N[9];
+            for (int p=0;p<3; p++){
+                for(int q=0;q<3;q++){
+                    N[num]=(*tablero).matrizMayor[i][p].matrizMenor[j][q];
+                    num++;
+                }
+            }
+            //Se ferifica que no se repita el numero del lugar p,q
+            for (int e=0; e<9;e++){
+                for (int f=0;f<9;f++){
+                    if(N[e]==N[f] && f!=e){
+                        verificar=0;
+                    }
+                }
+                num=0;
+            }
+        }
+    }
+    return verificar;
+}
+
+//Funcion para verificar los valores del Sudoku en toda la submatriz donde se encuentra
+int checarSubmatriz (sudoku* tablero){
+    //Se usa una bandera para dar valores verdaderos o falsos
+   int verificar=1; 
+    for (int i=0;i<3;i++){
+        for (int j=0;j<3; j++){
+            int num=0;
+            int N[9];
+            for (int p=0;p<3; p++){
+                for(int q=0;q<3;q++){
+                    N[num]=(*tablero).matrizMayor[i][j].matrizMenor[p][q];
+                    num++;
+                }
+            }
+            //Se ferifica que no se repita el numero 
+            for (int e=0; e<9;e++){
+                for (int f=0;f<9;f++){
+                    if(N[e]==N[f] && f!=e){
+                        verificar=0;
+                    }
+                }
+                num=0;
+            }
+        }
+    }
+    return verificar;
+} 
+
+//Funcion de impresion del resultado
+void resultado (sudoku* tablero){
+    //Se asigna los valores de las banderas de las funciones para que se puedan analizar
+    int horizontal=checarHorizontal(tablero);
+    int vertical=checarVertical(tablero); 
+    int submatriz=checarSubmatriz(tablero);
+    //Se analizan las banderas
+    if (horizontal==1 && submatriz==1 && vertical==1){
+        //Si el resultado es positivo se le notifica al usuario
+        printf("\tFelicidades es un SUDOKU\t");
+    }
+    else {
+        //Si el resultado es negativo se le notifica al usuario
+        printf("\tLo siento, no es un SUDOKU\t");
+    }
+}
diff --git a/ADAS/Canul/Ada6-Racionales.c b/ADAS/Canul/Ada6-Racionales.c
new file mode 100644
index 0000000..0b3962b
--- /dev/null
+++ b/ADAS/Canul/Ada6-Racionales.c
@@ -0,0 +1,137 @@
+#include <stdio.h>
+/* Ejercicio que recibe dos numeros racionales (fracciones) y realiza 4 operaciones basicas:
+1.Suma
+2.Resta
+3.Multiplicacion
+4.Division
+Para resolverlo utiliza estructura de datos
+Autor: Pamela Canul*/
+
+//Se define la estructura del racional 
+typedef struct racional
+{
+    int numerador; 
+    int denominador; 
+}racional; 
+
+//Prototipos de las fuciones a utilizar
+void leerRacional (racional* );
+racional sumarRacionales (racional r1, racional r2);
+racional restarRacionales (racional r1,racional r2); 
+racional multiplicarRacionales (racional r1, racional r2); 
+racional dividirRacionales (racional r1, racional r2);
+void simplificarRacional (racional *); 
+void imprimirRacional (racional r3); 
+
+int main (){
+    racional r1, r2, r3; 
+
+    //Funcion para leer los racionales
+    leerRacional (&r1);
+    leerRacional (&r2);
+
+    /*Funciones para las operaciones*/
+    sumarRacionales (r1, r2);
+    restarRacionales (r1, r2);
+    multiplicarRacionales (r1, r2); 
+    dividirRacionales (r1, r2);
+
+    //Simplificar e imprimir los resultados
+    printf("Suma: \n"); 
+    imprimirRacional(sumarRacionales(r1, r2)); 
+    printf("Resta: \n"); 
+    imprimirRacional(restarRacionales(r1, r2));
+    printf("Multiplicacion: \n"); 
+    imprimirRacional(multiplicarRacionales(r1, r2));
+    printf("Division: \n"); 
+    imprimirRacional(dividirRacionales(r1, r2));
+
+    return 0;    
+}
+
+//Leer los racionales
+void leerRacional( racional* raci){
+	printf("Ingrese el numerador: \n");
+    scanf("%d",&raci->numerador);
+    printf("Ingrese el denominador: \n");
+    scanf("%d",&raci->denominador);
+} 
+
+//Sumar los racionales
+racional sumarRacionales (racional r1, racional r2) {
+    racional r3;
+    int numerador, denominador; 
+    numerador= (r1.numerador*r2.denominador)+(r1.denominador*r2.numerador); 
+    denominador=r1.denominador*r2.denominador; 
+    r3.numerador=numerador; 
+    r3.denominador=denominador;
+    simplificarRacional(&r3);
+    return r3; 
+}
+
+//Restar los racionales
+racional restarRacionales (racional r1, racional r2) {
+    racional r3;
+    int numerador, denominador; 
+    numerador= (r1.numerador*r2.denominador)-(r1.denominador*r2.numerador); 
+    denominador=r1.denominador*r2.denominador; 
+    r3.numerador=numerador; 
+    r3.denominador=denominador;
+    simplificarRacional(&r3);
+    return r3; 
+}
+
+//Multiplicar los racionales 
+racional multiplicarRacionales (racional r1, racional r2) {
+    racional r3;
+    int numerador, denominador; 
+    numerador= r1.numerador*r2.numerador; 
+    denominador=r1.denominador*r2.denominador; 
+    r3.numerador=numerador; 
+    r3.denominador=denominador;
+    simplificarRacional(&r3);
+    return r3; 
+}
+
+//Dividir racional
+racional dividirRacionales (racional r1, racional r2) { 
+    racional r3; 
+    int numerador, denominador; 
+    numerador= r1.numerador * r2.denominador;
+    denominador= r1.denominador * r2.numerador; 
+    r3.numerador=numerador; 
+    r3.denominador=denominador; 
+    simplificarRacional(&r3); 
+    return r3; 
+}
+
+//simplificar el racional resultante 
+void simplificarRacional (racional *raci) {
+    int simp=2;
+    while (simp<=(*raci).numerador  || simp<=(*raci).denominador){
+        if ((*raci).numerador%simp==0 && (*raci).denominador%simp==0){
+            (*raci).numerador=(*raci).numerador/simp;
+            (*raci).denominador=(*raci).denominador/simp;
+        }
+        else {
+            simp++;
+        }
+    }
+}
+
+//Imprimir el racional resultante 
+void imprimirRacional (racional r3) { 
+    //Para imprimirlo se considerara todos los casos, por ejemplo si el numerador es igual a cero o si el denominador es igual a uno o si el numerador y el denominador son iguales
+    //Numerador igual a cero
+    if(r3.numerador==0){
+        printf("0\n");
+        //si el numerador es igual al denominador, si el denominador es igual a 1 o el resultado simplivicado
+    }else {
+        if(r3.numerador==r3.denominador){
+            printf("1\n");
+    }else if(r3.denominador==1){
+        printf("%d\n",r3.numerador);
+    }else { 
+        printf("%d/%d\n",r3.numerador,r3.denominador);
+    }
+}
diff --git a/ADAS/Canul/Ejercicio26Marzo.c b/ADAS/Canul/Ejercicio26Marzo.c
new file mode 100644
index 0000000..41d3b8e
--- /dev/null
+++ b/ADAS/Canul/Ejercicio26Marzo.c
@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#define N 3
+
+//ADA 4 visualizar region (2 y 4) y region (1 y 3)
+//Autor: Pamela Canul Chacon
+
+void asignarArreglo (int arr [][N]);
+void imprimirArreglo (int arr [][N]);
+void recorrerMatriz24 (int arr [][N]);
+void recorrerMatriz13 (int arr [][N]);
+
+int main () {
+	int arreglo[N][N];
+	time_t t; 
+	/* inicializacion del generador de numeros random*/
+	srand((unsigned) time(&t));
+	
+	asignarArreglo(arreglo);
+	imprimirArreglo(arreglo); 
+	recorrerMatriz24 (arreglo); 
+	recorrerMatriz13 (arreglo); 
+	
+	return(0);
+}
+
+/*asignar valores a la matriz*/
+void asignarArreglo(int arr[][N]){
+	for (int i = 0; i < N; i++){
+		for (int j = 0; j < N; j++){
+			arr[i][j] = rand() % 10;
+		}
+	}
+}
+	
+/*Imprimir la matriz */	
+void imprimirArreglo (int arr[][N]){
+	for(int i = 0; i < N; i++) {
+		for(int j = 0; j < N; j++) {
+			printf(" %d ",  arr[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
+	
+/*Recorrer Matriz 24 */ 
+void recorrerMatriz24 (int arr [][N]) {
+	printf("Region 2 y 4\n");
+	for(int i = 0; i<N; i++) {
+		for(int j=0; j<N;j++){
+			if(j<N-i && j>=i) { 
+				printf("%d ", arr[i][j]);
+				printf("\t");
+			}
+			else if (i>(N-1)/2 && j>=N-1-i && j<=i) {
+				printf("%d", arr[i][j]);
+				printf("\t");
+			}
+			else {
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+
+/*Recorrer Matriz 24 */ 
+void recorrerMatriz13 (int arr [][N]) { 
+	printf("Region 1 y 3\n");
+	for(int i=0; i<N; i++){
+		for(int j=0;j<N;j++){
+			if (j<=N/2){
+				if (j<=(N-1)/2 && j<=i && j<=N-1-i) {
+					printf("%d", i,j, arr[i][j]);
+					printf("\t");
+				}
+				else { 
+					printf("\t");
+				}
+			}
+			else {
+				if ( j>=i && j>=N-1-i && j>=(N-1)/2){
+					printf("%d",  arr[i][j]);
+					printf("\t");
+				}
+				else { 
+					printf("\t");
+				}
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+}
diff --git a/ADAS/Correa/ADA4.c b/ADAS/Correa/ADA4.c
new file mode 100644
index 0000000..26d9088
--- /dev/null
+++ b/ADAS/Correa/ADA4.c
@@ -0,0 +1,319 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define M 5
+//ADA 4
+//Autor Audny Desiree Correa Ceballos
+void asignarValores(int arr[][M]);
+void imprimirArreglo(int arr[][M]);
+void imprimirR1R2(int arr[][M]);
+void imprimirR2R1(int arr[][M]);
+void imprimirR3R4(int arr[][M]);
+void imprimirR4R3(int arr[][M]);
+void imprimirDiagonalPrincipal(int arr[][M]);
+void imprimirDiagonalInversa(int arr[][M]);
+void imprimirR1R4(int arr[][M]);
+void imprimirR4R1(int arr[][M]);
+void imprimirR2R3(int arr[][M]);
+void imprimirR3R2(int arr[][M]);
+void imprimirRegion1(int arr[][M]);
+void imprimirRegion1Descendente(int arr[][M]);
+void imprimirRegion2(int arr[][M]);
+void imprimirRegion2Descendente(int arr[][M]);
+void imprimirRegion3(int arr[][M]);
+void imprimirRegion3Descendente(int arr[][M]);
+void imprimirRegion4(int arr[][M]);
+void imprimirRegion4Descendente(int arr[][M]);
+
+
+int main(){
+	int arreglo[M][M];
+	time_t t;
+	srand((unsigned) time(&t));
+	asignarValores(arreglo);
+	imprimirArreglo(arreglo);
+	imprimirR1R2(arreglo);
+	imprimirR2R1(arreglo);
+	imprimirR3R4(arreglo);
+	imprimirR4R3(arreglo);
+	imprimirR1R4(arreglo);
+	imprimirR4R1(arreglo);
+	imprimirR2R3(arreglo);
+	imprimirR3R2(arreglo);
+	imprimirDiagonalPrincipal(arreglo);
+	imprimirDiagonalInversa(arreglo);
+	imprimirRegion1(arreglo);
+	imprimirRegion1Descendente(arreglo);
+	imprimirRegion2(arreglo);
+	imprimirRegion2Descendente(arreglo);
+	imprimirRegion3(arreglo);
+	imprimirRegion3Descendente(arreglo);
+	imprimirRegion4(arreglo);
+	imprimirRegion4Descendente(arreglo);
+	
+}
+
+void asignarValores(int arr[][M]){
+	int i, j;
+	for(j=0; j<M; j++){
+		for(i=0; i<M; i++){
+			arr[i][j]= rand()%10;
+		}
+	}
+}
+
+void imprimirArreglo(int arr[][M]){
+	int i,j;
+    for(i = 0; i < M; i++){
+    	for(j = 0; j < M; j++){
+    		printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+   }  
+}
+
+void imprimirR1R2(int arr[][M]){
+	int i, j;
+	// va desde la fila 0 hasta M-1
+	printf("Region 1-2\n");
+	for(i=0; i<M; i++){
+		for(j=0; j<(M- i); j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR2R1(int arr[][M]){
+	int i, j;
+	//Va desde la fila M-1 hasta 0 
+	printf("Region 2-1\n");
+	for(j=0; j<M; j++){
+		for(i=M-1; i>=(M-j-1); i--){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR3R4(int arr[][M]){
+	int i,j;
+	// va desde la fila 0 hasta M-1
+	printf("Region 3-4\n");
+	for(i=0; i<M;i++){
+		for(j=(M-1-i);j<=(M-1);j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR4R3(int arr[][M]){
+	int i,j;
+	//Va desde la fila M-1 hasta 0
+	printf("Region 4-3\n");
+	for(i=(M-1);i>=0;i--){
+		for(j=(M-1-i);j<=(M-1);j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+void imprimirR1R4(int arr[][M]){
+	int i, j;
+	//Va de la fila 0 hasta M-1
+	printf("Region 1-4\n");
+	for(i=0; i<M; i++){
+		for(j=0; j<=i;j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR4R1(int arr[][M]){
+	int i,j;
+	//Va de la fila M-1 hasta 0
+	printf("Region 4-1\n");
+	for(i=(M-1);i>=0;i--){
+		for(j=0;j<=i;j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR2R3(int arr[][M]){
+	int i, j;
+	//va dede la fila M-1 hasta la fila 0
+	printf("Region 2-3\n");
+	for(i=0; i<M; i++){
+		for(j=i; j<=(M-1); j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR3R2(int arr[][M]){
+	int i,j;
+	// va desde la fila 0 hasta M-1
+	printf("Region 3-2\n");
+	for(i=(M-1);i>=0;i--){
+		for(j=i;j<=(M-1);j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirDiagonalPrincipal(int arr[][M]){
+	int i, j;
+	printf("Diagonal Principal\n");
+	for(i=0; i<M;i++){
+		for(j=0;j<M;j++){
+			if (i==j){
+				printf("(%d,%d:%d)",i,j, arr[i][j]);
+			}else{
+				printf(" ");
+			}
+		}
+		printf("\n");
+	}
+}
+
+void imprimirDiagonalInversa(int arr[][M]){
+	int i, j;
+	printf("Diagonal inversa\n");
+	for(i=0; i<M;i++){
+		for(j=0;j<(M-i);j++){
+			if(j==(M-i-1)){
+				printf("(%d,%d:%d)",i,j, arr[i][j]);
+			}else{
+				printf(" ");
+			}
+		}
+		printf("\n");
+	}
+}
+void imprimirRegion1(int arr[][M]){
+	int i,j;
+	// desde fila 0 hasta M-1
+	printf("Region 1\n");
+	for(i=0;i<=2;i++){
+		for(j=0; j<=i; j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);	
+		}
+		printf("\n");
+	}
+	for(i=3;i<=4;i++){
+		for(j=0;j<=(M-i-1);j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);	
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion1Descendente(int arr[][M]){
+	int i,j;
+	//fila M-1 hasta 0
+	printf("Region 1 descendente\n");
+	for(i=(M-1);i>=2;i--){
+		for(j=0;j<=(M-i-1);j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}	
+	for(i=1;i>=0;i--){
+		for(j=0;j<=i;j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion2(int arr[][M]){
+	int i, j;
+	// fila 0 hasta (M-1)/2
+	printf("Region 2\n");
+	for(i=0; i<=2/* Este es mi (M-1)/2*/; i++){
+		for(j=i;j<(M-i); j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion2Descendente(int arr[][M]){
+	int i,j;
+	//fila (M-1)/2 hasta 0
+	printf("Region 2 descentente\n");
+	for (i=((M-1)/2);i>=0;i--){
+		for(j=i;j<(M-i);j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion3(int arr[][M]){
+	int i,j;
+	//fila 0 hasta M-1
+	printf("Region 3\n");
+	for(i=0;i<=2;i++){
+		for(j=(M-1-i);j<=(M-1);j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+	for(i=3;i<=4;i++){
+		for(j=i;j<=4;j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion3Descendente(int arr[][M]){
+	int i,j;
+	//Fila M-1 hasta 0
+	printf("Region 3 descendente\n");
+	for(i=(M-1);i>=2;i--){
+		for(j=i;j<=(M-1);j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+	for(i=1;i>=0;i--){
+		for(j=(M-1-i);j<=(M-1);j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion4(int arr[][M]){
+	int i, j;
+	//fila (M-1)/2 hasta M-1
+	printf("Region 4\n");
+	for(i=((M-1)/2); i<M; i++){
+		for(j=(M-i-1);j<=i;j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion4Descendente(int arr[][M]){
+	int i,j;
+	//fila M-1 hasta (M-1)/2
+	printf("Region 4 descentente\n");
+	for(i=(M-1);i>=((M-1)/2);i--){
+		for(j=(M-1-i);j<=i;j++){
+			printf("(%d,%d:%d)",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+	
+}
diff --git a/ADAS/Correa/ADA4Visualizacion.c b/ADAS/Correa/ADA4Visualizacion.c
new file mode 100644
index 0000000..5faffa1
--- /dev/null
+++ b/ADAS/Correa/ADA4Visualizacion.c
@@ -0,0 +1,369 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define M 5
+//ADA 4 con visualizacion
+//Autor Audny Desiree Correa Ceballos
+void asignarValores(int arr[][M]);
+void imprimirArreglo(int arr[][M]);
+void imprimirR1R2(int arr[][M]);
+void imprimirR2R1(int arr[][M]);
+void imprimirR3R4(int arr[][M]);
+void imprimirR4R3(int arr[][M]);
+void imprimirDiagonalPrincipal(int arr[][M]);
+void imprimirDiagonalInversa(int arr[][M]);
+void imprimirR1R4(int arr[][M]);
+void imprimirR4R1(int arr[][M]);
+void imprimirR2R3(int arr[][M]);
+void imprimirR3R2(int arr[][M]);
+void imprimirRegion1(int arr[][M]);
+void imprimirRegion1Descendente(int arr[][M]);
+void imprimirRegion2(int arr[][M]);
+void imprimirRegion2Descendente(int arr[][M]);
+void imprimirRegion3(int arr[][M]);
+void imprimirRegion3Descendente(int arr[][M]);
+void imprimirRegion4(int arr[][M]);
+void imprimirRegion4Descendente(int arr[][M]);
+
+
+int main(){
+	int arreglo[M][M];
+	time_t t;
+	srand((unsigned) time(&t));
+	asignarValores(arreglo);
+	imprimirArreglo(arreglo);
+	imprimirR1R2(arreglo);
+	imprimirR2R1(arreglo);
+	imprimirR3R4(arreglo);
+	imprimirR4R3(arreglo);
+	imprimirR1R4(arreglo);
+	imprimirR4R1(arreglo);
+	imprimirR2R3(arreglo);
+	imprimirR3R2(arreglo);
+	imprimirDiagonalPrincipal(arreglo);
+	imprimirDiagonalInversa(arreglo);
+	imprimirRegion1(arreglo);
+	imprimirRegion1Descendente(arreglo);
+	imprimirRegion2(arreglo);
+	imprimirRegion2Descendente(arreglo);
+	imprimirRegion3(arreglo);
+	imprimirRegion3Descendente(arreglo);
+	imprimirRegion4(arreglo);
+	imprimirRegion4Descendente(arreglo);
+	
+}
+
+void asignarValores(int arr[][M]){
+	int i, j;
+	for(j=0; j<M; j++){
+		for(i=0; i<M; i++){
+			arr[i][j]= rand()%10;
+		}
+	}
+}
+
+void imprimirArreglo(int arr[][M]){
+	int i,j;
+    for(i = 0; i < M; i++){
+    	for(j = 0; j < M; j++){
+    		printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+		}
+		printf("\n");
+   }  
+}
+
+void imprimirR1R2(int arr[][M]){
+	int i, j;
+	// va desde la fila 0 hasta M-1
+	printf("Region 1-2\n");
+	for(i=0; i<M; i++){
+		for(j=0; j<(M- i); j++){
+			printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR2R1(int arr[][M]){
+	int i, j;
+	//Va desde la fila M-1 hasta 0 
+	printf("Region 2-1\n");
+	for(j=0; j<M; j++){
+		for(i=M-1; i>=(M-j-1); i--){
+			printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR3R4(int arr[][M]){
+	int i,j;
+	// va desde la fila 0 hasta M-1
+	printf("Region 3-4\n");
+	for(i=0; i<M;i++){
+		for(j=0; j<M;j++){
+			if(j>= M-i-1){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR4R3(int arr[][M]){
+	int i,j;
+	//Va desde la fila M-1 hasta 0
+	printf("Region 4-3\n");
+	for(i=(M-1);i>=0;i--){
+		for(j=0;j<=(M-1);j++){
+			if(j>= M-1-i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+void imprimirR1R4(int arr[][M]){
+	int i, j;
+	//Va de la fila 0 hasta M-1
+	printf("Region 1-4\n");
+	for(i=0; i<M; i++){
+		for(j=0; j<=i;j++){
+			printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR4R1(int arr[][M]){
+	int i,j;
+	//Va de la fila M-1 hasta 0
+	printf("Region 4-1\n");
+	for(i=(M-1);i>=0;i--){
+		for(j=0;j<=i;j++){
+			printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR2R3(int arr[][M]){
+	int i, j;
+	//va dede la fila M-1 hasta la fila 0
+	printf("Region 2-3\n");
+	for(i=0; i<M; i++){
+		for(j=0; j<=(M-1); j++){
+			if(j>=i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR3R2(int arr[][M]){
+	int i,j;
+	// va desde la fila 0 hasta M-1
+	printf("Region 3-2\n");
+	for(i=(M-1);i>=0;i--){
+		for(j=0;j<=(M-1);j++){
+			if(j>=i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+
+void imprimirDiagonalPrincipal(int arr[][M]){
+	int i, j;
+	printf("Diagonal Principal\n");
+	for(i=0; i<M;i++){
+		for(j=0;j<M;j++){
+			if (i==j){
+				printf("(%d,%d:%d)",i,j, arr[i][j]);
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+
+void imprimirDiagonalInversa(int arr[][M]){
+	int i, j;
+	printf("Diagonal inversa\n");
+	for(i=0; i<M;i++){
+		for(j=0;j<(M-i);j++){
+			if(j==(M-i-1)){
+				printf("(%d,%d:%d)",i,j, arr[i][j]);
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+void imprimirRegion1(int arr[][M]){
+	int i,j;
+	// desde fila 0 hasta M-1
+	printf("Region 1\n");
+	for(i=0;i<=(M-1)/2;i++){
+		for(j=0; j<=i; j++){
+			printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+		}
+		printf("\n");
+	}
+	for(i=((M-1)/2)+1;i<=M-1;i++){
+		for(j=0;j<=(M-i-1);j++){
+			printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion1Descendente(int arr[][M]){
+	int i,j;
+	//fila M-1 hasta 0
+	printf("Region 1 descendente\n");
+	for(i=(M-1);i>=2;i--){
+		for(j=0;j<=(M-i-1);j++){
+			printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}	
+	for(i=1;i>=0;i--){
+		for(j=0;j<=i;j++){
+			printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion2(int arr[][M]){
+	int i, j;
+	// fila 0 hasta (M-1)/2
+	printf("Region 2\n");
+	for(i=0; i<=(M-1)/2/* Este es mi (M-1)/2*/; i++){
+		for(j=0;j<M; j++){
+			if(j>= i && j<M-i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}	
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion2Descendente(int arr[][M]){
+	int i,j;
+	//fila (M-1)/2 hasta 0
+	printf("Region 2 descentente\n");
+	for (i=(M-1)/2;i>=0;i--){
+		for(j=0;j<M;j++){
+			if(j>=i && j<M-i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion3(int arr[][M]){
+	int i,j;
+	//fila 0 hasta M-1
+	printf("Region 3\n");
+	for(i=0;i<=(M-1)/2;i++){
+		for(j=0;j<=(M-1);j++){
+			if(j>=M-1-i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+	for(i=((M-1)/2)+1;i<=M-1;i++){
+		for(j=0;j<=4;j++){
+			if(j>=i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion3Descendente(int arr[][M]){
+	int i,j;
+	//Fila M-1 hasta 0
+	printf("Region 3 descendente\n");
+	for(i=(M-1);i>=(M-1)/2;i--){
+		for(j=0;j<=(M-1);j++){
+			if(j>=i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}	
+		}
+		printf("\n");
+	}
+	for(i=((M-1)/2)-1;i>=0;i--){
+		for(j=0;j<=(M-1);j++){
+			if(j>=M-i-1){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}
+			
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion4(int arr[][M]){
+	int i, j;
+	//fila (M-1)/2 hasta M-1
+	printf("Region 4\n");
+	for(i=(M-1)/2; i<M; i++){
+		for(j=0;j<M;j++){
+			if(j>=M-i-1 && j<=i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+
+void imprimirRegion4Descendente(int arr[][M]){
+	int i,j;
+	//fila M-1 hasta (M-1)/2
+	printf("Region 4 descentente\n");
+	for(i=(M-1);i>=(M-1)/2;i--){
+		for(j=0;j<M;j++){
+			if(j>=M-i-1 && j<=i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+	
+}
+
diff --git a/ADAS/Correa/ADA5Racionales.c b/ADAS/Correa/ADA5Racionales.c
new file mode 100644
index 0000000..e67a5f1
--- /dev/null
+++ b/ADAS/Correa/ADA5Racionales.c
@@ -0,0 +1,127 @@
+#include <stdio.h>
+//Codigo que recibe don numeros racionales, utilizando estructuras de datos y 
+//devuelve el resultado de las cuatro operaciones basicas 
+
+//Definir la estructura
+typedef struct racional{
+    int numerador;
+    int denominador;
+} racional;
+
+//Prototipos
+void leerRacional(racional* );
+racional sumarRacionales( racional, racional);
+racional restarRacionales( racional, racional);
+racional multiplicarRacionales( racional, racional);
+racional dividirRacionales(racional, racional);
+void simplificarRacional(racional* );
+void imprimirRacional(racional ); 
+
+int main(){
+    struct racional r1, r2;
+    //Funciones de lectura de datos
+    leerRacional(&r1);
+    leerRacional(&r2);
+    //Funciones de operacion
+    sumarRacionales(r1,r2);
+    restarRacionales(r1,r2);
+    multiplicarRacionales(r1,r2);
+    dividirRacionales(r1,r2);
+    //Funciones de impresion
+    printf("Resultado de la suma: \n");
+    imprimirRacional(sumarRacionales(r1,r2));
+    printf("Resultado de la resta: \n");
+    imprimirRacional(restarRacionales(r1,r2));
+    printf("Resultado de la multiplicacion: \n");
+    imprimirRacional(multiplicarRacionales(r1,r2));
+    printf("Resultado de la division: \n");
+    imprimirRacional(dividirRacionales(r1,r2));
+
+}
+
+void leerRacional( racional* rac){
+	printf("Ingrese el numerador: \n");
+    scanf("%d",&rac->numerador);
+    printf("Ingrese el denominador: \n");
+    scanf("%d",&rac->denominador);
+}
+
+
+racional sumarRacionales(racional r1, racional r2){
+    racional resultado;
+    int numerador, denominador;
+    numerador=r1.numerador*r2.denominador+r1.denominador*r2.numerador;
+    denominador=r1.denominador*r2.denominador;
+    resultado.numerador=numerador;
+    resultado.denominador=denominador;
+    simplificarRacional(&resultado);
+    return resultado;
+}
+
+racional restarRacionales(racional r1, racional r2){
+    racional resultado;
+    int numerador, denominador;
+    numerador=r1.numerador*r2.denominador-r1.denominador*r2.numerador;
+    denominador=r1.denominador*r2.denominador;
+    resultado.numerador=numerador;
+    resultado.denominador=denominador;
+    simplificarRacional(&resultado);
+    return resultado;
+}
+
+racional multiplicarRacionales(racional r1, racional r2){
+    racional resultado;
+    int numerador, denominador;
+    numerador=r1.numerador*r2.numerador;
+    denominador=r1.denominador*r2.denominador;
+    resultado.numerador=numerador;
+    resultado.denominador=denominador;
+    simplificarRacional(&resultado);
+    return resultado;
+}
+
+racional dividirRacionales(racional r1, racional r2){
+    racional resultado;
+    int numerador, denominador;
+    numerador=r1.numerador*r2.denominador;
+    denominador=r1.denominador*r2.numerador;
+    resultado.numerador=numerador;
+    resultado.denominador=denominador;
+    simplificarRacional(&resultado);
+    return resultado;
+}
+
+void simplificarRacional(racional* rac){
+    int aux=2;
+    while (aux<=rac->numerador || aux<=rac->denominador)
+    {
+        if (rac->numerador%aux==0 && rac->denominador%aux==0)
+        {
+            rac->numerador=rac->numerador/aux;
+            rac->denominador=rac->denominador/aux;
+        }else{
+            aux++;
+        }
+        
+    }
+    
+}
+
+void imprimirRacional(racional resultado){
+	//Si el numerador es 0, independientemente del valor del denominador el numero va ser 0
+	if(resultado.numerador==0){
+		printf("0\n");
+	}else{
+		// Si el numeraador es igual al denominador significa que es un entero con valor igual a 1
+		if (resultado.numerador==resultado.denominador){
+        	printf("1\n");
+    	}else if (resultado.denominador==1){ 
+    		//Si el denominador es 1 significa que es un entero con valor igual al numerador
+    		printf("%d\n",resultado.numerador);
+		}else{
+			//Este es un racional reducido en su maxima expresion 
+        	printf("%d/%d\n", resultado.numerador, resultado.denominador);
+    	}
+	}
+    	
+}
diff --git a/ADAS/Correa/ADA6-BusquedaBinaria.c b/ADAS/Correa/ADA6-BusquedaBinaria.c
new file mode 100644
index 0000000..477aa68
--- /dev/null
+++ b/ADAS/Correa/ADA6-BusquedaBinaria.c
@@ -0,0 +1,394 @@
+//Programa que almacena la lista con las expresiones booleanas, ordenadas de acuerdo a 
+// la fecha en las cuales se registraron
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct fecha{
+    int dd;
+    int mm;
+    int aaaa;
+}Fecha;
+
+typedef struct dato{
+    char expresion[121];
+    Fecha FECHA;
+}Dato;
+
+typedef struct nodo{
+    Dato info;
+    struct nodo *siguienteNodo;
+}Nodo;
+
+typedef Nodo *nodoApuntador;
+
+int seleccionarMenu();
+void leerFecha(int*, int*, int*);
+int EsBisiesto(int );
+void insertarOrdenada(nodoApuntador *, int, int, int, char*);
+void continuar(int *);
+void borrarLista(nodoApuntador *, int* );
+void imprimirLista(Nodo);
+void busquedaBinaria(nodoApuntador *);
+int contarNodos(nodoApuntador *);
+void seleccionarFecha(int *,int *, int *);
+void definirMitad(int *, int *, int *);
+int compareTo(nodoApuntador* ,int *, int*, int*); //////////////////////
+void imprimirNodBuscado(nodoApuntador);
+
+return main(){
+    nodoApuntador nodoCabecera=NULL;
+    int opcionSeleccionada,dia,mes,anio,tamanio,cont=0, bandera=1, cantidad;
+    char cad[121], *cadena;
+    opcionSeleccionada=seleccionarMenu();
+    while (opcionSeleccionada != 1 && cont==0)
+    {
+        if (opcionSeleccionada == 2)
+        {
+            printf("No hay listas que borrar\n");
+
+        }else
+        {
+            printf("No hay listas que imprimir\n");
+        }
+        
+    }
+    if (opcionSeleccionada == 1){
+        while(bandera==1){
+            leerFecha(&dia,&mes,&anio);
+            printf("Ingrese la expresion booleana\n");
+            gets(cad);
+            tamanio= strlen(cad);
+            cadena =(char* )malloc((tamanio+1)* sizeof(char));
+            strcpy(cadena,cad);
+            insertarOrdenado(&nodoCabecera,dia,mes,anio,&cadena);
+            cont +=1;
+            continuar(&bandera);
+        }
+    }
+    if (opcionSeleccionada == 2 && cont!= 0 ){
+        borrarLista(&nodoCabecera,&cont);
+    }
+    //Busqueda binaria
+    busquedaBinaria(&nodoCabecera);
+
+    imprimirLista(nodoCabecera);
+
+    return 0;
+}
+
+
+int seleccionarMenu(){
+    int opcion;
+    printf("\t MENU \t");
+    printf("1 Añadir a la lista\n");
+    printf("2 Borrar lista\n");
+    printf("3 Imprimir lista\n");
+    printf("Selecciona una opcion\n");
+    scanf("%d",&opcion);
+
+    while (opcion<1 || opcion>3){
+        printf("Opcion no valida, seleccione otra opcion\n");
+        scanf("%d", &opcion);
+    }
+    return opcion;
+}
+
+void leerFecha(int *dia, int *mes, int *anio){
+    int respuesta;
+    printf("Ingrese año(aaaa):");
+    scanf("%d",anio);
+    while (*anio<0 || *anio>2020){
+        printf("Año invalido, ingrese otro:");
+        scanf("%d",anio);
+    }
+    printf("Ingrese mes (mm):");
+    scanf("%d",mes);
+    while(*mes<1 || *mes>12){
+        printf("Mes invalido, ingrese otro:");
+        scanf("%d", mes);
+    }
+    printf("Inserte dia (dd):");
+    scanf("%d",dia);
+    respuesta=EsBisiesto(anio);
+    if (respuesta==0){
+        if(*mes==2){
+            while (*dia<1 || *dia>28){
+                printf("Inserte dia (dd):");
+                scanf("%d",dia);
+            }
+        }else if (*mes >= 1 || *mes<=7 && *mes !=2){
+            if (*mes%2==1){
+                while (*dia<1 || *dia>31){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }else{
+                while (*dia<1 || *dia>30){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }
+            
+        }else if( *mes>7 || *mes<=12 && *mes != 2){
+            if (*mes%2==1){
+                while (*dia<1 || *dia>30){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }else{
+                while (*dia<1 || *dia>31){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }
+
+        }
+        
+
+    }else{
+        if(*mes==2){
+            while (*dia<1 || *dia>29){
+                printf("Inserte dia (dd):");
+                scanf("%d",dia);
+            }
+        }else if (*mes >= 1 || *mes<=7 && *mes !=2){
+            if (*mes%2==1){
+                while (*dia<1 || *dia>31){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }else{
+                while (*dia<1 || *dia>30){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }
+            
+        }else if( *mes>7 || *mes<=12 && *mes != 2){
+            if (*mes%2==1){
+                while (*dia<1 || *dia>30){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }else{
+                while (*dia<1 || *dia>31){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }
+
+        }
+
+    }
+}
+
+int EsBisiesto(int anio_){
+    if (anio_%4==0){
+        if (anio_%100==0){
+            if (anio_%400==0){
+                return 1;
+            }else{
+                return 0;
+            }
+    else{
+        return 0;
+    }
+}
+
+void insertarOrdenado(nodoApuntador *nodoPtr, int dd_, int mm_, int aaaa_, char *exp){
+    nodoApuntador nuevoNodo, nodoActual = *nodoPtr , antiguoNodo = NULL;
+    nuevoNodo =(Nodo*)malloc(sizeof(Nodo));
+    if (nuevoNodo != NULL){
+        strcpy(nuevoNodo ->info.expresion,exp);
+        nuevoNodo -> info.FECHA.dd = dd_;
+        nuevoNodo -> info.FECHA.mm = mm_;
+        nuevoNodo -> info.FECHA.aaaa = aaaa_;
+        nuevoNodo -> siguienteNodo=NULL;
+
+        if (aaaa_!= nodoActual-> info.FECHA.aaaa){
+            while (nodoActual != NULL && aaaa_>nodoActual-> info.FECHA.aaaa){
+                antiguoNodo = nodoActual;
+                nodoActual = nodoActual-> siguienteNodo;
+            }
+            if (antiguoNodo==NULL){
+                nuevoNodo ->siguienteNodo = *nodoPtr;
+                *nodoPtr = nuevoNodo;
+            }else{
+                antiguoNodo->siguienteNodo = nuevoNodo;
+                nuevoNodo ->siguienteNodo = nodoActual;
+            }
+        }else if(mm_ != nodoActual->info.FECHA.mm){
+            while (nodoActual != NULL && mm_>nodoActual-> info.FECHA.mm){
+                antiguoNodo = nodoActual;
+                nodoActual = nodoActual-> siguienteNodo;
+            }
+            if (antiguoNodo==NULL){
+                nuevoNodo ->siguienteNodo = *nodoPtr;
+                *nodoPtr = nuevoNodo;
+            }else{
+                antiguoNodo->siguienteNodo = nuevoNodo;
+                nuevoNodo ->siguienteNodo = nodoActual;
+            }
+        }else{
+            while (nodoActual != NULL && dd_>nodoActual-> info.FECHA.dd){
+                antiguoNodo = nodoActual;
+                nodoActual = nodoActual-> siguienteNodo;
+            }
+            if (antiguoNodo==NULL){
+                nuevoNodo ->siguienteNodo = *nodoPtr;
+                *nodoPtr = nuevoNodo;
+            }else{
+                antiguoNodo->siguienteNodo = nuevoNodo;
+                nuevoNodo ->siguienteNodo = nodoActual;
+            }
+        }
+    }else{
+        printf("No hay memoria\n");
+    }
+}
+
+void continuar(int *bandera){
+    int eleccion;
+    printf("Desea insertar otra expresion?\n");
+    prinf("Seleccione un numero: 1. Sí/ 2. No\n");
+    scanf("%d", &eleccion);
+    while (eleccion<1 || eleccion>2){
+        printf("Eleccion invalida, seleccione un numero\n");
+        scanf("%d", &eleccion);
+    }
+    if (eleccion==1){
+        *bandera =1;
+    }else{
+        *bandera=0;
+    }
+    
+
+}
+void borrarLista(nodoApuntador *nodoPtr, int* cont_){
+    Nodo nodoTemporal, nodoActual = *nodoPtr;
+    int aaaa,mm,dd;
+    printf("Ingrese la fecha de la expresion que desea borrar\n");
+    printf("Año(aaaa):");
+    scanf("%d",&aaaa);
+    printf("Mes(mm):");
+    scanf("%d",&mm);
+    printf("Dia(dd):");
+    scanf("%d",&dd);
+    if(nodoActual->info.FECHA.aaaa==aaaa && nodoActual->info.FECHA.mm==mm && nodoActual->info.FECHA.dd==dd){
+        nodoTemporal=nodoActual;
+        *nodoPtr=nodoActual->siguienteNodo;
+        nodoTemporal->siguienteNodo = NULL;
+        free(nodoTemporal);
+        *cont-=1;
+    }else{
+        printf("No existe esa fecha\n");
+    }
+}
+
+void imprimirLista(nodoActual){
+    if (nodoActual == NULL){
+        printf("Lista vacia\n");
+    }else{
+        printf("\t LISTA\t");
+        while(nodoActual != NULL){
+            printf("Expresion: %s\n",nodoActual->info.expresion);
+            printf("Fecha: %d / %d / %d", nodoActual->info.FECHA.dd,nodoActual->info.FECHA.mm, nodoActual->info.FECHA.aaaa);
+            nodoActual = nodoActual->siguienteNodo;
+        }
+        printf("\n");
+    }
+}
+
+int contarNodos(nodoContador *nodoPtr){
+    int cantidadNodos=0;
+    while(nodoPtr->siguienteNodo != NULL){
+        cantidadNodos +=1;
+        nodoPtr = nodoPtr->siguienteNodo;
+    }
+    return cantidadNodos;
+}
+
+void busquedaBinaria(nodoApuntador *nodoPtr){
+    int i,cantidad, dd, mm, aaaa, izq, der, mitad, acomodador, bandera =0;
+    cantidad = contarNodos(&nodoPtr);
+    der = cantidad;
+    mitad=(izq+der)/2;
+    seleccionarFecha(&aaaa,&mm,&dd);
+    
+    while(izq<=der){
+        acomodador = compareTo(&nodoPtr,&aaaa,&mm, &dd);  
+        if (acomodador==1){
+            izq = mitad + 1;
+            definirmitad(&mitad, &izq, &der);
+        } else if(acomodador== -1){
+            der = mitad -1;
+            definirmitad(&mitad, &izq, &der);
+        }else if( acomodador ==0){
+            for(i=0;i<mitad;i++){
+                nodoPtr= nodoPtr->siguienteNodo;
+            }
+            bandera =0;
+            break;
+        }
+    }
+    if (bandera==0){
+        imprimirNodoBuscado(nodoPtr);
+    }else{
+        imprimirNodoBuscado(NULL);
+    }
+    
+}
+void definirMitad(int *mid, int *izquierda, int *derecha){
+    *mid = *(izquierda + derecha)/2;
+}
+void seleccionarFecha(int *aaaa_, int *mm_, int *dd_){
+    printf("Ingrese la fecha que busca\n");
+    printf("aaaa:");
+    scanf("%d",&aaaa_);
+    printf("mm:");
+    scanf("%d",&mm_);
+    printf("dd:");
+    scanf("%d", &dd_);
+}
+int compareTo(nodoApuntador *nodoPtr, int *aaaa_, int *mm_, int *dd_, int *mid_){
+    int i, resultado; //Mis listas estan ordenadas de mayor a menor fecha
+    for (i=0; i<mid; i++){
+        nodoPtr = nodoPtr -> siguienteNodo;
+    }
+    if (aaaa_ != nodoPtr->info.FECHA.aaaa){
+        if(aaaa_ < nodoPtr->info.FECHA.aaaa){
+            resultado = 1;
+        }else{
+            resultado = -1;
+        }
+
+    }else if(mm_ != nodoPtr->info.FECHA.mm){
+        if(mm_ < nodoPtr->info.FECHA.mm){
+            resultado = 1;
+        }else{
+            resultado = -1;
+        }
+    }else if(dd_ != nodoPtr->info.FECHA.dd){
+        if(dd_ < nodoPtr->info.FECHA.dd){
+            resultado = 1;
+        }else if(dd_ > nodoPtr->info.FECHA.dd){
+            resultado = -1;
+        }else{
+            resultado = 0;
+        }
+
+    }
+    return resultado;
+}
+
+void imprimirNodoBuscado(nodoApuntador nodoBuscado){
+    if (nodoBuscado == NULL){
+        printf("No se encontraron resultados para su busqueda\n");
+    }else{
+        printf("\t ENCONTRADO!!!\t");
+        printf("Expresion: %s", nodoBuscado->info.expresion);
+        printf("Fecha: %d / %d / %d", nodoBuscado->info.FECHA.dd,nodoBuscado->info.FECHA.mm, nodoBuscado->info.FECHA.aaaa);
+    }
+}
\ No newline at end of file
diff --git a/ADAS/Correa/ADA6-Listas.c b/ADAS/Correa/ADA6-Listas.c
new file mode 100644
index 0000000..97302d9
--- /dev/null
+++ b/ADAS/Correa/ADA6-Listas.c
@@ -0,0 +1,293 @@
+//Programa que almacena la lista con las expresiones booleanas, ordenadas de acuerdo a 
+// la fecha en las cuales se registraron
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct fecha{
+    int dd;
+    int mm;
+    int aaaa;
+}Fecha;
+
+typedef struct dato{
+    char expresion[121];
+    Fecha FECHA;
+}Dato;
+
+typedef struct nodo{
+    Dato info;
+    struct nodo *siguienteNodo;
+}Nodo;
+
+typedef Nodo *nodoApuntador;
+
+int seleccionarMenu();
+void leerFecha(int*, int*, int*);
+int EsBisiesto(int );
+void insertarOrdenada(nodoApuntador *, int, int, int, char*);
+void continuar(int *);
+void borrarLista(nodoApuntador *, int* );
+void imprimirLista(Nodo);
+
+return main(){
+    nodoApuntador nodoCabecera=NULL;
+    int opcionSeleccionada,dia,mes,anio,tamanio,cont=0, bandera=1;
+    char cad[121], *cadena;
+    opcionSeleccionada=seleccionarMenu();
+    while (opcionSeleccionada != 1 && cont==0)
+    {
+        if (opcionSeleccionada == 2)
+        {
+            printf("No hay listas que borrar\n");
+
+        }else
+        {
+            printf("No hay listas que imprimir\n");
+        }
+        
+    }
+    if (opcionSeleccionada == 1){
+        while(bandera==1){
+            leerFecha(&dia,&mes,&anio);
+            printf("Ingrese la expresion booleana\n");
+            gets(cad);
+            tamanio= strlen(cad);
+            cadena =(char* )malloc((tamanio+1)* sizeof(char));
+            strcpy(cadena,cad);
+            insertarOrdenado(&nodoCabecera,dia,mes,anio,&cadena);
+            cont +=1;
+            continuar(&bandera);
+        }
+    }
+    if (opcionSeleccionada == 2 && cont!= 0 ){
+        borrarLista(&nodoCabecera,&cont);
+    }
+    imprimirLista(nodoCabecera);
+
+    return 0;
+}
+
+
+int seleccionarMenu(){
+    int opcion;
+    printf("\t MENU \t");
+    printf("1 Añadir a la lista\n");
+    printf("2 Borrar lista\n");
+    printf("3 Imprimir lista\n");
+    printf("Selecciona una opcion\n");
+    scanf("%d",&opcion);
+
+    while (opcion<1 || opcion>3){
+        printf("Opcion no valida, seleccione otra opcion\n");
+        scanf("%d", &opcion);
+    }
+    return opcion;
+}
+
+void leerFecha(int *dia, int *mes, int *anio){
+    int respuesta;
+    printf("Ingrese año(aaaa):");
+    scanf("%d",anio);
+    while (*anio<0 || *anio>2020){
+        printf("Año invalido, ingrese otro:");
+        scanf("%d",anio);
+    }
+    printf("Ingrese mes (mm):");
+    scanf("%d",mes);
+    while(*mes<1 || *mes>12){
+        printf("Mes invalido, ingrese otro:");
+        scanf("%d", mes);
+    }
+    printf("Inserte dia (dd):");
+    scanf("%d",dia);
+    respuesta=EsBisiesto(anio);
+    if (respuesta==0){
+        if(*mes==2){
+            while (*dia<1 || *dia>28){
+                printf("Inserte dia (dd):");
+                scanf("%d",dia);
+            }
+        }else if (*mes >= 1 || *mes<=7 && *mes !=2){
+            if (*mes%2==1){
+                while (*dia<1 || *dia>31){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }else{
+                while (*dia<1 || *dia>30){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }
+            
+        }else if( *mes>7 || *mes<=12 && *mes != 2){
+            if (*mes%2==1){
+                while (*dia<1 || *dia>30){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }else{
+                while (*dia<1 || *dia>31){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }
+
+        }
+        
+
+    }else{
+        if(*mes==2){
+            while (*dia<1 || *dia>29){
+                printf("Inserte dia (dd):");
+                scanf("%d",dia);
+            }
+        }else if (*mes >= 1 || *mes<=7 && *mes !=2){
+            if (*mes%2==1){
+                while (*dia<1 || *dia>31){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }else{
+                while (*dia<1 || *dia>30){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }
+            
+        }else if( *mes>7 || *mes<=12 && *mes != 2){
+            if (*mes%2==1){
+                while (*dia<1 || *dia>30){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }else{
+                while (*dia<1 || *dia>31){
+                    printf("Inserte dia (dd):");
+                    scanf("%d",dia);
+                }
+            }
+
+        }
+
+    }
+}
+
+int EsBisiesto(int anio_){
+    if (anio_%4==0){
+        if (anio_%100==0){
+            if (anio_%400==0){
+                return 1;
+            }else{
+                return 0;
+            }
+    else{
+        return 0;
+    }
+}
+
+void insertarOrdenado(nodoApuntador *nodoPtr, int dd_, int mm_, int aaaa_, char *exp){
+    nodoApuntador nuevoNodo, nodoActual = *nodoPtr , antiguoNodo = NULL;
+    nuevoNodo =(Nodo*)malloc(sizeof(Nodo));
+    if (nuevoNodo != NULL){
+        strcpy(nuevoNodo ->info.expresion,exp);
+        nuevoNodo -> info.FECHA.dd = dd_;
+        nuevoNodo -> info.FECHA.mm = mm_;
+        nuevoNodo -> info.FECHA.aaaa = aaaa_;
+        nuevoNodo -> siguienteNodo=NULL;
+
+        if (aaaa_!= nodoActual-> info.FECHA.aaaa){
+            while (nodoActual != NULL && aaaa_>nodoActual-> info.FECHA.aaaa){
+                antiguoNodo = nodoActual;
+                nodoActual = nodoActual-> siguienteNodo;
+            }
+            if (antiguoNodo==NULL){
+                nuevoNodo ->siguienteNodo = *nodoPtr;
+                *nodoPtr = nuevoNodo;
+            }else{
+                antiguoNodo->siguienteNodo = nuevoNodo;
+                nuevoNodo ->siguienteNodo = nodoActual;
+            }
+        }else if(mm_ != nodoActual->info.FECHA.mm){
+            while (nodoActual != NULL && mm_>nodoActual-> info.FECHA.mm){
+                antiguoNodo = nodoActual;
+                nodoActual = nodoActual-> siguienteNodo;
+            }
+            if (antiguoNodo==NULL){
+                nuevoNodo ->siguienteNodo = *nodoPtr;
+                *nodoPtr = nuevoNodo;
+            }else{
+                antiguoNodo->siguienteNodo = nuevoNodo;
+                nuevoNodo ->siguienteNodo = nodoActual;
+            }
+        }else{
+            while (nodoActual != NULL && dd_>nodoActual-> info.FECHA.dd){
+                antiguoNodo = nodoActual;
+                nodoActual = nodoActual-> siguienteNodo;
+            }
+            if (antiguoNodo==NULL){
+                nuevoNodo ->siguienteNodo = *nodoPtr;
+                *nodoPtr = nuevoNodo;
+            }else{
+                antiguoNodo->siguienteNodo = nuevoNodo;
+                nuevoNodo ->siguienteNodo = nodoActual;
+            }
+        }
+    }else{
+        printf("No hay memoria\n");
+    }
+}
+
+void continuar(int *bandera){
+    int eleccion;
+    printf("Desea insertar otra expresion?\n");
+    prinf("Seleccione un numero: 1. Sí/ 2. No\n");
+    scanf("%d", &eleccion);
+    while (eleccion<1 || eleccion>2){
+        printf("Eleccion invalida, seleccione un numero\n");
+        scanf("%d", &eleccion);
+    }
+    if (eleccion==1){
+        *bandera =1;
+    }else{
+        *bandera=0;
+    }
+    
+
+}
+void borrarLista(nodoApuntador *nodoPtr, int* cont_){
+    Nodo nodoTemporal, nodoActual = *nodoPtr;
+    int aaaa,mm,dd;
+    printf("Ingrese la fecha de la expresion que desea borrar\n");
+    printf("Año(aaaa):");
+    scanf("%d",&aaaa);
+    printf("Mes(mm):");
+    scanf("%d",&mm);
+    printf("Dia(dd):");
+    scanf("%d",&dd);
+    if(nodoActual->info.FECHA.aaaa==aaaa && nodoActual->info.FECHA.mm==mm && nodoActual->info.FECHA.dd==dd){
+        nodoTemporal=nodoActual;
+        *nodoPtr=nodoActual->siguienteNodo;
+        nodoTemporal->siguienteNodo = NULL;
+        free(nodoTemporal);
+        *cont-=1;
+    }else{
+        printf("No existe esa fecha\n");
+    }
+}
+
+void imprimirLista(nodoActual){
+    if (nodoActual == NULL){
+        printf("Lista vacia\n");
+    }else{
+        printf("\t LISTA\t");
+        while(nodoActual != NULL){
+            printf("Expresion: %s\n",nodoActual->info.expresion);
+            printf("Fecha: %d / %d / %d", nodoActual->info.FECHA.dd,nodoActual->info.FECHA.mm, nodoActual->info.FECHA.aaaa);
+            nodoActual = nodoActual->siguienteNodo;
+        }
+        printf("\n");
+    }
+}
\ No newline at end of file
diff --git a/ADAS/Correa/ADA6.-Sudoku.c b/ADAS/Correa/ADA6.-Sudoku.c
new file mode 100644
index 0000000..690f3f9
--- /dev/null
+++ b/ADAS/Correa/ADA6.-Sudoku.c
@@ -0,0 +1,168 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+typedef struct tableroMenor{
+	int matriz[3][3];
+}tableroMenor;
+
+typedef struct sudoku{
+	tableroMenor tableroCompleto[3][3];
+}sudoku;
+
+void asignarValores(sudoku *);
+void imprimirSudoku(sudoku *);
+int recorrerCuadro(sudoku* );
+int recorrerHorizontal(sudoku *);
+int recorrerVertical(sudoku *);
+void mostrarResultados(sudoku*);
+
+int main(){
+	sudoku arreglo;
+	srand(time(NULL));
+	asignarValores(&arreglo);
+	imprimirSudoku(&arreglo);
+	mostrarResultados(&arreglo);
+}
+
+void asignarValores(sudoku* arreglo){
+	int i,j;
+	int m,n;
+	for(i=0; i<3;i++){
+		for(j=0; j<3; j++){
+			for(m=0;m<3;m++){
+				for(n=0;n<3;n++){
+					(*arreglo).tableroCompleto[i][j].matriz[m][n] = rand()%9 + 1;
+				}
+			}
+		}
+	}
+	
+}
+
+void imprimirSudoku(sudoku* arreglo){
+	int i,j;
+	int m,n;
+	for(i=0; i<3;i++){
+		for(m=0; m<3; m++){
+			for(j=0;j<3;j++){
+				for(n=0;n<3;n++){
+					printf("%d ",(*arreglo).tableroCompleto[i][j].matriz[m][n]);
+				}
+				printf(" ");
+			}
+			printf("\n");
+		}
+		printf("\n");
+	}
+	
+}
+
+int recorrerCuadro(sudoku* arreglo){
+	/* Bandera */
+	int verificar = 1;
+	int i,j,m,n, x, z;
+	for(i=0; i<3; i++){
+		for(j=0; j<3; j++){
+			int indice = 0;
+			// Aqui se guardan los valores de cada cuadro
+			int digito[9];
+			for(m=0;m<3;m++){
+				for(n=0; n<3; n++){
+					digito[indice]=(*arreglo).tableroCompleto[i][j].matriz[m][n];
+					// se le suma uno al indeice para que ocupe otro espacio
+					indice += 1;
+				}
+			}
+			for(x=0;x<9;x++){
+				for(z=0;z<9;z++){
+					if (digito[x] == digito[z] && x != z){
+						// si son iguales indica que hay dos digitos en el mismo cuadro 
+						// y se cambia el valor a 0
+						verificar = 0;
+					}
+				}
+				// volver a 0 para que el arreglo no si pase  del limite
+				indice = 0;
+			}
+		}
+	}
+	return verificar;
+}
+	
+
+int recorrerHorizontal(sudoku* arreglo){
+	/* Bandera */
+	int verificar = 1;
+	int i,j,m,n, x, z;
+	for(i=0; i<3; i++){
+		for(j=0; j<3; j++){
+			int indice = 0;
+			// Aqui se guardan los valores de cada fila
+			int digito[9];
+			for(m=0;m<3;m++){
+				for(n=0; n<3; n++){
+					digito[indice]=(*arreglo).tableroCompleto[i][m].matriz[j][n];
+					// se le suma uno al indeice para que ocupe otro espacio
+					indice += 1;
+				}
+			}
+			for(x=0;x<9;x++){
+				for(z=0;z<9;z++){
+					if (digito[x] == digito[z] && x != z){
+						// si son iguales indica que hay dos digitos en la misma fila
+						// y se cambia el valor a 0
+						verificar = 0;
+					}
+				}
+				// volver a 0 para que el arreglo no si pase  del limite
+				indice = 0;
+			}
+		}
+	}
+	return verificar;
+}
+
+int recorrerVertical(sudoku* arreglo){
+	int verificar = 1;
+	int i,j,m,n, x, z;
+	for(i=0; i<3; i++){
+		for(j=0; j<3; j++){
+			int indice = 0;
+			// Aqui se guardan los valores de cada columna
+			int digito[9];
+			for(m=0;m<3;m++){
+				for(n=0; n<3; n++){
+					digito[indice]=(*arreglo).tableroCompleto[j][i].matriz[n][m];
+					// se le suma uno al indeice para que ocupe otro espacio
+					indice += 1;
+				}
+			}
+			for(x=0;x<9;x++){
+				for(z=0;z<9;z++){
+					if (digito[x] == digito[z] && x != z){
+						// si son iguales indica que hay dos digitos en la misma columna 
+						// y se cambia el valor a 0
+						verificar = 0;
+					}
+				}
+				// volver a 0 para que el arreglo no si pase  del limite
+				indice = 0;
+			}
+		}
+	}
+	return verificar;
+}
+
+
+void mostrarResultados(sudoku* arreglo){
+	// obtener los resultados de cada bandera 
+	int resultadoC = recorrerCuadro(arreglo);
+	int resultadoH = recorrerHorizontal(arreglo);
+	int resultadoV = recorrerVertical(arreglo);
+	if (resultadoC==1 && resultadoH ==1 && resultadoV==1 ){
+		printf("\t Es un Sudoku ");
+	}else{
+		printf("\t No es Sudoku ");
+	}
+}
diff --git a/ADAS/Correa/Ejercicio26Marzo.c b/ADAS/Correa/Ejercicio26Marzo.c
new file mode 100644
index 0000000..2759da6
--- /dev/null
+++ b/ADAS/Correa/Ejercicio26Marzo.c
@@ -0,0 +1,94 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define M 5
+//ADA 4 visualizar region 2-4 y region 1-3
+//Autor Audny Desiree Correa Ceballos
+void asignarValores(int arr[][M]);
+void imprimirArreglo(int arr[][M]);
+void imprimirR2R4(int arr[][M]);
+void imprimirR1R3(int arr[][M]);
+
+int main(){
+	int arreglo[M][M];
+	time_t t;
+	srand((unsigned) time(&t));
+	asignarValores(arreglo);
+	imprimirArreglo(arreglo);
+	imprimirR2R4(arreglo);
+	imprimirR1R3(arreglo);
+	
+}
+
+void asignarValores(int arr[][M]){
+	int i, j;
+	for(j=0; j<M; j++){
+		for(i=0; i<M; i++){
+			arr[i][j]= rand()%10;
+		}
+	}
+}
+
+void imprimirArreglo(int arr[][M]){
+	int i,j;
+    for(i = 0; i < M; i++){
+    	for(j = 0; j < M; j++){
+    		printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+		}
+		printf("\n");
+   }  
+}
+
+
+
+void imprimirR2R4(int arr[][M]){
+	int i, j;
+	// fila 0 hasta (M-1)/2
+	printf("Region 2-4\n");
+	for(i=0; i<=(M-1)/2/* Este es mi (M-1)/2*/; i++){
+		for(j=0;j<M; j++){
+			if(j>= i && j<M-i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}	
+		}
+		printf("\n");
+	}
+	for(i=((M-1)/2)+1; i<M; i++){
+		for(j=0;j<M;j++){
+			if(j>=M-i-1 && j<=i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);	
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
+
+void imprimirR1R3(int arr[][M]){
+	int i,j;
+	printf("Region 1-3\n");
+	for(i=0; i<=(M-1)/2; i++){
+		for(j=0; j<M; j++){
+			if(j<=i || j>=M-1-i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+	for(i=((M-1)/2)+1; i<M;i++){
+		for(j=0; j<M;j++){
+			if (j<=M-1-i || j>=i){
+				printf("(%d,%d:%d)\t",i,j, arr[i][j]);
+			}else{
+				printf("\t");
+			}
+		}
+		printf("\n");
+	}
+}
diff --git "a/ADAS/Llanes/ADA4_ConVisualizaci\303\263n.c" "b/ADAS/Llanes/ADA4_ConVisualizaci\303\263n.c"
new file mode 100644
index 0000000..c5dcd2a
--- /dev/null
+++ "b/ADAS/Llanes/ADA4_ConVisualizaci\303\263n.c"
@@ -0,0 +1,425 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <stdbool.h>
+#define N 5
+
+//Prototipado de funciones
+void asignarArreglo(int arr[][N]);
+void imprimirArreglo(int arr[][N]);
+void menuOpciones(int arr[][N]);
+void desplegarMenu();
+void nuevoCuadro(int arr[][N]);
+void recorrerMatriz1_2Ascendente(int arr[][N]);
+void recorrerMatriz1_2Descendente(int arr[][N]);
+void recorrerMatriz3_4Ascendente(int arr[][N]);
+void recorrerMatriz3_4Descendente(int arr[][N]);
+void recorrerMatriz1_4Ascendente(int arr[][N]);
+void recorrerMatriz1_4Descendente(int arr[][N]);
+void recorrerMatriz2_3Ascendente(int arr[][N]); 
+void recorrerMatriz2_3Descendente(int arr[][N]);
+void recorrerMatriz1Ascendente(int arr[][N]);
+void recorrerMatriz1Descendente(int arr[][N]);
+void recorrerMatriz2Ascendente(int arr[][N]);
+void recorrerMatriz2Descendente(int arr[][N]);
+void recorrerMatriz3Ascendente(int arr[][N]);
+void recorrerMatriz3Descendente(int arr[][N]);
+void recorrerMatriz4Ascendente(int arr[][N]);
+void recorrerMatriz4Descendente(int arr[][N]);
+void recorrerDiagonalPrincipal(int arr[][N]);
+void recorrerDiagonalInvertida(int arreglo[][N]); 
+
+int main () {
+
+  int arreglo[N][N];
+
+  //Generador-Inador 3ooo
+  time_t t;
+  srand((unsigned) time(&t));
+
+  asignarArreglo(arreglo);
+
+  imprimirArreglo(arreglo);
+
+  menuOpciones(arreglo);
+
+  return(0);
+
+}
+
+void asignarArreglo(int arr[][N]) {
+  for(int i = 0; i < N; i++) {
+       for (int j = 0; j<N; j++) {
+           arr[i][j] = rand() % 51;
+       }
+    }
+}
+
+void imprimirArreglo(int arr[][N]) {
+    printf("[ Cuadro Actual ]\n");
+    for(int i = 0; i < N; i++) {
+        printf("\t");
+        for (int j = 0; j<N; j++){
+            printf("%d\t", arr[i][j]);
+        }
+        printf("\n");
+   }
+}
+
+void menuOpciones(int arr[][N]){
+    bool check = true;
+    int opc;
+    
+    desplegarMenu();
+
+    while( check ){
+      scanf("%d", &opc);
+      printf("\n");
+      switch(opc){
+        case 0:
+          printf("Buen dia :D\n");
+          check = false;
+          break;
+        case 1:
+          nuevoCuadro(arr);
+          break;
+        case 2:
+          recorrerMatriz1_2Ascendente(arr);
+          break;
+        case 3:
+          recorrerMatriz1_2Descendente(arr);
+          break;
+        case 4:
+          recorrerMatriz3_4Ascendente(arr);
+          break;
+        case 5:
+          recorrerMatriz3_4Descendente(arr);
+          break;
+        case 6:
+          recorrerMatriz1_4Ascendente(arr);
+          break;
+        case 7:
+          recorrerMatriz1_4Descendente(arr);
+          break;
+        case 8:
+          recorrerMatriz2_3Ascendente(arr);
+          break;
+        case 9:
+          recorrerMatriz2_3Descendente(arr);
+          break;
+        case 10:
+          recorrerMatriz1Ascendente(arr);
+          break;
+        case 11:
+          recorrerMatriz1Descendente(arr);
+          break;
+        case 12:
+          recorrerMatriz2Ascendente(arr);
+          break;
+        case 13:
+          recorrerMatriz2Descendente(arr);
+          break;
+        case 14:
+          recorrerMatriz3Ascendente(arr);
+          break;
+        case 15:
+          recorrerMatriz3Descendente(arr);
+          break;
+        case 16:
+          recorrerMatriz4Ascendente(arr);
+          break;
+        case 17:
+          recorrerMatriz4Descendente(arr);
+          break;
+        case 18:
+          recorrerDiagonalPrincipal(arr);
+          break;
+        case 19:
+          recorrerDiagonalInvertida(arr); 
+        default:
+          printf("El comando seleccionado no esta en la lista, intentelo denuevo :c\n");
+      }
+      printf("\n");
+    }
+}
+
+void desplegarMenu(){
+  printf("\n[ Tablero de opciones ]");
+      printf("\n 1. Generar nueva matriz");
+      
+      printf("\n 2. 1-2 Ascendiente\t\t6. 1-4 Ascendente\t\t10. 1 Ascendiente\t\t14. 3 Ascendiente");
+      
+      printf("\n 3. 1-2 Descendente\t\t7. 1-4 Descendente\t\t11. 1 Desendiente\t\t15. 3 Descendiente");
+      
+      printf("\n 4. 3-4 Ascendente\t\t8. 2-3 Ascendente\t\t12. 2 Ascendiente\t\t16. 4 Ascendiente");
+      
+      printf("\n 5. 3-4 Descendente\t\t9. 2-3 Descendente\t\t13. 2 Ascendiente\t\t17. 4 Descendiente");
+      
+      printf("\n 18. Diagonal principal\t19. Diagonal invertida\n");
+      printf(" 0. Exit\n");
+}
+
+void nuevoCuadro(int arr[][N]){
+  system("clear");
+  asignarArreglo(arr);
+  imprimirArreglo(arr);
+  menuOpciones(arr);
+}
+
+void recorrerMatriz1_2Ascendente(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+      for( int j = 0; j < N; j++ ){
+        if( j < N - i ){
+          printf("%d \t", arr[i][j]);
+        }
+        else{
+          printf("\t");
+        }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz1_2Descendente(int arr[][N]){
+  for( int i = N-1; 0 <= i; i-- ) {
+      for( int j = 0; j < N; j++ ){
+        if( j < N - i ){
+          printf("%d \t", arr[i][j]);
+        }
+        else{
+          printf("\t");
+        }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz3_4Ascendente(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+      for( int j = 0; j < N; j++ ){
+        if( j >= N - i -1 ){
+          printf("%d \t", arr[i][j]);
+        }
+        else{
+          printf("\t");
+        }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz3_4Descendente(int arr[][N]){
+  for( int i = N-1; 0 <= i; i-- ) {
+      for( int j = 0; j < N; j++ ){
+        if( j >= N - i -1 ){
+          printf("%d \t", arr[i][j]);
+        }
+        else{
+          printf("\t");
+        }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz1_4Ascendente(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+      for( int j = 0; j < N; j++ ){
+        if( j <= i ){
+          printf("%d \t", arr[i][j]);
+        }
+        else{
+          printf("\t");
+        }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz1_4Descendente(int arr[][N]){
+  for( int i = N - 1; 0 <= i; i-- ) {
+      for( int j = 0; j < N; j++ ){
+        if( j <= i ){
+          printf("%d \t", arr[i][j]);
+        }
+        else{
+          printf("\t");
+        }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz2_3Ascendente(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+      for( int j = 0; j < N; j++ ){
+        if( j >= i ){
+          printf("%d \t", arr[i][j]);
+        }
+        else{
+          printf("\t");
+        }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz2_3Descendente(int arr[][N]){
+  for( int i = N - 1; 0 <= i; i-- ) {
+      for( int j = 0; j < N; j++ ){
+        if( j >= i ){
+          printf("%d \t", arr[i][j]);
+        }
+        else{
+          printf("\t");
+        }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz1Ascendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = 0; i < N; i++ ){
+    for ( int j = 0;j < N; j++ ){
+      if( j <= m && j <= i && j <= N - 1 - i ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz1Descendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = N; 0 <= i; i-- ){
+    for ( int j = 0;j < N; j++ ){
+      if( j <= m && j <= i && j <= N - 1 - i ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz2Ascendente(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+    for( int j = 0; j < N; j++ ){
+      if( j < N - i && j >= i ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz2Descendente(int arr[][N]){
+  for( int i = N - 1; 0 <= i; i-- ) {
+    for( int j = 0; j < N; j++ ){
+      if( j < N - i && j >= i ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz3Ascendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = 0; i < N; i++ ){
+    for ( int j = 0;j < N; j++ ){
+      if( j >= m && j >= i && j >= N - 1 - i ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz3Descendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = N; 0 <= i; i-- ){
+    for ( int j = 0;j < N; j++ ){
+      if( j >= m && j >= i && j >= N - 1 - i ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz4Ascendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = 0; i < N; i++ ){
+    for ( int j = 0;j < N; j++ ){
+      if( i >= m && j <= i && j >= N - 1 - i ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz4Descendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = N - 1; 0 <= i; i-- ){
+    for ( int j = 0;j < N; j++ ){
+      if( i >= m && j <= i && j >= N - 1 - i ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerDiagonalPrincipal(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+    for( int j = 0; j < N; j++ ){
+      if( i == j ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+  printf("\n");
+  }
+}
+
+void recorrerDiagonalInvertida(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+    for( int j = 0; j < N; j++ ){
+      if( j == N - i - 1 ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+  printf("\n");
+  }
+}
diff --git "a/ADAS/Llanes/ADA4_SinVisualizaci\303\263n.c" "b/ADAS/Llanes/ADA4_SinVisualizaci\303\263n.c"
new file mode 100644
index 0000000..9dba99d
--- /dev/null
+++ "b/ADAS/Llanes/ADA4_SinVisualizaci\303\263n.c"
@@ -0,0 +1,353 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <stdbool.h>
+#define N 3
+
+//Prototipado de funciones
+void asignarArreglo(int arr[][N]);
+void imprimirArreglo(int arr[][N]);
+void menuOpciones(int arr[][N]);
+void desplegarMenu();
+void nuevoCuadro(int arr[][N]);
+void recorrerMatriz1_2Ascendente(int arr[][N]);
+void recorrerMatriz1_2Descendente(int arr[][N]);
+void recorrerMatriz3_4Ascendente(int arr[][N]);
+void recorrerMatriz3_4Descendente(int arr[][N]);
+void recorrerMatriz1_4Ascendente(int arr[][N]);
+void recorrerMatriz1_4Descendente(int arr[][N]);
+void recorrerMatriz2_3Ascendente(int arr[][N]); 
+void recorrerMatriz2_3Descendente(int arr[][N]);
+void recorrerMatriz1Ascendente(int arr[][N]);
+void recorrerMatriz1Descendente(int arr[][N]);
+void recorrerMatriz2Ascendente(int arr[][N]);
+void recorrerMatriz2Descendente(int arr[][N]);
+void recorrerMatriz3Ascendente(int arr[][N]);
+void recorrerMatriz3Descendente(int arr[][N]);
+void recorrerMatriz4Ascendente(int arr[][N]);
+void recorrerMatriz4Descendente(int arr[][N]);
+void recorrerDiagonalPrincipal(int arr[][N]);
+void recorrerDiagonalInvertida(int arreglo[][N]); 
+
+int main () {
+
+  int arreglo[N][N];
+
+  //Generador-Inador 3ooo
+  time_t t;
+  srand((unsigned) time(&t));
+
+  asignarArreglo(arreglo);
+
+  imprimirArreglo(arreglo);
+
+  menuOpciones(arreglo);
+
+  return(0);
+
+}
+
+void asignarArreglo(int arr[][N]) {
+  for(int i = 0; i < N; i++) {
+       for (int j = 0; j<N; j++) {
+           arr[i][j] = rand() % 51;
+       }
+    }
+}
+
+void imprimirArreglo(int arr[][N]) {
+    printf("[ Cuadro Actual ]\n");
+    for(int i = 0; i < N; i++) {
+        printf("\t");
+        for (int j = 0; j<N; j++){
+            printf("%d\t", arr[i][j]);
+        }
+        printf("\n");
+   }
+}
+
+void menuOpciones(int arr[][N]){
+    bool check = true;
+    int opc;
+    
+    desplegarMenu();
+    
+    while( check ){
+      scanf("%d", &opc);
+      printf("\n");
+      switch(opc){
+        case 0:
+          printf("Buen dia :D\n");
+          check = false;
+          break;
+        case 1:
+          nuevoCuadro(arr);
+          break;
+        case 2:
+          recorrerMatriz1_2Ascendente(arr);
+          break;
+        case 3:
+          recorrerMatriz1_2Descendente(arr);
+          break;
+        case 4:
+          recorrerMatriz3_4Ascendente(arr);
+          break;
+        case 5:
+          recorrerMatriz3_4Descendente(arr);
+          break;
+        case 6:
+          recorrerMatriz1_4Ascendente(arr);
+          break;
+        case 7:
+          recorrerMatriz1_4Descendente(arr);
+          break;
+        case 8:
+          recorrerMatriz2_3Ascendente(arr);
+          break;
+        case 9:
+          recorrerMatriz2_3Descendente(arr);
+          break;
+        case 10:
+          recorrerMatriz1Ascendente(arr);
+          break;
+        case 11:
+          recorrerMatriz1Descendente(arr);
+          break;
+        case 12:
+          recorrerMatriz2Ascendente(arr);
+          break;
+        case 13:
+          recorrerMatriz2Descendente(arr);
+          break;
+        case 14:
+          recorrerMatriz3Ascendente(arr);
+          break;
+        case 15:
+          recorrerMatriz3Descendente(arr);
+          break;
+        case 16:
+          recorrerMatriz4Ascendente(arr);
+          break;
+        case 17:
+          recorrerMatriz4Descendente(arr);
+          break;
+        case 18:
+          recorrerDiagonalPrincipal(arr);
+          break;
+        case 19:
+          recorrerDiagonalInvertida(arr); 
+        default:
+          printf("El comando seleccionado no esta en la lista, intentelo denuevo :c\n");
+      }
+      printf("\n");
+    }
+}
+
+void desplegarMenu(){
+  printf("\n[ Tablero de opciones ]");
+      printf("\n 1. Generar nueva matriz");
+      
+      printf("\n 2. 1-2 Ascendiente\t\t6. 1-4 Ascendente\t\t10. 1 Ascendiente\t\t14. 3 Ascendiente");
+      
+      printf("\n 3. 1-2 Descendente\t\t7. 1-4 Descendente\t\t11. 1 Desendiente\t\t15. 3 Descendiente");
+      
+      printf("\n 4. 3-4 Ascendente\t\t8. 2-3 Ascendente\t\t12. 2 Ascendiente\t\t16. 4 Ascendiente");
+      
+      printf("\n 5. 3-4 Descendente\t\t9. 2-3 Descendente\t\t13. 2 Ascendiente\t\t17. 4 Descendiente");
+      
+      printf("\n 18. Diagonal principal\t19. Diagonal invertida\n");
+      printf(" 0. Exit\n");
+}
+
+void nuevoCuadro(int arr[][N]){
+  system("clear");
+  asignarArreglo(arr);
+  imprimirArreglo(arr);
+  menuOpciones(arr);
+}
+
+void recorrerMatriz1_2Ascendente(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+      for( int j = 0; j < N; j++ ){
+        if( j < N - i ){
+          printf("%d\t", arr[i][j]);
+        }
+    }
+  }
+}
+
+void recorrerMatriz1_2Descendente(int arr[][N]){
+  for( int i = N-1; 0 <= i; i-- ) {
+      for( int j = 0; j < N; j++ ){
+        if( j < N - i ){
+          printf("%d\t", arr[i][j]);
+        }
+    }
+  }
+}
+
+void recorrerMatriz3_4Ascendente(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+      for( int j = 0; j < N; j++ ){
+        if( j >= N - i -1 ){
+          printf("%d\t", arr[i][j]);
+        }
+    }
+  }
+}
+
+void recorrerMatriz3_4Descendente(int arr[][N]){
+  for( int i = N-1; 0 <= i; i-- ) {
+      for( int j = 0; j < N; j++ ){
+        if( j >= N - i -1 ){
+          printf("%d\t", arr[i][j]);
+        }
+    }
+  }
+}
+
+void recorrerMatriz1_4Ascendente(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+      for( int j = 0; j < N; j++ ){
+        if( j <= i ){
+          printf("%d\t", arr[i][j]);
+        }
+      }
+  }
+}
+
+void recorrerMatriz1_4Descendente(int arr[][N]){
+  for( int i = N - 1; 0 <= i; i-- ) {
+      for( int j = 0; j < N; j++ ){
+        if( j <= i ){
+          printf("%d \t", arr[i][j]);
+        }
+    }
+  }
+}
+
+void recorrerMatriz2_3Ascendente(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+      for( int j = 0; j < N; j++ ){
+        if( j >= i ){
+          printf("%d\t", arr[i][j]);
+        }
+    }
+  }
+}
+
+void recorrerMatriz2_3Descendente(int arr[][N]){
+  for( int i = N - 1; 0 <= i; i-- ) {
+      for( int j = 0; j < N; j++ ){
+        if( j >= i ){
+          printf("%d\t", arr[i][j]);
+        }
+    }
+  }
+}
+
+void recorrerMatriz1Ascendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = 0; i < N; i++ ){
+    for ( int j = 0;j < N; j++ ){
+      if( j <= m && j <= i && j <= N - 1 - i ){
+        printf("%d\t", arr[i][j]);
+      }
+    }
+  }
+}
+
+void recorrerMatriz1Descendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = N; 0 <= i; i-- ){
+    for ( int j = 0;j < N; j++ ){
+      if( j <= m && j <= i && j <= N - 1 - i ){
+        printf("%d \t", arr[i][j]);
+      }
+    }
+  }
+}
+
+void recorrerMatriz2Ascendente(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+    for( int j = 0; j < N; j++ ){
+      if( j < N - i && j >= i ){
+        printf("%d \t", arr[i][j]);
+      }
+    }
+  }
+}
+
+void recorrerMatriz2Descendente(int arr[][N]){
+  for( int i = N - 1; 0 <= i; i-- ) {
+    for( int j = 0; j < N; j++ ){
+      if( j < N - i && j >= i ){
+        printf("%d \t", arr[i][j]);
+      }
+    }
+  }
+}
+
+void recorrerMatriz3Ascendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = 0; i < N; i++ ){
+    for ( int j = 0;j < N; j++ ){
+      if( j >= m && j >= i && j >= N - 1 - i ){
+        printf("%d \t", arr[i][j]);
+      }
+    }
+  }
+}
+
+void recorrerMatriz3Descendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = N; 0 <= i; i-- ){
+    for ( int j = 0;j < N; j++ ){
+      if( j >= m && j >= i && j >= N - 1 - i ){
+        printf("%d \t", arr[i][j]);
+      }
+    }
+  }
+}
+
+void recorrerMatriz4Ascendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = 0; i < N; i++ ){
+    for ( int j = 0;j < N; j++ ){
+      if( i >= m && j <= i && j >= N - 1 - i ){
+        printf("%d \t", arr[i][j]);
+      }
+    }
+  }
+}
+
+void recorrerMatriz4Descendente(int arr[][N]){
+  int m = (N-1)/2;
+  for ( int i = N - 1; 0 <= i; i-- ){
+    for ( int j = 0;j < N; j++ ){
+      if( i >= m && j <= i && j >= N - 1 - i ){
+        printf("%d \t", arr[i][j]);
+      }
+    }
+  }
+}
+
+void recorrerDiagonalPrincipal(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+    for( int j = 0; j < N; j++ ){
+      if( i == j ){
+        printf("%d \t", arr[i][j]);
+      }
+    }
+  }
+}
+
+void recorrerDiagonalInvertida(int arr[][N]){
+  for( int i = 0; i < N; i++ ) {
+    for( int j = 0; j < N; j++ ){
+      if( j == N - i - 1 ){
+        printf("%d \t", arr[i][j]);
+      }
+    }
+  }
+}
diff --git a/ADAS/Llanes/ADA6-Racionales.c b/ADAS/Llanes/ADA6-Racionales.c
new file mode 100644
index 0000000..188c95a
--- /dev/null
+++ b/ADAS/Llanes/ADA6-Racionales.c
@@ -0,0 +1,208 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define GREEN "\x1b[32m"
+#define RESET "\x1b[0m"
+
+typedef struct racional{
+    int numerador;
+    int denominador;
+} racional;
+
+//Prototipos
+void leerRacionales( racional * , racional * );
+void mostrarRacionales( racional *, racional * );
+//Operaciones esenciales
+int mcd( int, int );
+int mcm( int, int );
+void simplificar( racional * );
+racional sumaRacionales( racional *, racional *);
+racional restaRacionales( racional *, racional * );
+racional multiRacionales( racional *, racional * );
+racional divRacionales( racional *, racional * );
+void imprimirRacional( racional );
+
+int main(){
+    struct racional rac1, rac2;
+    //Entrada
+    leerRacionales( &rac1, &rac2 );
+
+    //Proceso
+    mostrarRacionales( &rac1, &rac2 );
+
+    //Salida
+    imprimirRacional( sumaRacionales( &rac1, &rac2 ) );
+    imprimirRacional( restaRacionales( &rac1, &rac2 ) );
+    imprimirRacional( multiRacionales( &rac1, &rac2 ) );  
+    imprimirRacional( divRacionales( &rac1, &rac2 ) );
+}
+
+void leerRacionales( racional *r1, racional *r2 ){
+	//Información
+  printf("Formato de racional: ");
+  printf( GREEN "< " RESET);
+  printf("Numerador");
+  printf( GREEN " > " RESET);
+  printf( GREEN "< " RESET);
+  printf("Denominador");
+  printf( GREEN " >\n" RESET);
+  //Lo que pidió xd
+  //Racional 1
+  printf("Ingrese racional 1: \n\t");
+  scanf("%d",&r1->numerador);
+  scanf("%d",&r1->denominador);
+  //Racional 2	
+  printf("Ingrese racional 2: \n\t");
+  scanf("%d",&r2->numerador);
+  scanf("%d",&r2->denominador);
+}
+
+void mostrarRacionales( racional *r1, racional *r2 ){
+  //Limpiar consola
+  system("clear");
+  //Racional 1.
+  printf( "Racional 1.\t");
+  printf( "%d", r1->numerador );
+  printf( GREEN " / " RESET );
+  printf( "%d\n", r1->denominador );
+  //Racional 2.
+  printf( "Racional 2.\t");
+  printf( "%d", r2->numerador );
+  printf( GREEN " / " RESET );
+  printf( "%d\n", r2->denominador );
+}
+
+int mcd( int a, int b ){
+  
+  int aux;
+
+  if(b > a){
+    aux = a;
+    a = b;
+    b = aux;
+  }
+
+  while(a % b!=0){
+    a = a % b;
+    aux = a;
+    a = b;
+    b = aux;    
+  }
+
+  return b;
+
+}
+
+int mcm( int a, int b ){
+
+  return ( a * b ) / mcd( a , b );
+
+}
+
+void simplificar( racional *resultado ){
+  
+  if( resultado->numerador == 0 || resultado->denominador == 0 ){
+    resultado->numerador = 0;
+  }
+  else{
+    int aux;
+  
+    aux = mcd( resultado->denominador, resultado->numerador );
+
+    resultado->numerador /= aux;
+
+    resultado->denominador /= aux;
+  }
+}
+
+racional sumaRacionales( racional *r1, racional *r2 ){
+  racional resultado;
+
+  printf("Resultado de la suma:\n\t");
+
+  if( r1->denominador == 0 || r2->denominador == 0 ){
+    resultado.numerador = 0;
+    resultado.denominador = 0;
+  }
+  else{
+    resultado.denominador = mcm(r1->denominador,r2->denominador);
+
+    resultado.numerador = ( ( resultado.denominador / r1->denominador ) * r1->numerador ) + ( ( resultado.denominador / r2->denominador ) * r2->numerador );
+  }
+
+  simplificar(&resultado);
+
+  return resultado;
+
+}
+
+racional restaRacionales( racional *r1, racional *r2 ){
+  racional resultado;
+
+  printf("Resultado de la resta:\n\t");
+
+  if( r1->denominador == 0 || r2->denominador == 0 ){
+    resultado.numerador = 0;
+    resultado.denominador = 0;
+  }
+  else{
+    resultado.denominador = mcm(r1->denominador,r2->denominador);
+
+    resultado.numerador = ( ( resultado.denominador / r1->denominador ) * r1->numerador ) - ( ( resultado.denominador / r2->denominador ) * r2->numerador );
+  }
+
+  if( resultado.denominador < 0 ){
+    resultado.numerador *= -1;
+    resultado.denominador *= -1;
+  }
+
+  simplificar( &resultado );
+
+  return resultado;
+
+}
+
+racional multiRacionales( racional *r1, racional *r2 ){
+  racional resultado;
+
+  printf("Resultado de la resta:\n\t");
+
+  resultado.numerador = r1->numerador*r2->numerador;
+  resultado.denominador = r1->denominador*r2->denominador;
+
+  simplificar(&resultado);
+
+  return resultado;
+
+}
+
+racional divRacionales( racional *r1, racional *r2 ){
+  racional resultado;
+
+  printf("Resultado de la resta:\n\t");
+
+  resultado.numerador = r1->numerador*r2->denominador;
+  resultado.denominador = r1->denominador*r2->numerador;
+
+  simplificar(&resultado);
+
+  return resultado;
+
+}
+
+void imprimirRacional( racional resultado ){
+  if( resultado.numerador == 0 ){
+    printf("0\n");
+  }
+  else{
+    if( resultado.numerador % resultado.denominador == 0 ){
+      printf("%d\n", resultado.numerador / resultado.denominador );
+    }
+    else{
+      printf( "%d", resultado.numerador );
+      printf( GREEN " / " RESET );
+      printf( "%d\n", resultado.denominador );
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/ADAS/Llanes/ADA6-Sudoku.c b/ADAS/Llanes/ADA6-Sudoku.c
new file mode 100644
index 0000000..ea9d06e
--- /dev/null
+++ b/ADAS/Llanes/ADA6-Sudoku.c
@@ -0,0 +1,146 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <stdbool.h>
+
+typedef struct tableroMenor{
+  int panel[3][3];
+} tableroMenor;
+
+typedef struct tableroMayor{
+  tableroMenor tablero[3][3];
+} tableroMayor;
+
+/*
+Notas para el Roberto del futuro.
+Seguir intentando hacerlo con struct, s[e] qu[e] se puede :c
+Revisar como usar booleanos con punteros, parece que funcionan raro.
+Comprobar por qu[e] esta ignorando mi sistema para evitar coincidencias.
+*/
+
+//Prototipos
+tableroMenor llenarPanel(  );
+void llenarSudoku( tableroMayor * );
+void imprimirPanel( tableroMenor * );
+void imprimirTablero( tableroMayor * );
+bool checkVertical( tableroMayor * );
+bool checkHorizontal( tableroMayor * );
+bool checkSudoku( tableroMayor * );
+void limpiarCheck( bool * );
+
+int main() {
+  tableroMayor sudoku;
+
+  // Aleatorio-Inador 3001
+  srand(time(NULL));
+
+  llenarSudoku( &sudoku );
+
+  imprimirTablero( &sudoku );
+
+  printf( "%d", checkSudoku( &sudoku ) );
+}
+
+void llenarSudoku( tableroMayor *pan ){
+  int aux;
+  bool check[10];
+  for ( int i = 0; i < 3; i++ ){
+    for ( int j = 0; j < 3; j++ ){
+      limpiarCheck( check );
+      for ( int y = 0; y < 3; y++ ){
+        for ( int x = 0; x < 3; x++ ){
+          while ( true ){
+            aux = rand() % 9;
+            if( !check[ aux ] ){
+              pan->tablero[j][i].panel[x][y] = aux + 1;
+              check[ aux ] = true;
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+void imprimirTablero( tableroMayor *pan ) {
+  for ( int i = 0; i < 3; i++ ) {
+    for ( int j = 0; j < 3; j++ ) {
+      for ( int y = 0; y < 3; y++ ) {
+        printf(" | ");
+        for ( int x = 0; x < 3; x++ ) {
+          printf( "%d ", pan->tablero[j][i].panel[x][y] );
+        }
+        printf(" | ");
+      }
+      printf("\n");
+    }
+    printf("\n");
+  }
+}
+
+bool checkVertical( tableroMayor *pan ) {
+  bool check[10];
+  for ( int i = 0; i < 3; i++ ){
+    for ( int j = 0; j < 3; j++ ){
+      for ( int y = 0; y < 3; y++ ){
+        if( !check[ pan->tablero[j][i].panel[j][y] ] ){
+          check[ pan->tablero[i][j].panel[y][j] ] = true;
+        }
+        else{
+          return false;
+        }
+      }
+    }
+    limpiarCheck( check );
+  }
+  return true;
+}
+
+bool checkHorizontal( tableroMayor *pan ) {
+  bool check[10];
+  for ( int i = 0; i < 3; i++ ){
+    for ( int j = 0; j < 3; j++ ){
+      for ( int x = 0; x < 3; x++ ){
+        if( !check[ pan->tablero[j][i].panel[x][i] ] ){
+          check[ pan->tablero[j][i].panel[x][i] ] = true;
+        }
+        else{
+          return false;
+        }
+      }
+    }
+    limpiarCheck( check );
+  }
+  return true;
+}
+
+bool checkSudoku( tableroMayor *pan ){
+  return ( checkVertical( pan ) && checkHorizontal( pan ) );
+}
+
+void limpiarCheck( bool *a ) {
+  for ( int i = 0; i < 9; i++){
+    *(a + i) = false;
+  }
+}
+/*
+void checkVertical( ) {
+  bool check[10];
+  for ( int i = 0; i < 9; i++){
+    printf("%d", check[i]);
+  }
+
+  limpiarCheck( check );
+  for ( int i = 0; i < 9; i++){
+    printf(" %d", check[i]);
+  }
+
+}
+
+void limpiarCheck( bool (*a) ) {
+  for ( int i = 0; i < 9; i++){
+    *(a + i) = false;
+  }
+}
+*/
\ No newline at end of file
diff --git a/ADAS/Llanes/Ejercicio26Marzo.c b/ADAS/Llanes/Ejercicio26Marzo.c
new file mode 100644
index 0000000..a1b5a8d
--- /dev/null
+++ b/ADAS/Llanes/Ejercicio26Marzo.c
@@ -0,0 +1,132 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <stdbool.h>
+
+int tam;
+
+//Prototipos de funciones
+int dimensionarArreglo();
+void asignarArreglo(int arr[][tam]);
+void imprimirArreglo(int arr[][tam]);
+void desplegarMenu();
+void menuOpciones(int arr[][tam]);
+void nuevoCuadro(int arr[][tam]);
+void recorrerMatriz2_4(int arr[][tam]);
+void recorrerMatriz1_3(int arr[][tam]);
+
+int main(){
+
+  time_t t;
+  srand((unsigned) time(&t));
+
+  tam = dimensionarArreglo();
+
+  int arreglo[tam][tam];
+
+  asignarArreglo( arreglo );
+  imprimirArreglo( arreglo );
+  desplegarMenu();
+  menuOpciones( arreglo );
+
+}
+
+int dimensionarArreglo(){
+  int size;
+  printf("Inserte las dimensiones del arreglo: ");
+  scanf("%d", &size);
+  return size;
+}
+
+void asignarArreglo(int arr[][tam]) {
+  for(int i = 0; i < tam; i++ ) {
+       for (int j = 0; j < tam; j++ ) {
+           arr[i][j] = rand() % 10;
+       }
+    }
+}
+
+void imprimirArreglo(int arr[][tam]) {
+    printf("[ Cuadro Actual ]\n");
+    for( int i = 0; i < tam; i++ ) {
+        printf("\t");
+        for ( int j = 0; j < tam; j++ ){
+            printf("%d\t", arr[i][j]);
+        }
+        printf("\n");
+   }
+}
+
+void desplegarMenu(){
+  printf("\n[ Tablero de opciones ]");
+  printf("\n 1. Generar nueva matriz");
+  printf("\n 2. Región 2-4");
+  printf("\n 3. Región 1-3");
+  printf("\n 0. Cerrar\n");
+}
+
+void menuOpciones(int arr[][tam]){
+    bool check = true;
+    int opc;
+    
+    desplegarMenu();
+
+    while( check ){
+      scanf("%d", &opc);
+      printf("\n");
+      switch(opc){
+        case 0:
+          printf("Buen dia :D\n");
+          check = false;
+          break;
+        case 1:
+          nuevoCuadro(arr);
+          break;
+        case 2:
+          recorrerMatriz1_3(arr);
+          break;
+        case 3:
+          recorrerMatriz1_3(arr);
+          break;
+        default:
+          printf("El comando seleccionado no esta en la lista, intentelo denuevo :c\n");
+      }
+      printf("\n");
+    }
+}
+
+void nuevoCuadro(int arr[][tam]){
+  system("clear");
+  asignarArreglo(arr);
+  imprimirArreglo(arr);
+  menuOpciones(arr);
+}
+
+void recorrerMatriz2_4(int arr[][tam]){
+   for ( int i = 0; i < tam; i++ ){
+    for ( int j = 0;j < tam; j++ ){
+      if( ( j < tam - i && j >= i ) || ( j >= tam - i - 1  && j <= i ) ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+    printf("\n");
+  }
+}
+
+void recorrerMatriz1_3(int arr[][tam]){
+  for ( int i = 0; i < tam; i++ ){
+    for ( int j = 0;j < tam; j++ ){
+      if( ( j <= i && j <= tam - 1 - i ) || ( j >= i && j >= tam - 1 - i ) ){
+        printf("%d \t", arr[i][j]);
+      }
+      else{
+        printf("\t");
+      }
+    }
+    printf("\n");
+  }
+}
+
diff --git a/ADAS/Llanes/listas.c b/ADAS/Llanes/listas.c
new file mode 100644
index 0000000..c329579
--- /dev/null
+++ b/ADAS/Llanes/listas.c
@@ -0,0 +1,153 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdlib.h>
+
+typedef struct Nodo {
+  int ID;
+  struct Nodo  *sig;
+} Nodo;
+
+typedef struct Lista {
+  Nodo  *cabeza;
+  int longitud;
+} Lista;
+
+// Prototipado de funciones
+Nodo *crearNodo(int ID);
+// Funciones de busqueda
+int estaVacia(Lista *lista);
+int obtenerNodo_N(Lista *lista, int n);
+int obtenerTamaño();
+
+// Funciones de inserción
+void insertarNodo_principio(Lista *lista, int ID);
+void insertarNodo_final(Lista *lista, int ID);
+void insertarNodo_despuesN(Lista *lista, int ID, int n);
+
+// Funciones de eliminación
+void eliminarNodo_principio(Lista *lista);
+void eliminarNodo_final(Lista *lista);
+void eliminarNodo_N(Lista *lista, int n);
+
+int main(){
+
+  // Ejecute la función que quiera usar.
+
+}
+
+int estaVacia(Lista *lista) {
+  
+  return lista -> cabeza == NULL;
+
+};
+
+int obtenerNodo_N(Lista *lista, int n) {
+  if (lista -> cabeza == NULL) {
+    return NULL;
+  } else {
+    Nodo *puntero = lista -> cabeza;
+    int posicion = 0;
+    while (posicion < n && puntero -> sig) {
+      puntero = puntero -> sig;
+      posicion ++;
+    }
+    if (posicion != n) {
+      return NULL;
+    } else {
+      return puntero -> ID;
+    }
+  }
+}
+
+int obtenerTamaño(Lista *lista) {
+  return lista -> longitud;
+}
+
+void insertarNodo_principio(Lista *lista, int ID) {
+  Nodo *nodo = crearNodo(ID);
+  nodo -> sig = lista -> cabeza;
+  lista -> cabeza = nodo;
+  lista -> longitud ++;
+};
+
+void insertarNodo_final(Lista *lista, int ID) {
+  Nodo *nodo = crearNodo(ID);
+  if (lista -> cabeza == NULL) {
+    lista -> cabeza = nodo;
+  } else {
+    Nodo *puntero = lista -> cabeza;
+    while (puntero -> sig) {
+      puntero = puntero -> sig;
+    }
+    puntero -> sig = nodo;
+  }
+  lista -> longitud ++;
+};
+
+void insertarNodo_despuesN(Lista *lista, int ID, int n) {
+  Nodo *nodo = crearNodo(ID);
+  if (lista -> cabeza == NULL) {
+    lista -> cabeza = nodo;
+  } else {
+    Nodo *puntero = lista -> cabeza;
+    int posicion = 0;
+    while (posicion < n && puntero -> sig) {
+      puntero = puntero -> sig;
+      posicion ++;
+    }
+    nodo -> sig = puntero -> sig;
+    puntero -> sig = nodo;
+  }
+  lista -> longitud ++;
+};
+
+void eliminarNodo_principio(Lista *lista) {
+  if (lista -> cabeza) {
+    Nodo *eliminado = lista -> cabeza;
+    lista -> cabeza = lista -> cabeza -> sig;
+    eliminarNodo(eliminado);
+    lista -> longitud --;
+  }
+}
+
+void eliminarNodo_final(Lista *lista) {
+  if (lista -> cabeza) {
+    if (lista -> cabeza -> sig) {
+      Nodo *puntero = lista -> cabeza;
+      while (puntero -> sig -> sig) {
+        puntero = puntero -> sig;
+      }
+      Nodo *eliminado = puntero -> sig;
+      puntero -> sig = NULL;
+      eliminarNodo(eliminado);
+      lista -> longitud --;
+    } else {
+      Nodo *eliminado = lista -> cabeza;
+      lista -> cabeza = NULL;
+      eliminarNodo(eliminado);
+      lista -> longitud --;
+    }
+  }
+};
+
+void eliminarNodo_N(Lista *lista, int n) {
+  if (lista -> cabeza) {
+    if (n == 0) {
+      Nodo *eliminado = lista -> cabeza;
+      lista -> cabeza = lista -> cabeza -> sig;
+      eliminarNodo(eliminado);
+      lista -> longitud --;
+    } else if (n < lista -> longitud) {
+      Nodo *puntero = lista -> cabeza;
+      int posicion = 0;
+      while (posicion < (n-1)) {
+        puntero = puntero -> sig;
+        posicion ++;
+      }
+      Nodo *eliminado = puntero -> sig;
+      puntero -> sig = eliminado -> sig;
+      eliminarNodo(eliminado);
+      lista -> longitud --;
+    }
+  }
+}
\ No newline at end of file
diff --git a/ADAS/Reyes/.DS_Store b/ADAS/Reyes/.DS_Store
new file mode 100644
index 0000000..5008ddf
Binary files /dev/null and b/ADAS/Reyes/.DS_Store differ
diff --git a/ADAS/Reyes/ADA4.c b/ADAS/Reyes/ADA4.c
new file mode 100644
index 0000000..6693372
--- /dev/null
+++ b/ADAS/Reyes/ADA4.c
@@ -0,0 +1,402 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int N = 3;
+int running = 1;
+
+// Main Functions
+void generateArr(int arr[][N]);
+void printArr(int arr[][N]);
+void menuReturn();
+
+// Array Paths
+void recorrerMatriz1_2Ascendente(int arr[][N]);
+void recorrerMatriz1_2Descendente(int arr[][N]);
+void recorrerMatriz3_4Ascendente(int arr[][N]);
+void recorrerMatriz3_4Descendente(int arr[][N]);
+void recorrerMatriz1_4Ascendente(int arr[][N]);
+void recorrerMatriz1_4Descendente(int arr[][N]);
+void recorrerMatriz2_3Ascendente(int arr[][N]);
+void recorrerMatriz2_3Descendente(int arr[][N]);
+void recorrerMatriz1Ascendente(int arr[][N]);
+void recorrerMatriz1Descendente(int arr[][N]);
+void recorrerMatriz2Ascendente(int arr[][N]);
+void recorrerMatriz2Descendente(int arr[][N]);
+void recorrerMatriz3Ascendente(int arr[][N]);
+void recorrerMatriz3Descendente(int arr[][N]);
+void recorrerMatriz4Ascendente(int arr[][N]);
+void recorrerMatriz4Descendente(int arr[][N]);
+void recorrerDiagonalPrincipal(int arr[][N]);
+void recorrerDiagonalInvertida(int arr[][N]);
+
+
+int main() {
+
+    int arreglo[N][N], ans;
+
+    // Rand initializer
+    srand(time(NULL));
+
+    generateArr(arreglo);
+
+    while(running == 1) {
+        system("clear");
+        printf("\n\033[1;34m===============================================\n");
+        printf("============ RECORRIDO DE MATRICES ============\n");
+        printf("===============================================\n\n\033[0m");
+
+        printArr(arreglo);
+        printf("\n");
+
+        printf("MENU: \n");
+        printf(" \033[32m1. \033[0mGenerar nueva matriz\n");
+        printf(" \033[32m2. \033[0m 1-2 Ascendente      \033[32m3. \033[0m 1-2 Descendente      \033[32m4. \033[0m 3-4 Ascendente      \033[32m5. \033[0m 3-4 Descendente\n");
+        printf(" \033[32m6. \033[0m 1-4 Ascendente      \033[32m7. \033[0m 1-4 Descendente      \033[32m8. \033[0m 2-3 Ascendente      \033[32m9. \033[0m 2-3 Descendente\n");
+        printf(" \033[32m10. \033[0m 1 Ascendente       \033[32m11. \033[0m 1 Descendente       \033[32m12. \033[0m 2 Ascendente       \033[32m13. \033[0m 2 Descendente\n");
+        printf(" \033[32m14. \033[0m 3 Ascendente       \033[32m15. \033[0m 3 Descendente       \033[32m16. \033[0m 4 Ascendente       \033[32m17. \033[0m 4 Descendente\n");
+        printf(" \033[32m18. \033[0m Diagonal           \033[32m19. \033[0m Diagonal Invertida  \033[32m0. \033[0mTerminar sesión\n\n");
+
+        printf(" > ¿Qué acción deseas realizar?: \033[1;32m");
+        scanf("%d", &ans);
+        printf("\033[0m\n");
+
+        switch (ans)
+        {
+            case 1:
+                generateArr(arreglo);
+                break;
+
+            case 2:
+                recorrerMatriz1_2Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;            
+            
+            case 3:
+                recorrerMatriz1_2Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 4:
+                recorrerMatriz3_4Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 5:
+                recorrerMatriz3_4Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 6:
+                recorrerMatriz1_4Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 7:
+                recorrerMatriz1_4Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 8:
+                recorrerMatriz2_3Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 9:
+                recorrerMatriz2_3Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 10:
+                recorrerMatriz1Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 11:
+                recorrerMatriz1Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 12:
+                recorrerMatriz2Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 13:
+                recorrerMatriz2Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 14:
+                recorrerMatriz3Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 15:
+                recorrerMatriz3Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 16:
+                recorrerMatriz4Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 17:
+                recorrerMatriz4Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 18:
+                recorrerDiagonalPrincipal(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 19:
+                recorrerDiagonalInvertida(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 0:
+                running = 0;
+                break;
+
+            default:
+                printf("\n \033[31mIngrese una opción Válida\033[0m\n");
+                menuReturn();
+                break;
+        }
+
+        printf("\n");
+    }
+
+}
+
+void menuReturn() {
+    int ans;
+
+    printf("\n [ ¿Deseas regresar al menú? (Yes = 1/ No = 0) ]: ");
+    scanf("%d", &ans);
+    if(ans == 0) {
+        running = 0;
+    }
+}
+
+void generateArr(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            arr[i][j] = rand() % 10;
+        }
+    }
+}
+
+void printArr(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        printf("                ");
+        for(int j = 0; j < N; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        printf("\n");
+    }
+}
+
+// Path Funcionts
+void recorrerMatriz1_2Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N - i; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerMatriz1_2Descendente(int arr[][N]) {
+    for(int i = N - 1; i >= 0; i--) {
+        for(int j = 0; j < N - i; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerMatriz3_4Ascendente(int arr[][N]) {
+    for(int i = 0; i <= (N - 1); i++) {
+        for(int j = (N - 1) - i; j <= N - 1; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerMatriz3_4Descendente(int arr[][N]) {
+    for(int i = N - 1; i >= 0; i--) {
+        for(int j = (N - 1) - i; j < N; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerMatriz1_4Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j <= i; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerMatriz1_4Descendente(int arr[][N]) {
+    for(int i = (N - 1); i >= 0; i--) {
+        for(int j = 0; j <= i; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerMatriz2_3Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = i; j < N; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerMatriz2_3Descendente(int arr[][N]) {
+    for(int i = (N - 1); i >= 0; i--) {
+        for(int j = i; j < N; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerMatriz1Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        if( i <= N/2) {
+            for(int j = 0; j <= i; j++) {
+                printf("%d  ", arr[i][j]);
+            }
+        } else {
+            for(int j = 0; j <= (N - 1) - i; j++) {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        
+    }
+}
+
+void recorrerMatriz1Descendente(int arr[][N]) {
+    for(int i = (N - 1); i >= 0; i--) {
+        if( i <= N/2) {
+            for(int j = 0; j <= i; j++) {
+                printf("%d  ", arr[i][j]);
+            }
+        } else {
+            for(int j = 0; j <= (N - 1) - i; j++) {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        
+    }
+}
+
+void recorrerMatriz2Ascendente(int arr[][N]) {
+    for(int i = 0; i <= N/2; i++) {
+        for(int j = i; j <= (N - 1) - i; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerMatriz2Descendente(int arr[][N]) {
+    for(int i = N/2; i >= 0; i--) {
+        for(int j = i; j <= (N - 1) - i; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerMatriz3Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        if( i <= N/2) {
+            for(int j = (N - 1) - i; j < N; j++) {
+                printf("%d  ", arr[i][j]);
+            } 
+        } else {
+
+            for(int j = i; j < N; j++) {
+                printf("%d  ", arr[i][j]);
+            }
+       }
+       
+    }
+}
+
+void recorrerMatriz3Descendente(int arr[][N]) {
+    for(int i = (N - 1); i >= 0; i--) {
+        if(i <= N/2) {
+            for(int j = (N - 1) - i; j < N; j++) {
+                printf("%d  ", arr[i][j]);
+            }
+        } else {
+
+            for(int j = i; j < N; j++){
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        
+    }
+}
+
+void recorrerMatriz4Ascendente(int arr[][N]) {
+    for(int i = N/2; i < N; i++) {
+        for(int j = (N - 1) - i; j <= i; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerMatriz4Descendente(int arr[][N]) {
+    for(int i = (N - 1); i >= N/2; i--) {
+        for(int j = (N - 1) - i; j <= i; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        
+    }
+}
+
+void recorrerDiagonalPrincipal(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        printf("%d  ", arr[i][i]);
+    }
+}
+
+void recorrerDiagonalInvertida(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        printf("%d  ", arr[i][(N - 1) - i]);
+    }
+}
\ No newline at end of file
diff --git a/ADAS/Reyes/ADA4_visual.c b/ADAS/Reyes/ADA4_visual.c
new file mode 100644
index 0000000..96dbb73
--- /dev/null
+++ b/ADAS/Reyes/ADA4_visual.c
@@ -0,0 +1,494 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int N = 5;
+int running = 1;
+
+// Main Functions
+void generateArr(int arr[][N]);
+void printArr(int arr[][N]);
+void menuReturn();
+
+// Array Paths
+void recorrerMatriz1_2Ascendente(int arr[][N]);
+void recorrerMatriz1_2Descendente(int arr[][N]);
+void recorrerMatriz3_4Ascendente(int arr[][N]);
+void recorrerMatriz3_4Descendente(int arr[][N]);
+void recorrerMatriz1_4Ascendente(int arr[][N]);
+void recorrerMatriz1_4Descendente(int arr[][N]);
+void recorrerMatriz2_3Ascendente(int arr[][N]);
+void recorrerMatriz2_3Descendente(int arr[][N]);
+void recorrerMatriz1Ascendente(int arr[][N]);
+void recorrerMatriz1Descendente(int arr[][N]);
+void recorrerMatriz2Ascendente(int arr[][N]);
+void recorrerMatriz2Descendente(int arr[][N]);
+void recorrerMatriz3Ascendente(int arr[][N]);
+void recorrerMatriz3Descendente(int arr[][N]);
+void recorrerMatriz4Ascendente(int arr[][N]);
+void recorrerMatriz4Descendente(int arr[][N]);
+void recorrerDiagonalPrincipal(int arr[][N]);
+void recorrerDiagonalInvertida(int arr[][N]);
+
+
+int main() {
+
+    int arreglo[N][N], ans;
+
+    // Rand initializer
+    srand(time(NULL));
+
+    generateArr(arreglo);
+
+    while(running == 1) {
+        system("clear");
+        printf("\n\033[1;34m===============================================\n");
+        printf("============ RECORRIDO DE MATRICES ============\n");
+        printf("===============================================\n\n\033[0m");
+
+        printArr(arreglo);
+        printf("\n");
+
+        printf("MENU: \n");
+        printf(" \033[32m1. \033[0mGenerar nueva matriz\n");
+        printf(" \033[32m2. \033[0m 1-2 Ascendente      \033[32m3. \033[0m 1-2 Descendente      \033[32m4. \033[0m 3-4 Ascendente      \033[32m5. \033[0m 3-4 Descendente\n");
+        printf(" \033[32m6. \033[0m 1-4 Ascendente      \033[32m7. \033[0m 1-4 Descendente      \033[32m8. \033[0m 2-3 Ascendente      \033[32m9. \033[0m 2-3 Descendente\n");
+        printf(" \033[32m10. \033[0m 1 Ascendente       \033[32m11. \033[0m 1 Descendente       \033[32m12. \033[0m 2 Ascendente       \033[32m13. \033[0m 2 Descendente\n");
+        printf(" \033[32m14. \033[0m 3 Ascendente       \033[32m15. \033[0m 3 Descendente       \033[32m16. \033[0m 4 Ascendente       \033[32m17. \033[0m 4 Descendente\n");
+        printf(" \033[32m18. \033[0m Diagonal           \033[32m19. \033[0m Diagonal Invertida  \033[32m0. \033[0mTerminar sesión\n\n");
+
+        printf(" > ¿Qué acción deseas realizar?: \033[1;32m");
+        scanf("%d", &ans);
+        printf("\033[0m\n");
+
+        switch (ans)
+        {
+            case 1:
+                generateArr(arreglo);
+                break;
+
+            case 2:
+                recorrerMatriz1_2Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;            
+            
+            case 3:
+                recorrerMatriz1_2Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 4:
+                recorrerMatriz3_4Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 5:
+                recorrerMatriz3_4Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 6:
+                recorrerMatriz1_4Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 7:
+                recorrerMatriz1_4Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 8:
+                recorrerMatriz2_3Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 9:
+                recorrerMatriz2_3Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 10:
+                recorrerMatriz1Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 11:
+                recorrerMatriz1Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 12:
+                recorrerMatriz2Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 13:
+                recorrerMatriz2Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 14:
+                recorrerMatriz3Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 15:
+                recorrerMatriz3Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 16:
+                recorrerMatriz4Ascendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 17:
+                recorrerMatriz4Descendente(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 18:
+                recorrerDiagonalPrincipal(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 19:
+                recorrerDiagonalInvertida(arreglo);
+                printf("\n");
+                menuReturn();
+                break;      
+
+            case 0:
+                running = 0;
+                break;
+
+            default:
+                printf("\n \033[31mIngrese una opción Válida\033[0m\n");
+                menuReturn();
+                break;
+        }
+
+        printf("\n");
+    }
+
+}
+
+void menuReturn() {
+    int ans;
+
+    printf("\n [ ¿Deseas regresar al menú? (Yes = 1/ No = 0) ]: ");
+    scanf("%d", &ans);
+    if(ans == 0) {
+        running = 0;
+    }
+}
+
+void generateArr(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            arr[i][j] = rand() % 10;
+        }
+    }
+}
+
+void printArr(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        printf("                ");
+        for(int j = 0; j < N; j++) {
+            printf("%d  ", arr[i][j]);
+        }
+        printf("\n");
+    }
+}
+
+// Path Funcionts
+void recorrerMatriz1_2Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if( j <= (N - 1) - i  ) {
+                printf("\033[35m%d  \033[0m", arr[i][j]);
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz1_2Descendente(int arr[][N]) {
+    for(int i = (N-1); i >= 0; i--) {
+        for(int j = 0; j < N; j++) {
+            if( j <= (N - 1) - ((N - 1) - i) ){
+                printf("\033[35m%d  \033[0m", arr[i][j]);
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz3_4Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if( j >= (N - 1) - i ) {
+                printf("\033[35m%d  \033[0m", arr[i][j]);
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz3_4Descendente(int arr[][N]) {
+    for(int i = (N-1); i >= 0; i--) {
+        for(int j = 0; j < N; j++) {
+            if( j >= (N - 1) - ((N - 1) - i) ) {
+                printf("\033[35m%d  \033[0m", arr[i][j]);
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz1_4Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if( j <= i ) {
+                printf("\033[35m%d  \033[0m", arr[i][j]);
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz1_4Descendente(int arr[][N]) {
+    for(int i = (N-1); i >= 0; i--) {
+        for(int j = 0; j < N; j++) {
+            if( j <= ((N-1) - i) ) {
+                printf("\033[35m%d  \033[0m", arr[i][j]);
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz2_3Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if( j >= i) {
+                printf("\033[35m%d  \033[0m", arr[i][j]);
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz2_3Descendente(int arr[][N]) {
+    for(int i = (N-1); i >= 0; i--) {
+        for(int j = 0; j < N; j++) {
+            if( j >= ((N-1) -i) ) {
+                printf("\033[35m%d  \033[0m", arr[i][j]);
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz1Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if(i <= (N/2)) {
+                if( j <= i ) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            } else {
+                if( j <= (N - 1) - i  ) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz1Descendente(int arr[][N]) {
+    for(int i = (N-1); i >= 0; i--) {
+        for(int j = 0; j < N; j++) {
+            if(i <= (N/2)) {
+                if( j <= i ) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            } else {
+                if( j <= (N - 1) - i  ) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz2Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if( i <= (N/2) && j <= (N - 1) - i) {
+                if( j >= i) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz2Descendente(int arr[][N]) {
+    for(int i = (N-1); i >= 0; i--) {
+        for(int j = 0; j < N; j++) {
+            if( (N - 1) - i <= (N/2) ) {
+                if( j <= (N - 1) - ((N - 1) - i) && j >= ((N-1) -i) ){
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz3Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if(j >= (N/2)) {
+                if( j >= i && j >= (N - 1) - i) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz3Descendente(int arr[][N]) {
+    for(int i = (N-1); i >= 0; i--) {
+        for(int j = 0; j < N; j++) {
+            if(j >= (N/2)) {
+                if( j >= i && j >= (N - 1) - i) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz4Ascendente(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if( i >= (N/2) ) {
+                if( j >= (N - 1) - i && j <= i) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz4Descendente(int arr[][N]) {
+    for(int i = (N-1); i >= 0; i--) {
+        for(int j = 0; j < N; j++) {
+            if( i < N ) {
+                if( j <= ((N-1) - i) && j >= (N - 1) - ((N - 1) - i) ) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerDiagonalPrincipal(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if( i == j) {
+                printf("\033[35m%d  \033[0m", arr[i][j]);
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerDiagonalInvertida(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if( (N - 1) - i == j) {
+                printf("\033[35m%d  \033[0m", arr[i][j]);
+            } else {
+                printf("%d  ", arr[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
\ No newline at end of file
diff --git a/ADAS/Reyes/Ada6-Listas.c b/ADAS/Reyes/Ada6-Listas.c
new file mode 100644
index 0000000..c9c323f
--- /dev/null
+++ b/ADAS/Reyes/Ada6-Listas.c
@@ -0,0 +1,211 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+/////////////////////////////
+/* Definiciones de Structs */
+/////////////////////////////
+
+typedef struct Nodo {
+  int ID;
+  struct Nodo  *sig;
+} Nodo;
+
+typedef struct Lista {
+  Nodo  *cabeza;
+  int longitud;
+} Lista;
+
+//////////////////////////////
+/* Declaración de funciones */
+//////////////////////////////
+
+// Menú
+void menu();
+
+// Creación de un Nodo
+Nodo *crearNodo(int ID);
+
+// Eliminación de un Nodo
+void eliminarNodo(Nodo *nodo);
+
+// ¿Está vacia la lista?
+
+int estaVacia(Lista *lista);
+
+// Inserción de un Nodo (al principio)
+void insertarNodo_principio(Lista *lista, int ID);
+
+// Inserción de un Nodo (al final)
+void insertarNodo_final(Lista *lista, int ID);
+
+// Inserción de un Nodo (después del elemento N)
+void insertarNodo_despuesN(Lista *lista, int ID, int n);
+
+// Obtención de un Nodo (N)
+int obtenerNodo_N(Lista *lista, int n);
+
+// Obtener número de elementos en la Lista
+int obtenerLargo();
+
+// Eliminación de un Nodo (al principio)
+void eliminarNodo_principio(Lista *lista);
+
+// Eliminación de un Nodo (al final)
+void eliminarNodo_final(Lista *lista);
+
+// Eliminación de un Nodo (N)
+void eliminarNodo_N(Lista *lista, int n);
+
+////////////////////////////
+/* Bloque MAIN del código */
+////////////////////////////
+
+int main() {
+
+  // Opción Deseada
+
+  return 0;
+}
+
+/////////////////////////////
+/* Definición de funciones */
+/////////////////////////////
+
+// Creación de un Nodo
+Nodo *crearNodo(int ID) {
+  Nodo *nodo = (Nodo *) malloc(sizeof (Nodo));
+  nodo -> ID = ID;
+  nodo -> sig = NULL;
+  return nodo;
+}
+
+// Eliminación de un Nodo
+void eliminarNodo(Nodo *nodo) {
+  free(nodo);
+};
+
+// ¿Está vacia la lista?
+
+int estaVacia(Lista *lista) {
+  return lista -> cabeza == NULL;
+};
+
+// Inserción de un Nodo (al principio)
+void insertarNodo_principio(Lista *lista, int ID) {
+  Nodo *nodo = crearNodo(ID);
+  nodo -> sig = lista -> cabeza;
+  lista -> cabeza = nodo;
+  lista -> longitud ++;
+};
+
+// Inserción de un Nodo (al final)
+void insertarNodo_final(Lista *lista, int ID) {
+  Nodo *nodo = crearNodo(ID);
+  if (lista -> cabeza == NULL) {
+    lista -> cabeza = nodo;
+  } else {
+    Nodo *puntero = lista -> cabeza;
+    while (puntero -> sig) {
+      puntero = puntero -> sig;
+    }
+    puntero -> sig = nodo;
+  }
+  lista -> longitud ++;
+};
+
+// Inserción de un Nodo (después del elemento N)
+void insertarNodo_despuesN(Lista *lista, int ID, int n) {
+  Nodo *nodo = crearNodo(ID);
+  if (lista -> cabeza == NULL) {
+    lista -> cabeza = nodo;
+  } else {
+    Nodo *puntero = lista -> cabeza;
+    int posicion = 0;
+    while (posicion < n && puntero -> sig) {
+      puntero = puntero -> sig;
+      posicion ++;
+    }
+    nodo -> sig = puntero -> sig;
+    puntero -> sig = nodo;
+  }
+  lista -> longitud ++;
+};
+
+
+// Obtención de un Nodo (N)
+int obtenerNodo_N(Lista *lista, int n) {
+  if (lista -> cabeza == NULL) {
+    return NULL;
+  } else {
+    Nodo *puntero = lista -> cabeza;
+    int posicion = 0;
+    while (posicion < n && puntero -> sig) {
+      puntero = puntero -> sig;
+      posicion ++;
+    }
+    if (posicion != n) {
+      return NULL;
+    } else {
+      return puntero -> ID;
+    }
+  }
+}
+
+// Obtener número de elementos en la Lista
+int obtenerLargo(Lista *lista) {
+  return lista -> longitud;
+}
+
+// Eliminación de un Nodo (al principio)
+void eliminarNodo_principio(Lista *lista) {
+  if (lista -> cabeza) {
+    Nodo *eliminado = lista -> cabeza;
+    lista -> cabeza = lista -> cabeza -> sig;
+    eliminarNodo(eliminado);
+    lista -> longitud --;
+  }
+}
+
+// Eliminación de un Nodo (al final)
+void eliminarNodo_final(Lista *lista) {
+  if (lista -> cabeza) {
+    if (lista -> cabeza -> sig) {
+      Nodo *puntero = lista -> cabeza;
+      while (puntero -> sig -> sig) {
+        puntero = puntero -> sig;
+      }
+      Nodo *eliminado = puntero -> sig;
+      puntero -> sig = NULL;
+      eliminarNodo(eliminado);
+      lista -> longitud --;
+    } else {
+      Nodo *eliminado = lista -> cabeza;
+      lista -> cabeza = NULL;
+      eliminarNodo(eliminado);
+      lista -> longitud --;
+    }
+  }
+};
+
+// Eliminación de un Nodo (N)
+void eliminarNodo_N(Lista *lista, int n) {
+  if (lista -> cabeza) {
+    if (n == 0) {
+      Nodo *eliminado = lista -> cabeza;
+      lista -> cabeza = lista -> cabeza -> sig;
+      eliminarNodo(eliminado);
+      lista -> longitud --;
+    } else if (n < lista -> longitud) {
+      Nodo *puntero = lista -> cabeza;
+      int posicion = 0;
+      while (posicion < (n-1)) {
+        puntero = puntero -> sig;
+        posicion ++;
+      }
+      Nodo *eliminado = puntero -> sig;
+      puntero -> sig = eliminado -> sig;
+      eliminarNodo(eliminado);
+      lista -> longitud --;
+    }
+  }
+}
diff --git a/ADAS/Reyes/Ada6-Racionales.c b/ADAS/Reyes/Ada6-Racionales.c
new file mode 100644
index 0000000..e8feb5b
--- /dev/null
+++ b/ADAS/Reyes/Ada6-Racionales.c
@@ -0,0 +1,105 @@
+#include <stdio.h>
+
+struct fracciones
+{
+    int nominador;
+    int denominador;
+};
+
+void reduccion(struct fracciones *fracc);
+void suma(struct fracciones *fracc, struct fracciones *fracc1, struct fracciones *fracc2);
+void resta(struct fracciones *fracc, struct fracciones *fracc1, struct fracciones *fracc2);
+void mult(struct fracciones *fracc, struct fracciones *fracc1, struct fracciones *fracc2);
+void div(struct fracciones *fracc, struct fracciones *fracc1, struct fracciones *fracc2);
+
+int main () {
+    struct fracciones fraccionPrim, fraccionSec, fraccionRes;
+
+    printf("\n");
+    printf("Escribe la fracción en formato <Numerador> <Denominador>, respetando los espacios y dejando un salto de línea entra cada fracción: \n");
+    scanf("%d %d", &fraccionPrim.nominador, &fraccionPrim.denominador);
+    scanf("%d %d", &fraccionSec.nominador, &fraccionSec.denominador);
+
+
+    printf("\n");
+
+    suma(&fraccionRes, &fraccionPrim, &fraccionSec);
+
+    resta(&fraccionRes, &fraccionPrim, &fraccionSec);
+
+    mult(&fraccionRes, &fraccionPrim, &fraccionSec);
+
+    div(&fraccionRes, &fraccionPrim, &fraccionSec);
+
+    printf("\n");
+}
+
+void reduccion(struct fracciones *fracc) {
+
+    int flag = 1;
+
+    if ((*fracc).nominador == 0) {
+        printf("\n\033[32m0\033[0m\n");
+        return;
+    } else if ((*fracc).denominador == 0) {
+        printf("\n\033[32mIndef\033[0m\n");
+        return;
+    } else {
+        while(flag == 1) {
+            if ((*fracc).nominador % 2 == 0 && (*fracc).denominador % 2 == 0) {
+                (*fracc).nominador /= 2;
+                (*fracc).denominador /= 2;     
+            } else if ((*fracc).nominador % 3 == 0 && (*fracc).denominador % 3 == 0) {
+                (*fracc).nominador /= 3;
+                (*fracc).denominador /= 3;
+            } else if ((*fracc).nominador % 5 == 0 && (*fracc).denominador % 5 == 0) {
+                (*fracc).nominador /= 5;
+                (*fracc).denominador /= 5;
+            } else if ((*fracc).nominador % 7 == 0 && (*fracc).denominador % 7 == 0) {
+                (*fracc).nominador /= 7;
+                (*fracc).denominador /= 7;
+            } else if ((*fracc).nominador % 11 == 0 && (*fracc).denominador % 11 == 0) {
+                (*fracc).nominador /= 11;
+                (*fracc).denominador /= 11;
+            } else {
+                flag = 0;
+            }
+        }
+    }
+
+    if ((*fracc).denominador == 1) {
+        printf("\033[32m\n%d\033[0m\n", (*fracc).nominador);
+    } else {
+        printf("\033[32m\n%d\033[35m/\033[32m%d\033[0m \n", (*fracc).nominador, (*fracc).denominador);
+    }
+
+    return;
+}
+
+void suma(struct fracciones *fracc, struct fracciones *fracc1, struct fracciones *fracc2) {
+    printf("La suma de las fracciones es: ");
+    (*fracc).nominador = ((*fracc1).nominador * (*fracc2).denominador) + ((*fracc2).nominador * (*fracc1).denominador);
+    (*fracc).denominador = (*fracc1).denominador * (*fracc2).denominador;
+    reduccion(fracc);
+}
+
+void resta(struct fracciones *fracc, struct fracciones *fracc1, struct fracciones *fracc2) {
+    printf("La resta de las fracciones es: ");
+    (*fracc).nominador = ((*fracc1).nominador * (*fracc2).denominador) - ((*fracc2).nominador * (*fracc1).denominador);
+    (*fracc).denominador = (*fracc1).denominador * (*fracc2).denominador;
+    reduccion(fracc);
+}
+
+void mult(struct fracciones *fracc, struct fracciones *fracc1, struct fracciones *fracc2) {
+    printf("La multiplicación de las fracciones es: ");
+    (*fracc).nominador = (*fracc1).nominador * (*fracc2).nominador;
+    (*fracc).denominador = (*fracc1).denominador * (*fracc2).denominador;
+    reduccion(fracc);
+}
+
+void div(struct fracciones *fracc, struct fracciones *fracc1, struct fracciones *fracc2) {
+    printf("La división de las fracciones es: ");
+    (*fracc).nominador = (*fracc1).nominador * (*fracc2).denominador;
+    (*fracc).denominador = (*fracc1).denominador * (*fracc2).nominador;
+    reduccion(fracc);
+}
diff --git a/ADAS/Reyes/Ada6-Sudoku.c b/ADAS/Reyes/Ada6-Sudoku.c
new file mode 100644
index 0000000..63bbd41
--- /dev/null
+++ b/ADAS/Reyes/Ada6-Sudoku.c
@@ -0,0 +1,254 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+typedef struct tableroIndividual {
+  int tablero[3][3];
+} tableroIndiv;
+
+typedef struct tableroCompleto {
+  tableroIndiv tablero[3][3];
+} tableroComp;
+
+void llenarTablero(tableroComp *tab);
+void imprimirTablero(tableroComp *tab);
+int verificarHorizontal(tableroComp *tab);
+int verificarVertical(tableroComp *tab);
+int verificarCuadro(tableroComp *tab);
+void esSudoku(tableroComp *tab);
+
+int main() {
+  printf("\n");
+
+  // Random Initializer
+  srand(time(NULL));
+
+  tableroComp sudoku;
+
+  llenarTablero(&sudoku);
+
+  /*
+
+    // SUDOKU
+
+  sudoku.tablero[0][0].tablero[0][0] = 5;
+  sudoku.tablero[0][0].tablero[0][1] = 3;
+  sudoku.tablero[0][0].tablero[0][2] = 4;
+  sudoku.tablero[0][0].tablero[1][0] = 6;
+  sudoku.tablero[0][0].tablero[1][1] = 7;
+  sudoku.tablero[0][0].tablero[1][2] = 2;
+  sudoku.tablero[0][0].tablero[2][0] = 1;
+  sudoku.tablero[0][0].tablero[2][1] = 9;
+  sudoku.tablero[0][0].tablero[2][2] = 8;
+  sudoku.tablero[0][1].tablero[0][0] = 6;
+  sudoku.tablero[0][1].tablero[0][1] = 7;
+  sudoku.tablero[0][1].tablero[0][2] = 8;
+  sudoku.tablero[0][1].tablero[1][0] = 1;
+  sudoku.tablero[0][1].tablero[1][1] = 9;
+  sudoku.tablero[0][1].tablero[1][2] = 5;
+  sudoku.tablero[0][1].tablero[2][0] = 3;
+  sudoku.tablero[0][1].tablero[2][1] = 4;
+  sudoku.tablero[0][1].tablero[2][2] = 2;
+  sudoku.tablero[0][2].tablero[0][0] = 9;
+  sudoku.tablero[0][2].tablero[0][1] = 1;
+  sudoku.tablero[0][2].tablero[0][2] = 2;
+  sudoku.tablero[0][2].tablero[1][0] = 3;
+  sudoku.tablero[0][2].tablero[1][1] = 4;
+  sudoku.tablero[0][2].tablero[1][2] = 8;
+  sudoku.tablero[0][2].tablero[2][0] = 5;
+  sudoku.tablero[0][2].tablero[2][1] = 6;
+  sudoku.tablero[0][2].tablero[2][2] = 7;
+  sudoku.tablero[1][0].tablero[0][0] = 8;
+  sudoku.tablero[1][0].tablero[0][1] = 5;
+  sudoku.tablero[1][0].tablero[0][2] = 9;
+  sudoku.tablero[1][0].tablero[1][0] = 4;
+  sudoku.tablero[1][0].tablero[1][1] = 2;
+  sudoku.tablero[1][0].tablero[1][2] = 6;
+  sudoku.tablero[1][0].tablero[2][0] = 7;
+  sudoku.tablero[1][0].tablero[2][1] = 1;
+  sudoku.tablero[1][0].tablero[2][2] = 3;
+  sudoku.tablero[1][1].tablero[0][0] = 7;
+  sudoku.tablero[1][1].tablero[0][1] = 6;
+  sudoku.tablero[1][1].tablero[0][2] = 1;
+  sudoku.tablero[1][1].tablero[1][0] = 8;
+  sudoku.tablero[1][1].tablero[1][1] = 5;
+  sudoku.tablero[1][1].tablero[1][2] = 3;
+  sudoku.tablero[1][1].tablero[2][0] = 9;
+  sudoku.tablero[1][1].tablero[2][1] = 2;
+  sudoku.tablero[1][1].tablero[2][2] = 4;
+  sudoku.tablero[1][2].tablero[0][0] = 4;
+  sudoku.tablero[1][2].tablero[0][1] = 2;
+  sudoku.tablero[1][2].tablero[0][2] = 3;
+  sudoku.tablero[1][2].tablero[1][0] = 7;
+  sudoku.tablero[1][2].tablero[1][1] = 9;
+  sudoku.tablero[1][2].tablero[1][2] = 1;
+  sudoku.tablero[1][2].tablero[2][0] = 8;
+  sudoku.tablero[1][2].tablero[2][1] = 5;
+  sudoku.tablero[1][2].tablero[2][2] = 6;
+  sudoku.tablero[2][0].tablero[0][0] = 9;
+  sudoku.tablero[2][0].tablero[0][1] = 6;
+  sudoku.tablero[2][0].tablero[0][2] = 1;
+  sudoku.tablero[2][0].tablero[1][0] = 2;
+  sudoku.tablero[2][0].tablero[1][1] = 8;
+  sudoku.tablero[2][0].tablero[1][2] = 7;
+  sudoku.tablero[2][0].tablero[2][0] = 3;
+  sudoku.tablero[2][0].tablero[2][1] = 4;
+  sudoku.tablero[2][0].tablero[2][2] = 5;
+  sudoku.tablero[2][1].tablero[0][0] = 5;
+  sudoku.tablero[2][1].tablero[0][1] = 3;
+  sudoku.tablero[2][1].tablero[0][2] = 7;
+  sudoku.tablero[2][1].tablero[1][0] = 4;
+  sudoku.tablero[2][1].tablero[1][1] = 1;
+  sudoku.tablero[2][1].tablero[1][2] = 9;
+  sudoku.tablero[2][1].tablero[2][0] = 2;
+  sudoku.tablero[2][1].tablero[2][1] = 8;
+  sudoku.tablero[2][1].tablero[2][2] = 6;
+  sudoku.tablero[2][2].tablero[0][0] = 2;
+  sudoku.tablero[2][2].tablero[0][1] = 8;
+  sudoku.tablero[2][2].tablero[0][2] = 4;
+  sudoku.tablero[2][2].tablero[1][0] = 6;
+  sudoku.tablero[2][2].tablero[1][1] = 3;
+  sudoku.tablero[2][2].tablero[1][2] = 5;
+  sudoku.tablero[2][2].tablero[2][0] = 1;
+  sudoku.tablero[2][2].tablero[2][1] = 7;
+  sudoku.tablero[2][2].tablero[2][2] = 9;
+
+  */
+
+  imprimirTablero(&sudoku);
+
+  esSudoku(&sudoku);
+
+  printf("\n");
+  return 0;
+}
+
+void llenarTablero(tableroComp *tab) {
+
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 3; j++) {
+      for (int a = 0; a < 3; a++) {
+        for (int b = 0; b < 3; b++) {
+          (*tab).tablero[i][j].tablero[a][b] = rand() % 9 + 1;
+        }
+      }
+    }
+  }
+
+}
+
+void imprimirTablero(tableroComp *tab) {
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 3; j++) {
+      for (int a = 0; a < 3; a++) {
+        for (int b = 0; b < 3; b++) {
+          printf("%d ", (*tab).tablero[i][a].tablero[j][b]);
+        }
+        printf("  ");
+      }
+      printf("\n");
+    }
+    printf("\n");
+  }
+}
+
+int verificarHorizontal(tableroComp *tab) {
+  int flag = 1;
+
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 3; j++) {
+      int cont = 0;
+      int num[9];
+      for (int a = 0; a < 3; a++) {
+        for (int b = 0; b < 3 ; b++) {
+          num[cont] = (*tab).tablero[i][a].tablero[j][b];
+          cont += 1;
+        }
+      }
+      for(int x = 0; x < 9; x++){
+        for(int z = 0; z < 9; z++) {
+          if (num[x] == num [z] && x != z) {
+            flag = 0;
+        }
+      }
+      cont = 0;
+    }
+  }
+
+}
+return flag;
+}
+
+int verificarVertical(tableroComp *tab) {
+  int flag = 1;
+
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 3; j++) {
+      int cont = 0;
+      int num[9];
+      for (int a = 0; a < 3; a++) {
+        for (int b = 0; b < 3 ; b++) {
+          num[cont] = (*tab).tablero[j][i].tablero[b][a];
+          cont += 1;
+        }
+      }
+      for(int x = 0; x < 9; x++){
+        for(int z = 0; z < 9; z++) {
+          if (num[x] == num [z] && z != x) {
+            flag = 0;
+        }
+      }
+      cont = 0;
+    }
+  }
+
+
+}
+  return flag;
+
+}
+
+int verificarCuadro(tableroComp *tab) {
+  int flag = 1;
+  int acum = 0;
+
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 3; j++) {
+      int cont = 0;
+      int num[9];
+      for (int a = 0; a < 3; a++) {
+        for (int b = 0; b < 3; b++) {
+          num[cont] = (*tab).tablero[i][j].tablero[a][b];
+          cont += 1;
+        }
+      }
+      for(int x = 0; x < 9; x++){
+        for(int z = 0; z < 9; z++) {
+          if (num[x] == num [z] && z != x) {
+            flag = 0;
+        }
+      }
+      cont = 0;
+    }
+  }
+
+  if(acum == 9) {
+    flag = 1;
+  }
+
+}
+  return flag;
+}
+
+void esSudoku(tableroComp *tab) {
+  int a,b,c;
+  a = verificarVertical(tab);
+  b = verificarHorizontal(tab);
+  c = verificarCuadro(tab);
+
+  if( a == 1 && b == 1 && c ==1 ) {
+    printf("Es Sudoku");
+  } else {
+    printf("No Es Sudoku");
+  }
+}
diff --git a/ADAS/Reyes/Ejercicio26Marzo.c b/ADAS/Reyes/Ejercicio26Marzo.c
new file mode 100644
index 0000000..96e6389
--- /dev/null
+++ b/ADAS/Reyes/Ejercicio26Marzo.c
@@ -0,0 +1,79 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int N = 7;
+
+void generateArr(int arr[][N]);
+void printArr(int arr[][N]);
+void from2to4(int arr[][N]);
+void from1to3(int arr[][N]);
+
+int main () {
+
+    int arr[N][N];
+
+    // Rand initializer
+    srand(time(NULL));
+
+    generateArr(arr);
+
+    from2to4(arr);
+    printf("\n");
+    from1to3(arr);
+
+}
+
+// Generar un array aleatorio
+void generateArr(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            arr[i][j] = rand() % 10;
+        }
+    }
+}
+
+
+// Imprimir el arreglo con el area 2 y 4 resaltadas
+void from2to4(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if( i <= (N/2) && j <= (N - 1) - i) {
+                if( j >= i) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            } else {
+                if( j >= (N - 1) - i && j <= i) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            }
+        }
+        printf("\n");
+    }
+}
+
+// Imprimir el arreglo con el area 1 y 3 resaltadas
+void from1to3(int arr[][N]) {
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            if(j >= (N/2)) {
+                if( j >= i && j >= (N - 1) - i) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            } else {
+                if( j <= i && j <= (N - 1) - i) {
+                    printf("\033[35m%d  \033[0m", arr[i][j]);
+                } else {
+                    printf("%d  ", arr[i][j]);
+                }
+            }
+        }
+        printf("\n");
+    }
+}
\ No newline at end of file
diff --git "a/ADAS/\303\201vila/ADA6-Racionales.c" "b/ADAS/\303\201vila/ADA6-Racionales.c"
new file mode 100644
index 0000000..c894d93
--- /dev/null
+++ "b/ADAS/\303\201vila/ADA6-Racionales.c"
@@ -0,0 +1,119 @@
+#include <stdio.h>
+
+struct frac
+{
+    int firstNumber;
+    int secondNumber;
+};
+
+void redo(struct frac *frac);
+void add(struct frac *frac, struct frac *fracO, struct frac *fracT);
+void sus(struct frac *frac, struct frac *fracO, struct frac *fracT);
+void mult(struct frac *frac, struct frac *fracO, struct frac *fracT);
+void div(struct frac *frac, struct frac *fracO, struct frac *fracT);
+
+int main()
+{
+    struct frac frac1, frac2, result;
+    printf("Escribe las fracciones de la siguiente forma: -Numerador- -Denominador-");
+
+    scanf("%d %d", &frac1.firstNumber, &frac1.secondNumber);
+    scanf("%d %d", &frac2.firstNumber, &frac2.secondNumber);
+
+    printf("\n");
+    add(&result, &frac1, &frac2);
+    printf("\n");
+    sus(&result, &frac1, &frac2);
+    printf("\n");
+    mult(&result, &frac1, &frac2);
+    printf("\n");
+    div(&result, &frac1, &frac2);
+}
+void redo(struct frac *frac)
+{
+    int marker = 1;
+    if ((*frac).firstNumber == 0)
+    {
+        printf("0");
+        return;
+    }
+    else if ((*frac).secondNumber == 0)
+    {
+        printf("Error (Not defined)");
+        return;
+    }
+    else
+    {
+        while (marker == 1)
+        {
+            if ((*frac).firstNumber % 2 == 0 && (*frac).secondNumber % 2 == 0)
+            {
+                (*frac).firstNumber /= 2;
+                (*frac).secondNumber /= 2;
+            }
+            else if ((*frac).firstNumber % 3 == 0 && (*frac).secondNumber % 3 == 0)
+            {
+                (*frac).firstNumber /= 3;
+                (*frac).secondNumber /= 3;
+            }
+            else if ((*frac).firstNumber % 5 == 0 && (*frac).secondNumber % 5 == 0)
+            {
+                (*frac).firstNumber /= 5;
+                (*frac).secondNumber /= 5;
+            }
+            else if ((*frac).firstNumber % 7 == 0 && (*frac).secondNumber % 7 == 0)
+            {
+                (*frac).firstNumber /= 7;
+                (*frac).secondNumber /= 7;
+            }
+            else if ((*frac).firstNumber % 11 == 0 && (*frac).secondNumber % 11 == 0)
+            {
+                (*frac).firstNumber /= 11;
+                (*frac).secondNumber /= 11;
+            }
+            else
+            {
+                marker = 0;
+            }
+        }
+    }
+
+    if ((*frac).secondNumber == 1)
+    {
+        printf("%d", (*frac).firstNumber);
+    }
+    else
+    {
+        printf("%d, %d", (*frac).firstNumber, (*frac).secondNumber);
+    }
+
+    return;
+}
+void add(struct frac *frac, struct frac *fracO, struct frac *fracT)
+{
+    printf("La suma es: ");
+    (*frac).firstNumber = ((*fracO).firstNumber * (*fracT).secondNumber) + ((*fracT).firstNumber * (*fracO).secondNumber);
+    (*frac).secondNumber = (*fracO).firstNumber * (*fracT).secondNumber;
+    redo(frac);
+}
+void sus(struct frac *frac, struct frac *fracO, struct frac *fracT)
+{
+    printf("La resta es: ");
+    (*frac).firstNumber = ((*fracO).firstNumber * (*fracT).secondNumber) - ((*fracT).firstNumber * (*fracO).secondNumber);
+    (*frac).secondNumber = (*fracO).secondNumber * (*fracT).secondNumber;
+    redo(frac);
+}
+void mult(struct frac *frac, struct frac *fracO, struct frac *fracT)
+{
+    printf("La multiplicación es: ");
+    (*frac).firstNumber = (*fracO).firstNumber * (*fracT).firstNumber;
+    (*frac).secondNumber = (*fracO).secondNumber * (*fracT).secondNumber;
+    redo(frac);
+}
+void div(struct frac *frac, struct frac *fracO, struct frac *fracT)
+{
+    printf("La división es: ");
+    (*frac).firstNumber = (*fracO).firstNumber * (*fracT).secondNumber;
+    (*frac).secondNumber = (*fracO).secondNumber * (*fracT).firstNumber;
+    redo(frac);
+}
diff --git "a/ADAS/\303\201vila/ADA6-Sudoku.c" "b/ADAS/\303\201vila/ADA6-Sudoku.c"
new file mode 100644
index 0000000..a788535
--- /dev/null
+++ "b/ADAS/\303\201vila/ADA6-Sudoku.c"
@@ -0,0 +1,194 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+typedef struct tablePart
+{
+    int table[3][3];
+} tablePart;
+
+typedef struct table
+{
+    tablePart table[3][3];
+} table;
+
+void fillTable(table *sudo);
+void printTable(table *sudo);
+int checkLineH(table *sudo);
+int checkLineV(table *sudo);
+int checkSquare(table *sudo);
+void result(table *sudo);
+
+int main()
+{
+    srand(time(NULL));
+    table sudoku;
+    fillTable(&sudoku);
+    printTable(&sudoku);
+    result(&sudoku);
+    return 0;
+}
+
+void fillTable(table *sudo)
+{
+
+    for (int i = 0; i < 3; i++)
+    {
+        for (int j = 0; j < 3; j++)
+        {
+            for (int k = 0; k < 3; k++)
+            {
+                for (int l = 0; l < 3; l++)
+                {
+                    (*sudo).table[i][j].table[k][l] = rand() % 9 + 1;
+                }
+            }
+        }
+    }
+}
+
+// void printTable(table *sudo)
+// {
+//     for (int i = 0; i < 3; i++)
+//     {
+//         for (int j = 0; j < 3; j++)
+//         {
+//             for (int k = 0; k < 3; k++)
+//             {
+//                 for (int l = 0; l < 3; l++)
+//                 {
+//                     printf("%d ", (*sudo).table[i][k].table[j][l]);
+//                 }
+//                 printf("  ");
+//             }
+//             printf("\n");
+//         }
+//         printf("\n");
+//     }
+// }
+
+int checkLineH(table *sudo)
+{
+    int checked = 1;
+
+    for (int i = 0; i < 3; i++)
+    {
+        for (int j = 0; j < 3; j++)
+        {
+            int ite = 0;
+            int line[9];
+            for (int a = 0; a < 3; a++)
+            {
+                for (int b = 0; b < 3; b++)
+                {
+                    line[ite] = (*sudo).table[i][a].table[j][b];
+                    ite += 1;
+                }
+            }
+            for (int x = 0; x < 9; x++)
+            {
+                for (int z = 0; z < 9; z++)
+                {
+                    if (line[x] == line[z] && x != z)
+                    {
+                        checked = 0;
+                    }
+                }
+                ite = 0;
+            }
+        }
+    }
+    return checked;
+}
+
+int checkLineV(table *sudo)
+{
+    int checked = 1;
+
+    for (int i = 0; i < 3; i++)
+    {
+        for (int j = 0; j < 3; j++)
+        {
+            int ite = 0;
+            int line[9];
+            for (int a = 0; a < 3; a++)
+            {
+                for (int b = 0; b < 3; b++)
+                {
+                    line[ite] = (*sudo).table[j][i].table[b][a];
+                    ite += 1;
+                }
+            }
+            for (int x = 0; x < 9; x++)
+            {
+                for (int z = 0; z < 9; z++)
+                {
+                    if (line[x] == line[z] && z != x)
+                    {
+                        checked = 0;
+                    }
+                }
+                ite = 0;
+            }
+        }
+    }
+    return checked;
+}
+
+int checkSquare(table *sudo)
+{
+    int checked = 1;
+    int acum = 0;
+
+    for (int i = 0; i < 3; i++)
+    {
+        for (int j = 0; j < 3; j++)
+        {
+            int ite = 0;
+            int line[9];
+            for (int a = 0; a < 3; a++)
+            {
+                for (int b = 0; b < 3; b++)
+                {
+                    line[ite] = (*sudo).table[i][j].table[a][b];
+                    ite += 1;
+                }
+            }
+            for (int x = 0; x < 9; x++)
+            {
+                for (int z = 0; z < 9; z++)
+                {
+                    if (line[x] == line[z] && z != x)
+                    {
+                        checked = 0;
+                    }
+                }
+                ite = 0;
+            }
+        }
+
+        if (acum == 9)
+        {
+            checked = 1;
+        }
+    }
+    return checked;
+}
+
+void result(table *sudo)
+{
+    int a, b, c;
+    
+    a = checkLineV(sudo);
+    b = checkLineH(sudo);
+    c = checkSquare(sudo);
+
+    if (a == 1 && b == 1 && c == 1)
+    {
+        printf("Sudoku!");
+    }
+    else
+    {
+        printf("Ño");
+    }
+}
diff --git "a/ADAS/\303\201vila/Ada4_Visual.c" "b/ADAS/\303\201vila/Ada4_Visual.c"
new file mode 100644
index 0000000..336d0b0
--- /dev/null
+++ "b/ADAS/\303\201vila/Ada4_Visual.c"
@@ -0,0 +1,516 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <stdbool.h>
+#define N 3
+
+//Prototipado:
+void generarMatriz(int arr[][N]);
+void imprimirMatriz(int arr[][N]);
+void sleccionarOpcion(int arr[][N]);
+void nuevoCuadro(int arr[][N]);
+
+//Opciones del usuario:
+void recorrerMatriz1_2Ascendente(int arr[][N]);
+void recorrerMatriz1_2Descendente(int arr[][N]);
+void recorrerMatriz3_4Ascendente(int arr[][N]);
+void recorrerMatriz3_4Descendente(int arr[][N]);
+void recorrerMatriz1_4Ascendente(int arr[][N]);
+void recorrerMatriz1_4Descendente(int arr[][N]);
+void recorrerMatriz2_3Ascendente(int arr[][N]);
+void recorrerMatriz2_3Descendente(int arr[][N]);
+void recorrerMatriz1Ascendente(int arr[][N]);
+void recorrerMatriz1Descendente(int arr[][N]);
+void recorrerMatriz2Ascendente(int arr[][N]);
+void recorrerMatriz2Descendente(int arr[][N]);
+void recorrerMatriz3Ascendente(int arr[][N]);
+void recorrerMatriz3Descendente(int arr[][N]);
+void recorrerMatriz4Ascendente(int arr[][N]);
+void recorrerMatriz4Descendente(int arr[][N]);
+void recorrerDiagonalPrincipal(int arr[][N]);
+void recorrerDiagonalInvertida(int matriz[][N]);
+
+//Main
+int main()
+{
+    //Generar:
+    int matriz[N][N];
+    time_t t;
+    srand((unsigned)time(&t));
+
+    generarMatriz(matriz);
+    imprimirMatriz(matriz);
+    sleccionarOpcion(matriz);
+
+    return (0);
+}
+
+// FUNCIONES
+void generarMatriz(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            arr[i][j] = rand() % 51;
+        }
+    }
+}
+
+void imprimirMatriz(int arr[][N])
+{
+    printf("Matriz:\n");
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            printf("%d\t", arr[i][j]);
+        }
+        printf("\n");
+    }
+}
+
+void sleccionarOpcion(int arr[][N])
+{
+    bool check = true;
+    int opc;
+    while (check)
+    {
+        printf("\n Opciones: \n\t0. Terminar");
+        printf("\n\t1. Crear nuevo cuadro");
+        printf("\n\t2. Sección 1-2 Ascendiente");
+        printf("\n\t3. Sección 1-2 Descendente");
+        printf("\n\t4. Sección 3-4 Ascendente");
+        printf("\n\t5. Sección 3-4 Descendente");
+        printf("\n\t6. Sección 1-4 Ascendente");
+        printf("\n\t7. Sección 1-4 Descendente");
+        printf("\n\t8. Sección 2-3 Ascendente");
+        printf("\n\t9. Sección 2-3 Descendente");
+        printf("\n\t10. Sección 1 Ascendiente");
+        printf("\n\t11. Sección 1 Descendiente");
+        printf("\n\t12. Sección 2 Ascendiente");
+        printf("\n\t13. Sección 2 Descendiente");
+        printf("\n\t14. Sección 3 Ascendiente");
+        printf("\n\t15. Sección 3 Descendiente");
+        printf("\n\t16. Sección 4 Ascendiente");
+        printf("\n\t17. Sección 4 Descendiente");
+        printf("\n\t18. Diagonal principal");
+        printf("\n\t19. Diagonal principal invertida\n");
+
+        scanf("%d", &opc);
+        switch (opc)
+        {
+        case 0:
+            check = false;
+            break;
+        case 1:
+            nuevoCuadro(arr);
+            break;
+        case 2:
+            recorrerMatriz1_2Ascendente(arr);
+            break;
+        case 3:
+            recorrerMatriz1_2Descendente(arr);
+            break;
+        case 4:
+            recorrerMatriz3_4Ascendente(arr);
+            break;
+        case 5:
+            recorrerMatriz3_4Descendente(arr);
+            break;
+        case 6:
+            recorrerMatriz1_4Ascendente(arr);
+            break;
+        case 7:
+            recorrerMatriz1_4Descendente(arr);
+            break;
+        case 8:
+            recorrerMatriz2_3Ascendente(arr);
+            break;
+        case 9:
+            recorrerMatriz2_3Descendente(arr);
+            break;
+        case 10:
+            recorrerMatriz1Ascendente(arr);
+            break;
+        case 11:
+            recorrerMatriz1Descendente(arr);
+            break;
+        case 12:
+            recorrerMatriz2Ascendente(arr);
+            break;
+        case 13:
+            recorrerMatriz2Descendente(arr);
+            break;
+        case 14:
+            recorrerMatriz3Ascendente(arr);
+            break;
+        case 15:
+            recorrerMatriz3Descendente(arr);
+            break;
+        case 16:
+            recorrerMatriz4Ascendente(arr);
+            break;
+        case 17:
+            recorrerMatriz4Descendente(arr);
+            break;
+        case 18:
+            recorrerDiagonalPrincipal(arr);
+            break;
+        case 19:
+            recorrerDiagonalInvertida(arr);
+        default:
+            printf("Sigue participando <3");
+        }
+    }
+}
+
+void nuevoCuadro(int arr[][N])
+{
+    system("clear");
+    generarMatriz(arr);
+    imprimirMatriz(arr);
+    sleccionarOpcion(arr);
+}
+
+void recorrerMatriz1_2Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j < N - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz1_2Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j < N - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz3_4Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= N - i - 1)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz3_4Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= N - i - 1)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz1_4Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j <= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz1_4Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j <= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz2_3Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz2_3Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz1Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j <= ((N - 1) / 2) && j <= i && j <= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz1Descendente(int arr[][N])
+{
+    for (int i = N; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j <= ((N - 1) / 2) && j <= i && j <= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz2Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j < N - i && j >= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz2Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j < N - i && j >= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz3Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= ((N - 1) / 2) && j >= i && j >= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz3Descendente(int arr[][N])
+{
+    for (int i = N; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= ((N - 1) / 2) && j >= i && j >= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz4Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (i >= ((N - 1) / 2) && j <= i && j >= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerMatriz4Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (i >= ((N - 1) / 2) && j <= i && j >= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerDiagonalPrincipal(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (i == j)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void recorrerDiagonalInvertida(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j == N - i - 1)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
diff --git "a/ADAS/\303\201vila/Ada4_noVisual.c" "b/ADAS/\303\201vila/Ada4_noVisual.c"
new file mode 100644
index 0000000..2fcf030
--- /dev/null
+++ "b/ADAS/\303\201vila/Ada4_noVisual.c"
@@ -0,0 +1,517 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <stdbool.h>
+#define N 3
+
+//Prototipado:
+void generarMatriz(int arr[][N]);
+void imprimirMatriz(int arr[][N]);
+void sleccionarOpcion(int arr[][N]);
+void nuevoCuadro(int arr[][N]);
+
+//Opciones del usuario:
+void recorrerMatriz1_2Ascendente(int arr[][N]);
+void recorrerMatriz1_2Descendente(int arr[][N]);
+void recorrerMatriz3_4Ascendente(int arr[][N]);
+void recorrerMatriz3_4Descendente(int arr[][N]);
+void recorrerMatriz1_4Ascendente(int arr[][N]);
+void recorrerMatriz1_4Descendente(int arr[][N]);
+void recorrerMatriz2_3Ascendente(int arr[][N]);
+void recorrerMatriz2_3Descendente(int arr[][N]);
+void recorrerMatriz1Ascendente(int arr[][N]);
+void recorrerMatriz1Descendente(int arr[][N]);
+void recorrerMatriz2Ascendente(int arr[][N]);
+void recorrerMatriz2Descendente(int arr[][N]);
+void recorrerMatriz3Ascendente(int arr[][N]);
+void recorrerMatriz3Descendente(int arr[][N]);
+void recorrerMatriz4Ascendente(int arr[][N]);
+void recorrerMatriz4Descendente(int arr[][N]);
+void recorrerDiagonalPrincipal(int arr[][N]);
+void recorrerDiagonalInvertida(int matriz[][N]);
+
+//Main
+int main()
+{
+    //Generar:
+    int matriz[N][N];
+    time_t t;
+    srand((unsigned)time(&t));
+
+    generarMatriz(matriz);
+    imprimirMatriz(matriz);
+    sleccionarOpcion(matriz);
+
+    return (0);
+}
+
+// FUNCIONES
+void generarMatriz(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            arr[i][j] = rand() % 25;
+        }
+    }
+}
+
+void imprimirMatriz(int arr[][N])
+{
+    printf("Matriz:\n");
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            printf("%d\t", arr[i][j]);
+        }
+        printf("\n");
+    }
+}
+
+void sleccionarOpcion(int arr[][N])
+{
+    int opc;
+    bool check = true;
+    while (check)
+    {
+        printf("\n Opciones: \n\t0. Terminar");
+        
+        printf("\n\t1. Crear nuevo cuadro");
+        printf("\n\t2. Sección 1-2 Ascendiente");
+        printf("\n\t3. Sección 1-2 Descendente");
+        printf("\n\t4. Sección 3-4 Ascendente");
+        printf("\n\t5. Sección 3-4 Descendente");
+        printf("\n\t6. Sección 1-4 Ascendente");
+        printf("\n\t7. Sección 1-4 Descendente");
+        printf("\n\t8. Sección 2-3 Ascendente");
+        printf("\n\t9. Sección 2-3 Descendente");
+        printf("\n\t10. Sección 1 Ascendiente");
+        printf("\n\t11. Sección 1 Descendiente");
+        printf("\n\t12. Sección 2 Ascendiente");
+        printf("\n\t13. Sección 2 Descendiente");
+        printf("\n\t14. Sección 3 Ascendiente");
+        printf("\n\t15. Sección 3 Descendiente");
+        printf("\n\t16. Sección 4 Ascendiente");
+        printf("\n\t17. Sección 4 Descendiente");
+        printf("\n\t18. Diagonal principal");
+        printf("\n\t19. Diagonal principal invertida\n");
+
+        scanf("%d", &opc);
+        switch (opc)
+        {
+        case 0:
+            check = false;
+            break;
+        case 1:
+            nuevoCuadro(arr);
+            break;
+        case 2:
+            recorrerMatriz1_2Ascendente(arr);
+            break;
+        case 3:
+            recorrerMatriz1_2Descendente(arr);
+            break;
+        case 4:
+            recorrerMatriz3_4Ascendente(arr);
+            break;
+        case 5:
+            recorrerMatriz3_4Descendente(arr);
+            break;
+        case 6:
+            recorrerMatriz1_4Ascendente(arr);
+            break;
+        case 7:
+            recorrerMatriz1_4Descendente(arr);
+            break;
+        case 8:
+            recorrerMatriz2_3Ascendente(arr);
+            break;
+        case 9:
+            recorrerMatriz2_3Descendente(arr);
+            break;
+        case 10:
+            recorrerMatriz1Ascendente(arr);
+            break;
+        case 11:
+            recorrerMatriz1Descendente(arr);
+            break;
+        case 12:
+            recorrerMatriz2Ascendente(arr);
+            break;
+        case 13:
+            recorrerMatriz2Descendente(arr);
+            break;
+        case 14:
+            recorrerMatriz3Ascendente(arr);
+            break;
+        case 15:
+            recorrerMatriz3Descendente(arr);
+            break;
+        case 16:
+            recorrerMatriz4Ascendente(arr);
+            break;
+        case 17:
+            recorrerMatriz4Descendente(arr);
+            break;
+        case 18:
+            recorrerDiagonalPrincipal(arr);
+            break;
+        case 19:
+            recorrerDiagonalInvertida(arr);
+        default:
+            printf("Sigue participando <3");
+        }
+    }
+}
+
+void nuevoCuadro(int arr[][N])
+{
+    system("clear");
+    generarMatriz(arr);
+    imprimirMatriz(arr);
+    sleccionarOpcion(arr);
+}
+
+void recorrerMatriz1_2Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j < N - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz1_2Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j < N - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz3_4Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= N - i - 1)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz3_4Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= N - i - 1)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz1_4Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j <= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz1_4Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j <= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz2_3Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz2_3Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz1Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j <= ((N - 1) / 2) && j <= i && j <= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz1Descendente(int arr[][N])
+{
+    for (int i = N; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j <= ((N - 1) / 2) && j <= i && j <= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz2Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j < N - i && j >= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz2Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j < N - i && j >= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz3Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= ((N - 1) / 2) && j >= i && j >= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz3Descendente(int arr[][N])
+{
+    for (int i = N; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= ((N - 1) / 2) && j >= i && j >= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz4Ascendente(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (i >= ((N - 1) / 2) && j <= i && j >= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerMatriz4Descendente(int arr[][N])
+{
+    for (int i = N - 1; 0 <= i; i--)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (i >= ((N - 1) / 2) && j <= i && j >= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerDiagonalPrincipal(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (i == j)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        // printf("\n");
+    }
+}
+
+void recorrerDiagonalInvertida(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j == N - i - 1)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            // else
+            // {
+            //     printf("\t");
+            // }
+        }
+        printf("\n");
+    }
+}
diff --git "a/ADAS/\303\201vila/Ada6-Listas.c" "b/ADAS/\303\201vila/Ada6-Listas.c"
new file mode 100644
index 0000000..d3870f2
--- /dev/null
+++ "b/ADAS/\303\201vila/Ada6-Listas.c"
@@ -0,0 +1,147 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+typedef struct listNumbers
+{
+    int number;
+    struct listNumbers *nextNode;
+} listNumbers;
+
+typedef listNumbers *listP;
+
+// Prototype
+void insertList(listP *, int);
+listP ereaseNode(listP, int);
+void printList(listP);
+void menu();
+
+// Main
+int main()
+{
+    listP list = NULL;
+    int _num, select;
+    bool flag = false;
+
+    do
+    {
+        menu();
+        scanf("%d", &select);
+
+        switch (select)
+        {
+        case 1:
+            scanf("%d", &_num);
+            insertList(&list, _num);
+            break;
+
+        case 2:
+            scanf("%d", &_num);
+            list = ereaseNode(list, _num);
+            break;
+
+        case 3:
+            printList(list);
+            break;
+
+        case 4:
+            flag = true;
+            break;
+            printf("Adios 💜");
+
+        default:
+            flag = true;
+            break;
+        }
+
+    } while (flag == false);
+    return 0;
+}
+
+void menu()
+{
+    printf("----[Menu]----\n");
+    printf("Elige una opción\n");
+    printf("1. Insertar un número\n");
+    printf("2. Borrar un número\n");
+    printf("3. Imprimir Lista\n");
+    printf("4. Cerrar\n");
+    printf("\n");
+}
+
+void insertList(listP *elementP, int numberV)
+{
+    listP newElement;
+    listP lastNode;
+    listP actualNode;
+
+    newElement = (listNumbers *)malloc(sizeof(listNumbers));
+    if (newElement != NULL)
+    {
+        newElement->number = numberV;
+        newElement->nextNode = NULL;
+        lastNode = NULL;
+        actualNode = *elementP;
+
+        while (actualNode != NULL && numberV > actualNode->number)
+        {
+            lastNode = actualNode;
+            actualNode = actualNode->nextNode;
+        }
+
+        if (lastNode == NULL)
+        {
+            newElement->nextNode = *elementP;
+            *elementP = newElement;
+        }
+        else
+        {
+            lastNode->nextNode = newElement;
+            newElement->nextNode = actualNode;
+        }
+    }
+    else
+    {
+        printf("X");
+    }
+}
+
+listP ereaseNode(listP actualNode, int numberV)
+{
+    listP fereaseNode = NULL;
+    if (actualNode != NULL)
+    {
+        if (actualNode->number == numberV)
+        {
+            fereaseNode = actualNode;
+            actualNode = actualNode->nextNode;
+            free(fereaseNode);
+        }
+        else
+        {
+            actualNode->nextNode = ereaseNode(actualNode->nextNode, numberV);
+        }
+    }
+    return actualNode;
+}
+
+void printList(listP actualNode)
+{
+    printf("\n");
+    if (actualNode == NULL)
+    {
+        printf("Lista vacia\n");
+    }
+    else
+    {
+        printf("\n");
+        printf("----[Lista]----\n");
+        printf("\n");
+        while (actualNode != NULL)
+        {
+            printf("%d\n", actualNode->number);
+            printf("\n");
+            actualNode = actualNode->nextNode;
+        }
+    }
+}
diff --git "a/ADAS/\303\201vila/Ejercicio26Marzo.c" "b/ADAS/\303\201vila/Ejercicio26Marzo.c"
new file mode 100644
index 0000000..277cef1
--- /dev/null
+++ "b/ADAS/\303\201vila/Ejercicio26Marzo.c"
@@ -0,0 +1,148 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <stdbool.h>
+#define N 3
+
+//Prototipado:
+void generarMatriz(int arr[][N]);
+void imprimirMatriz(int arr[][N]);
+void sleccionarOpcion(int arr[][N]);
+void nuevoCuadro(int arr[][N]);
+
+//Opciones del usuario:
+void opcion1(int arr[][N]);
+void opcion2(int arr[][N]);
+
+//Main
+int main()
+{
+    //Generar:
+    int matriz[N][N];
+    time_t t;
+    srand((unsigned)time(&t));
+
+    generarMatriz(matriz);
+    imprimirMatriz(matriz);
+    sleccionarOpcion(matriz);
+
+    return (0);
+}
+
+// FUNCIONES
+void generarMatriz(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            arr[i][j] = rand() % 51;
+        }
+    }
+}
+
+void imprimirMatriz(int arr[][N])
+{
+    printf("Matriz:\n");
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            printf("%d\t", arr[i][j]);
+        }
+        printf("\n");
+    }
+}
+
+void sleccionarOpcion(int arr[][N])
+{
+    bool check = true;
+    int opc;
+    while (check)
+    {
+        printf("\n Opciones: \n\t0. Terminar");
+        printf("\n\t1. Crear nuevo cuadro");
+        printf("\n\t2. Opción 1");
+        printf("\n\t3. Opción 2\n");
+
+        scanf("%d", &opc);
+        switch (opc)
+        {
+        case 0:
+            check = false;
+            break;
+        case 1:
+            nuevoCuadro(arr);
+            break;
+        case 2:
+            opcion1(arr);
+            break;
+        case 3:
+            opcion2(arr);
+            break;
+        default:
+            printf("Sigue participando <3");
+        }
+    }
+}
+
+void nuevoCuadro(int arr[][N])
+{
+    system("clear");
+    generarMatriz(arr);
+    imprimirMatriz(arr);
+    sleccionarOpcion(arr);
+}
+
+void opcion1(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j < N - i && j >= i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else if (i >= ((N - 1) / 2) && j <= i && j >= N - 1 - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
+
+void opcion2(int arr[][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (j >= (N / 2))
+            {
+                if (j >= i && j >= (N - 1) - i)
+                {
+                    printf("%d \t", arr[i][j]);
+                }
+                else
+                {
+                    printf("\t");
+                }
+            }
+            else if (j <= i && j <= (N - 1) - i)
+            {
+                printf("%d \t", arr[i][j]);
+            }
+            else
+            {
+                printf("\t");
+            }
+        }
+        printf("\n");
+    }
+}
diff --git a/Unidad 2-Estructuras de Control/Ejercicio1.c b/Unidad 2-Estructuras de Control/Ejercicio1.c
new file mode 100644
index 0000000..9edcdc9
--- /dev/null
+++ b/Unidad 2-Estructuras de Control/Ejercicio1.c	
@@ -0,0 +1,28 @@
+/* Ejercicio #1
+Escribe un programa que reciba un n�mero y te diga si ese n�mero es par o
+impar.
+- Pamela C. Canul Chac�n (Equipo 'about:blank') */
+#include <stdio.h>
+int main()
+{
+	//Entradas 
+	int num;
+	int esPar;
+	
+	//Solicitud de ingresar datos
+	scanf("%d",&num);
+	
+	//procedimiento
+	if (num%2 == 0) //Se compara con el modulo del n�mero y 2 para saber si el n�mero es par
+	{
+		esPar = 1; //La variable esPar toma valor positivo si el resultado de la divisi�n es cero
+	}
+	else{
+		esPar = 0; //La variable esPar toma valor negativo si el resultado de la divisi�n no es cero
+	}
+	
+	//Resultados
+	printf("%d",esPar);
+	
+	return 0; 
+}
diff --git a/Unidad 2-Estructuras de Control/Ejercicio13.c b/Unidad 2-Estructuras de Control/Ejercicio13.c
new file mode 100644
index 0000000..e509bf9
--- /dev/null
+++ b/Unidad 2-Estructuras de Control/Ejercicio13.c	
@@ -0,0 +1,63 @@
+/* Escribir el programa para convertir una hora leída en horario militar (número de cuatro dígitos) y la imprima a una hora en formato estándar (hh:00 am/pm). */
+
+#include <stdio.h>
+
+/* GLOBAL VARIABLES */
+
+int time, arr[4], first, second, flag = 0;
+char am[] = "am", pm[] = "pm";
+
+/* Functions */
+
+void entrada() {
+  scanf("%d", &time);
+}
+
+void proceso() {
+  for(int i = 0; i < 4; i++) {
+    arr[3-i] = time%10;
+    time /= 10;
+  }
+  if( (arr[0] == 1 && arr[1] > 2) || (arr[0] > 1)) {
+    first = (arr[0]*10 + arr[1]) - 12;
+    flag = 1;
+  } else {
+    first = arr[0]*10 + arr[1];
+  }
+  second = arr[2]*10 + arr[3];
+}
+
+void salida() {
+  if (flag == 0) {
+    if(first < 10 && second < 10) {
+      printf("0%d:0%d %s", first, second, am);
+    } else if(first < 10 && second > 10) {
+      printf("0%d:%d %s", first, second, am);
+    } else if(first > 10 && second < 10) {
+      printf("%d:0%d %s", first, second, am);
+    } else {
+      printf("%d:%d %s", first, second, am);
+    }
+  } else {
+        if(first < 10 && second < 10) {
+      printf("0%d:0%d %s", first, second, pm);
+    } else if(first < 10 && second > 10) {
+      printf("0%d:%d %s", first, second, pm);
+    } else if(first > 10 && second < 10) {
+      printf("%d:0%d %s", first, second, pm);
+    } else {
+      printf("%d:%d %s", first, second, pm);
+    }
+  }
+}
+
+/* MAIN */
+
+int main() {
+
+  entrada();
+  proceso();
+  salida();
+
+  return 0;
+}
diff --git a/Unidad 2-Estructuras de Control/Ejercicio19.c b/Unidad 2-Estructuras de Control/Ejercicio19.c
new file mode 100644
index 0000000..c35a4fb
--- /dev/null
+++ b/Unidad 2-Estructuras de Control/Ejercicio19.c	
@@ -0,0 +1,34 @@
+/* Ejercicio #19
+Escribir un programa que lea tres n�meros y determine el mayor de los tres.
+- Pamela C. Canul Chac�n (Equipo 'about:blank') */
+#include <stdio.h>
+int main() 
+{
+	//Entradas
+	int num1; 
+	int num2;
+	int num3;
+	int numMayor; 
+	//Solicitud de entrada de datos
+	scanf("%d",&num1);
+	scanf("%d",&num2);
+	scanf("%d",&num3);
+	
+	//Proceso 
+	if(num1 > num2 && num1 > num3) //se compara el n�mero 1 con los otros dos n�meros
+	{
+		numMayor = num1; //Se asigna un valor a la variable del numero mayor
+	}
+	else if(num2 > num1 && num2 > num3) //se compara el n�mero 2 con los otros dos n�meros
+	{
+		numMayor = num2; //Se asigna un valor a la variable del numero mayor
+	}
+	else { //Si no se cumple ninguna de las condiciones se considera que el n�mero 3 es el mayor
+		numMayor = num3; //Se asigna un valor a la variable del numero mayor
+	}
+	
+	//Resultados
+	printf("%d",numMayor);
+	
+	return 0; 
+}
diff --git a/Unidad 2-Estructuras de Control/Ejercicio31.c b/Unidad 2-Estructuras de Control/Ejercicio31.c
new file mode 100644
index 0000000..27219c6
--- /dev/null
+++ b/Unidad 2-Estructuras de Control/Ejercicio31.c	
@@ -0,0 +1,50 @@
+// # Ejercicio #31
+// # Dado un número determinar si es primo
+// # Autor: Miguel R. Ávila (Equipo 'about:blank')
+
+// # Dato de entrada: un número 
+// # Dato de salida: un valor booleano que represente si el número es primo
+
+#include<stdio.h>
+
+// Global Var
+int number;
+// Functions 
+
+void entrada() {
+    scanf("%d", &number);
+}
+
+void proceso(int num) {
+    int result = 0;
+    
+    if (num < 1) {
+        result = 0;
+    } else if (num == 2)
+    {
+        result = 1;
+    } else {
+        for (int  i = 2; i < num; i++)
+        {
+            if (num%i == 0)
+            {
+                result = 0;
+                break;
+            }
+            result = 1;
+            
+        }
+        
+    }
+    number = result;
+    
+}
+void salida() {
+      printf("%d", number);
+}
+// main
+int main() {
+    entrada();
+    proceso(number);
+    salida();
+}
\ No newline at end of file
diff --git a/Unidad 2-Estructuras de Control/Ejercicio37.c b/Unidad 2-Estructuras de Control/Ejercicio37.c
new file mode 100644
index 0000000..7b3ff88
--- /dev/null
+++ b/Unidad 2-Estructuras de Control/Ejercicio37.c	
@@ -0,0 +1,72 @@
+// # Ejercicio #31
+// # Dado un número determinar si es primo
+// # Autor: Miguel R. Ávila (Equipo 'about:blank')
+
+// # Dato de entrada: un número 
+// # Dato de salida: un valor booleano que represente si el número es primo
+
+#include<stdio.h>
+
+// Global Var
+int number;
+// Functions 
+
+void entrada() {
+    scanf("%d", &number);
+}
+
+void proceso(int num) {
+
+    int count = 0;
+    int result = 0;
+    int j = 0;
+    int acum = 0;
+    
+
+    while (count < num)
+    {
+        // Is Prime? 
+        if (j < 1) {
+                result = 0;
+            } else if (j == 2)
+            {
+                result = 1;
+            } else {
+                for (int  i = 2; i < j; i++)
+                {
+                    if (j%i == 0)
+                    {
+                        result = 0;
+                        break;
+                    }
+                    result = 1;
+                    
+                }
+                
+            }
+        // Adder
+        if (result == 1)
+        {
+            count = count + 1;
+            acum = acum + j;
+        }
+
+        j++;
+        result=0;
+        
+    }
+    number = acum;
+    
+    
+}
+void salida() {
+      printf("%d", number);
+}
+
+
+// main
+int main() {
+    entrada();
+    proceso(number);
+    salida();
+}
\ No newline at end of file
diff --git a/Unidad 2-Estructuras de Control/Ejercicio43.c b/Unidad 2-Estructuras de Control/Ejercicio43.c
new file mode 100644
index 0000000..eea922d
--- /dev/null
+++ b/Unidad 2-Estructuras de Control/Ejercicio43.c	
@@ -0,0 +1,74 @@
+#include <stdio.h>
+
+/* Ejercicio #43 MODULARIZADO
+# Programa que lea N valores y que cuente cuantos de ellos son positivos y cuantos
+# son negativos (0 es condici'on de fin de lectura)
+# Audny D. Correa Ceballos (Equipo 'about:blank') */
+
+//PROTOTIPOS DE LAS FUNCIONES
+void leerRangoDeDatos(int *);
+int leerValores (int);
+int compararValoresPositivos(int);
+int compararValoresNegativos(int);
+void imprimirSalidas(int, int);
+int main(){
+	//Declarar las Variables
+	int rangoDeValores, lista, positivos, negativos;
+	
+	//Funciones para leer las entradas
+	leerRangoDeValores(&rangoDeValores);
+	leerValores;
+	//Funciones del proceso 
+	positivos=compararValoresPositivos(lista);
+	negativos =compararValoresNegativos(lista);
+	//Funciones para imprimir las salidas
+	imprimirSalidas(positivos, negativos);
+	
+	return 0;
+}
+
+//Asignar un rando de cuantos valores  habran
+void leerRangoDeValores(int *_rangoDeValores){
+	scanf("%d", _rangoDeValores);
+}
+
+//Asignar los numeros que se compaararan
+int leerValores(int _rangoDeValores){
+	int i;
+	int lista[100];
+	for (i= 0; i<=_rangoDeValores; i++){
+		scanf("%d", &lista[i]);	
+	}
+	return *lista;
+}
+//Encontrar cuantos valores positivos hay
+int compararValoresPositivos(int _lista){
+	int i, contadorPositivo=0;
+	for (i= 0; i<=_lista; i++){
+		if (_lista >0){
+			contadorPositivo += 1;
+		}if (_lista == 0){
+			break;
+		}
+	} 
+	return contadorPositivo;
+}
+
+//Encontrar cuantos valores negativos hay
+int compararValoresNegativos(int _lista){
+	int i, contadorNegativo=0;
+	for (i= 0; i<=_lista; i++){
+		if (_lista < 0){
+			contadorNegativo += 1;
+		}if (_lista == 0){
+			break;
+		}
+	} 
+	return contadorNegativo;
+}
+//Imprimir las salidas
+void imprimirSalidas(int _positivos, int _negativos){
+	printf("%d", _positivos);
+	printf("%d", _negativos);
+}
+
diff --git a/Unidad 2-Estructuras de Control/Ejercicio48.c b/Unidad 2-Estructuras de Control/Ejercicio48.c
new file mode 100644
index 0000000..c73515f
--- /dev/null
+++ b/Unidad 2-Estructuras de Control/Ejercicio48.c	
@@ -0,0 +1,53 @@
+#include <stdio.h>
+/* Programa que lee el suldo base y antiguedad del empleado
+# Calcula el incentivo con base a ello
+# e imprime el sueldo base, incentivo y sueldo a pagar
+#  Audny D. Correa Ceballos (Equipo: 'about:blank') */
+
+//PROTOTIPOS DE LAS FUNCIONES
+void leerEntradas(int* , int*);
+int calcularIncentivo(int, int );
+int calcularSueldoAPagar (int , int );
+void imprimirSalidas(int, int, int);
+
+int main(){
+	//Definir las varianles
+	int sueldoBase, antiguedad, incentivoGenerado, sueldoAPagar;
+	//Leer entradas
+	leerEntradas(&sueldoBase, &antiguedad);
+	//Proceso
+	incentivoGenerado= calcularIncentivo(sueldoBase, antiguedad);
+	sueldoAPagar = calcularSueldoAPagar (sueldoBase, incentivoGenerado);
+	//Salidas
+	imprimirSalidas(sueldoBase, incentivoGenerado, sueldoAPagar);
+	
+	return 0;
+}
+
+void leerEntradas(int*_sueldoBase, int*_antiguedad){
+	scanf("%d", "%d", _sueldoBase, _antiguedad);
+}
+
+int calcularIncentivo(int _sueldoBase, int _antiguedad){
+	int incentivo=0;
+	if (_antiguedad >= 1 && _antiguedad <= 3);{
+		incentivo = _sueldoBase * 0.01;
+	}if (_antiguedad >= 4 && _antiguedad <= 6);{
+		incentivo = _sueldoBase * 0.03;
+	}if (_antiguedad >= 7 && _antiguedad <= 9);{
+		incentivo = _sueldoBase * 0.05;
+	}if (_antiguedad >= 10);{
+		incentivo = _sueldoBase * 0.07;
+	}
+	return incentivo;
+}
+
+int calcularSueldoAPagar (int _sueldoBase, int _incentivoGenerado){
+	int sueldoAFuturo;
+	sueldoAFuturo = _sueldoBase + _incentivoGenerado;
+	return sueldoAFuturo;
+}
+
+void imprimirSalidas(int _sueldoBase, int _incentivoGenerado, int _sueldoAPagar){
+	printf("%d", "%d", "%d", _sueldoBase, _incentivoGenerado, _sueldoAPagar);
+}
diff --git a/Unidad 2-Estructuras de Control/Ejercicio7.c b/Unidad 2-Estructuras de Control/Ejercicio7.c
new file mode 100644
index 0000000..48f2afd
--- /dev/null
+++ b/Unidad 2-Estructuras de Control/Ejercicio7.c	
@@ -0,0 +1,42 @@
+/* Escribir el programa para un programa que reciba un numero positivo, si este numero es mayor a 1000 se le sumara un 5%, si el numero es mayor a 3000 se le sumara otro 10% adicional y si el numero es mayor a 5000 se le sumara otro 5% adicional. */
+
+#include <stdio.h>
+
+/* GLOBAL VARIABLES */
+
+int number;
+
+/* Functions */
+
+void entrada() {
+  scanf("%d", &number);
+}
+
+void proceso(int num) {
+  int result = num;
+  if(num > 1000) {
+    result += result * .05;
+  }
+  if(num > 3000) {
+    result += result * .1;
+  }
+  if(num >5000) {
+    result += result *.05;
+  }
+  number = result;
+}
+
+void salida() {
+  printf("%d", number);
+}
+
+/* MAIN */
+
+int main() {
+
+  entrada();
+  proceso(number);
+  salida();
+
+  return 0;
+}
diff --git a/Unidad 2-Estructuras de Control/ejercicio25.c b/Unidad 2-Estructuras de Control/ejercicio25.c
new file mode 100644
index 0000000..38db549
--- /dev/null
+++ b/Unidad 2-Estructuras de Control/ejercicio25.c	
@@ -0,0 +1,19 @@
+/*# Ejercicio #25
+Escribir un programa para mostrar los códigos ASCII de las letras mayúsculas y minúsculas. 
+Autor: Roberto Llanes Montero (Equipo 'about:blank')
+
+Dato de entrada: un caracter
+Dato de salida: un entero que representa su valor ascii
+ */ 
+
+#include <stdio.h>
+//Declaración de variables
+char caracter;
+int main(){
+	//Leer el caracter
+	scanf("%c", &caracter);        
+	//Imprimir su valor decimal (código Ascii)
+	printf("%d\n", caracter);
+               
+return 0;
+}
diff --git a/Unidad 3-Funciones/Ejercicio 47.lua b/Unidad 3-Funciones/Ejercicio 47.lua
deleted file mode 100644
index 3f52cff..0000000
--- a/Unidad 3-Funciones/Ejercicio 47.lua	
+++ /dev/null
@@ -1,69 +0,0 @@
---[[Autor: Guillermo Canto Dzul
-Entradas: Nombre, Edad, Salario por hora, Horas trabajadas a la semana, Porcentaje de impuestos.
-Salidas: Sueldo Neto
-]]--
---Funciones
-function getName()
-  --io.write("Ingrese su nombre:")
-  name= io.read()
-end 
-
-function getAge()
-  --io.write("Ingrese su edad:")
-  age = io.read("*n")
-end
-
-function getSalary()
-  --io.write("Ingrese su salario por hora:")
-  salary = io.read("*n")
-end
-
-function getHours()
-  --io.write("Ingrese horas trabajadas:")
-  hours = io.read("*n")
-end
-
-function getTax()
-  --io.write("Porcentaje de impuestos:")
-  tax = io.read("*n")
-end
-
-function proceso()
-  if hours > 40 then
-    horas_extra = hours - 40
-    horas_tot = ((salary)*(hours))+((salary)*(horas_extra))
-  else
-    horas_tot = ((salary)*(hours))
-  end
-  impuestos_tot = ((tax)*(horas_tot)/(100))
-  resultado = ((horas_tot) - (impuestos_tot))
-  return resultado
-end
-
-function salida()
-  io.write("SUELDO NETO: " .. sueldoNeto )
-end
-
---Entradas
-
-getName()
-getAge()
-getSalary()
-getHours()
-getTax()
-
--- Proceso
-
-sueldoNeto = proceso()
-
--- Salida
-
-salida()
-
---[[
-QA: Realizó: Jose Mendez
-Entradas: jose, 26, 100 , 45 , 10
-Salidas: None
-Tiene problemas al momento de pedir el nombre, ya que solo acepta numeros.
-ademas al momento de imprimir variables, no funciona io.write
-]]
diff --git a/Unidad 3-Funciones/Ejercicio11.c b/Unidad 3-Funciones/Ejercicio11.c
deleted file mode 100644
index 89ffe28..0000000
--- a/Unidad 3-Funciones/Ejercicio11.c	
+++ /dev/null
@@ -1,44 +0,0 @@
-#include <stdio.h>
-/*Autor: Guillermo Canto Dzul
-Entradas: Monto a retirar del cajero
-Salidas: Saldo luego del retiro
-*/
-float entrada();
-float proceso(float montoARetirar);
-void salida(float saldo);
-int main(int argc, char *argv[]){
-	float montoARetirar, saldo;
-	montoARetirar = entrada();
-	saldo = proceso(montoARetirar);
-	salida(saldo);
-	return 0;
-}
-//Lee el monto a retirar
-float entrada(){
-	float montoARetirar;
-	printf("Ingrese el monto a retirar:\n");
-	scanf("%f", &montoARetirar);
-	return montoARetirar;
-}
-//Calcula el saldo restante
-float proceso(float montoARetirar){
-	float saldo = 3000;
-	if (montoARetirar > 3000 || montoARetirar <=0){
-		printf("La operacion no pudo realizarse\n");
-	}
-	else{
-		saldo = saldo - montoARetirar;
-	}
-	return saldo;
-}
-//imprime el saldo restante
-void salida(float saldo){
-	printf("Tu saldo es de %f\n", saldo);
-}
-
-/*
-QA: Hector Abraham V. Cosgalla
-Entradas:3000, 500, 4000
-Salidas: Tu saldo es de 0 , Tu saldo es de 2500 , La operacion no puede realizarse Tu saldo es de 3000
-Comentarios: Todo bien!
-*/
diff --git a/Unidad 3-Funciones/Ejercicio11.lua b/Unidad 3-Funciones/Ejercicio11.lua
deleted file mode 100644
index 1b05d65..0000000
--- a/Unidad 3-Funciones/Ejercicio11.lua	
+++ /dev/null
@@ -1,37 +0,0 @@
---[[
-Autor: Guillermo Canto Dzul
-Entradas: Monto a retirar del cajero
-Salidas: Saldo luego del retiro
-]]
---Funciones
-function entrada()
-    montoARetirar = io.read("*n")
-end
-
-function proceso()
-  saldo = 3000
-    if montoARetirar > 3000 or montoARetirar <= 0 then
-        flag = 0
-    else
-        saldo = saldo - montoARetirar
-        flag = 1
-    end
-end
-
-function salida()
-    if flag == 0 then
-        io.write("La operacion no pudo realizarse")
-    else
-        io.write("Tu saldo es de " .. saldo )
-    end
-end
---Main
-entrada()
-proceso()
-salida()
---[[
-QA: Hector Abraham V. Cosgalla
-Entradas:3000, 500, 4000
-Salidas: Tu saldo es de .. saldo .. , Tu saldo es de .. saldo .. , La operacion no puede realizarse
-Comentarios: Falta documentacion (corregido)
-]]
diff --git a/Unidad 3-Funciones/Ejercicio12.c b/Unidad 3-Funciones/Ejercicio12.c
index c2e31d6..759965d 100644
--- a/Unidad 3-Funciones/Ejercicio12.c	
+++ b/Unidad 3-Funciones/Ejercicio12.c	
@@ -1,81 +1,39 @@
-/*
-Autor:Jorge Chí 16/Febrero/19
-Entradas: dos numeros enteros (A y B)
-Salida: los números ordenados de mayor a menor
-Procedimiento general: Se pregunta cual es mayor y luego se ordenan
-*/
-
-#include<stdio.h>
-
-int lectura();
-void ascendente(int* numeroA1, int* numeroB1);
-void impresion(int numeroA2, int numeroB2);
-
-int main(){
-
-//se declaran los 2 valores
-
-int numeroA = 0, numeroB = 0;
-
-//entradas: se solicitan 2 valores al usuario
-
-numeroA = lectura();
-numeroB = lectura();
-
-//procedimiento: se comparan para saber cual es el mayor
-
-ascendente(&numeroA,&numeroB);
-
-//salidas: se imprimen en orden
-
-impresion(numeroA,numeroB);
-
-return 0;
-}
-
-int lectura(){
-//entradas:ninguna
- int numero = 0;
-//procedimiento: se pide el numero
- printf("Digite uno de los numeros a ordenar: \n");
- scanf("%i",&numero);
-//salidas: el numero leido
- return numero;
-
-}
-
-void ascendente(int* numeroA1, int* numeroB1){
-//entradas: los dos numeros
-int temporal = 0;
-//procedimiento: se ordenan si el segundo el mayor al primero
-if (*numeroB1 >= *numeroA1){
-
-    temporal = *numeroB1;
-    *numeroB1 = *numeroA1;
-    *numeroA1 = temporal;
-
-}
-//salidas: ninguna
-
-}
-
-void impresion(int numeroA2, int numeroB2){
-//entradas: los dos numeros
-
-//procedimiento: se imprimen en orden
-    printf("%i, %i", numeroA2, numeroB2);
-//salidas: ninguna
-
-
-}
-
-/*
-Autor QA: Alejandro Torre Reyes
-Entradas: 5,8
-Salidas: 8,5
-Proceso: OK
-Modularización: OK. El main no puede estar más simple.
- Función lectura: OK
- Función ascendente: OK
- Función impresion: OK
-*/
+/* Escribir un programa que lea 2 números y los imprima de mayor a menor. */
+
+#include <stdio.h>
+
+// Entrada
+int getNumber(){
+  int num;
+  scanf("%d", &num);
+  return num;
+}
+
+// Proceso
+int getResult(num1, num2){
+  if(num1 > num2){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+// Salida
+void getOutput(flag, num1, num2){
+  if (flag == 1){
+    printf("%d %d\n", num1, num2);
+  } else {
+    printf("%d %d\n", num2, num1);
+  }
+}
+
+/* MAIN */
+int main() {
+  int num1, num2, flag;
+  num1 = getNumber();
+  num2 = getNumber();
+  flag = getResult(num1, num2);
+  getOutput(flag, num1, num2);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/Unidad 3-Funciones/Ejercicio12.js b/Unidad 3-Funciones/Ejercicio12.js
deleted file mode 100644
index 42addfa..0000000
--- a/Unidad 3-Funciones/Ejercicio12.js	
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
-Autor:Jorge Chí 16/Febrero/19
-Entradas: dos numeros enteros (A y B)
-Salida: los números ordenados de mayor a menor
-Procedimiento general: Se pregunta cual es mayor y luego se ordenan
-*/
-
-var numeroA = 0;
-var numeroB = 0;
-
-//entradas: se solicitan 2 valores al usuario
-
-numeroA = lectura();
-numeroB = lectura();
-
-//procedimiento: se comparan para saber cual es el mayor
-
-ascendente();
-
-//salidas: se imprimen en orden
-
-impresion();
-
-function lectura(){
-//se lee el numero
-    var numero = 0;
-    alert("Ingresa un numero:");
-    numero = prompt();
-
-    return numero;
- }
-
-function ascendente(){
-
-	var temporal = 0;
-	//entradas: los dos numeros
-	//procedimiento: se ordenan si el segundo el mayor al primero
-	if (numeroB >= numeroA){
-
-   		temporal = numeroB;
-    	numeroB = numeroA;
-   		numeroA = temporal;
-
-}
-//salidas: ninguna
-
-}
-
-function impresion(){
-
-//entradas: los dos numeros
-
-//procedimiento: se imprimen en orden
-    alert(`${numeroA} , ${numeroB}` ); 
-//salidas: ninguna
-
-
-
-}
-/*
-Autor QA: Alejandro Torre Reyes
-Entradas: 19,45
-Salidas: 45,19
-Proceso: OK
-Modularidad: OK. Se realiza funciones para entradas, procedimientos e impresión de salidas.
-	Funcion lectura: Ok
-	Funcion ascendente: OK
-	Funcion impresion: OK
-*/
diff --git a/Unidad 3-Funciones/Ejercicio12.py b/Unidad 3-Funciones/Ejercicio12.py
new file mode 100644
index 0000000..7a9354e
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio12.py	
@@ -0,0 +1,25 @@
+# Escribir un programa que lea 2 números y los imprima de mayor a menor.
+
+# Entrada
+def getNumber():
+  num = int(input());
+  return num;
+
+# Proceso
+def getResult(num1, num2):
+  if (num1 > num2):
+    return 1;
+  else:
+    return 0;
+
+# Salida
+def getOutput(flag):
+  if(flag == 1):
+    print(str(num1) + ' ' + str(num2));
+  else:
+    print(str(num2) + ' ' + str(num1));
+
+num1 = getNumber();
+num2 = getNumber();
+flag = getResult(num1, num2);
+getOutput(flag);
\ No newline at end of file
diff --git a/Unidad 3-Funciones/Ejercicio15.c b/Unidad 3-Funciones/Ejercicio15.c
deleted file mode 100644
index 0e0f340..0000000
--- a/Unidad 3-Funciones/Ejercicio15.c	
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-Autor: Amílcar A. Ramírez Patrón
-Entradas: El dia, mes y año de dos fechas distintas
-Proceso: Verificar, en orden año, mes, día, qué numero de ambas fechas es mayor y escribir la fecha que es, a la vez
-que procurar continuar en orden en caso de empate, hasta que se concluya que ambas fechas son iguales
-Salidas: La fecha mayor
-*/
-#include <stdio.h>
-
-void leerAmbasFechas(int*, int*, int*, int*, int*, int*);
-void compararAmbasFechas(int*, int*, int*, int*, int*, int*);
-
-/*15.Escribir el programa que lea dos fechas (día-mes-año) con tres cantidades
-enteras e imprima la mayor, si son la misma imprima son iguales.
-*/
-int main(int argc, char *argv[]) {
-	//entrada
-	int diauno, mesuno, anouno, diados, mesdos, anodos;
-	leerAmbasFechas(&diauno, &mesuno, &anouno, &diados, &mesdos, &anodos);
-	//proceso
-	compararAmbasFechas(&diauno, &mesuno, &anouno, &diados, &mesdos, &anodos);
-	return 0;
-}
-
-void leerAmbasFechas(int *diauno, int *mesuno, int* anouno, int *diados, int *mesdos, int *anodos){
-	printf("Escriba el dia uno:");
-	scanf("%d", diauno);
-	printf("Escriba el mes uno:");
-	scanf("%d", mesuno);
-	printf("Escriba el ano uno:");
-	scanf("%d", anouno);
-	printf("Escriba el dia dos:");
-	scanf("%d", diados);
-	printf("Escriba el mes dos:");
-	scanf("%d", mesdos);
-	printf("Escriba el ano dos:");
-	scanf("%d", anodos);
-}
-
-
-void compararAmbasFechas(int *diauno, int *mesuno, int* anouno, int *diados, int *mesdos, int *anodos){
-	if(*anouno < *anodos){
-		printf("La segunda fecha ingresada es mayor: dia %d mes %d año %d\n", *diados, *mesdos, *anodos);
-	}
-	if(*anouno > *anodos){
-		printf("La primera fecha ingresada es mayor: dia %d mes %d año %d\n", *diauno, *mesuno, *anouno);
-	}
-	else if (*anouno = *anodos){
-		if(*mesuno < *mesdos){
-			printf("La segunda fecha ingresada es mayor: dia %d mes %d año %d\n", *diados, *mesdos, *anodos);
-		}
-		if(*mesuno > *mesdos){
-			printf("La primera fecha ingresada es mayor: dia %d mes %d año %d\n", *diauno, *mesuno, *anouno);
-		}
-		else if(*mesuno = *mesdos){
-			if(*diauno < *diados){
-				printf("La segunda fecha ingresada es mayor: dia %d mes %d año %d\n", *diados, *mesdos, *anodos);
-			}
-			if(*diauno > *diados){
-				printf("La primera fecha ingresada es mayor: dia %d mes %d año %d\n", *diauno, *mesuno, *anouno);
-			}
-			else if(*diauno = *diados){
-				printf("Las fechas son las mismas\n");
-			}
-		}
-	}
-}
-
-/*
-QA: Hector Abraham V. Cosgalla
-Entradas:
-Entradas:
-10--|24--|10--|
-2---|3---|2---|
-1998|1995|1995|
-24--|10--|10--|
-3---|2---|2---|
-1995|1998|1995|
-Salidas:
-La primera fecha ingresada es mayor | la segunda fecha ingresada es mayor | las fechas son las mismas
-																		| La primera fecha ingresada es mayor |
-Comentarios: Hay una pequeña falla en el segundo caso, hay que revisarlo, y se necesita un poco mas
-de informacion al momento de solicitar los valores.
-*/
diff --git a/Unidad 3-Funciones/Ejercicio15.lua b/Unidad 3-Funciones/Ejercicio15.lua
deleted file mode 100644
index 8644b2b..0000000
--- a/Unidad 3-Funciones/Ejercicio15.lua	
+++ /dev/null
@@ -1,72 +0,0 @@
---[[Autor: Amílcar A. Ramírez Patrón
-Entradas: El dia, mes y año de dos fechas distintas
-Proceso: Verificar, en orden año, mes, día, qué numero de ambas fechas es mayor y escribir la fecha que es, a la vez
-que procurar continuar en orden en caso de empate, hasta que se concluya que ambas fechas son iguales
-Salidas: La fecha mayor]]
-
---[[ Funciones ]]--
-   diauno = 0
-   mesuno = 0
-   anouno = 0
-   diados = 0
-   mesdos = 0
-   anodos = 0
-function leerAmbasFechas()
-   io.write("Escriba el dia uno:")
-   diauno = io.read("*n")
-   io.write("Escriba el mes uno:")
-   mesuno = io.read("*n")
-   io.write("Escriba el ano uno:")
-   anouno = io.read("*n")
-   io.write("Escriba el dia dos:")
-   diados = io.read("*n")
-   io.write("Escriba el mes dos:")
-   mesdos = io.read("*n")
-   io.write("Escriba el ano dos:")
-   anodos = io.read("*n")
-end
-
-function compararAmbasFechas()
-    if anouno < anodos then
-        print("La segunda fecha ingresada es mayor: dia", diados, "mes" , mesdos, "ano", anodos)
-    end
-    if anouno > anodos then
-        print("La primera fecha ingresada es mayor: dia", diauno,"mes", mesuno,"ano" anouno)
-    end
-    if anouno == anodos then
-        if mesuno < mesdos then
-            print("La segunda fecha ingresada es mayor: dia", diados, "mes" , mesdos, "ano", anodos)
-        end
-        if mesuno > mesdos then
-            print("La primera fecha ingresada es mayor: dia", diauno,"mes", mesuno,"ano" anouno)
-        end
-        if mesuno == mesdos then
-            if diauno < diados then
-               print("La segunda fecha ingresada es mayor: dia", diados, "mes" , mesdos, "ano", anodos)
-            end
-            if diauno > diados then
-                print("La primera fecha ingresada es mayor: dia", diauno,"mes", mesuno,"ano" anouno)
-            end
-            if diauno == diados then
-                print("las fechas son las mismas")
-            end
-        end
-    end
-end
-
---[[ Main ]]--
-leerAmbasFechas()
-compararAmbasFechas()
---[[
-QA: Hector Abraham V. Cosgalla
-Entradas:
-10--|24--|10--|
-2---|3---|2---|
-1998|1995|1995|
-24--|10--|10--|
-3---|2---|2---|
-1995|1998|1995|
-Salidas:
-La primera fecha ingresada es mayor | la segunda fecha ingresada es mayor | las fechas son las mismas
-Comentarios: Esta bien solo que falta un poco de informacion al momento de pedir las fechas
-]]
diff --git a/Unidad 3-Funciones/Ejercicio16.c b/Unidad 3-Funciones/Ejercicio16.c
deleted file mode 100644
index 9e13b4a..0000000
--- a/Unidad 3-Funciones/Ejercicio16.c	
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-Autor:Jorge Chí 16/Febrero/19
-Entradas: numero (colección de números).
-Salidas: media (de la suma de numero)
-Procedimiento general: Se ingresan numeros que se suman en la variable numero y luego se
-calcula la media de estos. Si se teclea un 0 se deja de tomar entradas. si se teclea un negativo se informa de esto.
-*/
-
-
-#include <stdio.h>
-
-int lecturaValores(float* sumaValores, int contadorSuma);
-float media(float sumaValores, int contadorSuma);
-void impresion(float mediaAImprimir);
-
-int main(void){
-
-//se inicia la variable que lee los numeros, la suma de estos y un contador
-
-float mediaFinal = 0;
-float suma = 0;
-int contador = 0;
-
-//Entradas: se solicitan los numeros del conjunto, se cuentan los numeros en total y se suman
-
-contador = lecturaValores(&suma, contador);
-
-/*Proceso : si ningun dato fue ingresado se infor de ello, en otro caso
-se calcula la media y se imprime */
-
-mediaFinal = media(suma, contador);
-
-//salida: la media impresa
-
-impresion(mediaFinal);
-
-return 0;
-
-}
-
-int lecturaValores(float* sumaValores, int contadorSuma){
-
-//entradas: la suma de valores y el contador
-
-  float numero = 0;
-
-  //proceso: se leen los números y despues se pasa por referencia la suma y el contador aumenta
-
-  while (1){
-
-    printf("Ingresa un numero del conjunto al cual quieres sacar media(teclea 0 para terminar):\n");
-    scanf("%f", &numero);
-
-    if (numero == 0){
-
-        break;
-
-    } else if (numero < 0){
-
-        printf("ERROR, numero menor que 0\n");
-
-    } else {
-        *sumaValores = *sumaValores + numero;
-        contadorSuma++;
-
-    }
-
-}
-//salidas: el contador
- return contadorSuma;
-
-}
-
-float media(float sumaValores, int contadorSuma){
-
-   //entradas: la suma del conjunto y el contador
-
-    float media = 0;
-
-    //proceso: si la suma no es 0 se saca la media
-
-    if (sumaValores != 0){
-
-    media = sumaValores / contadorSuma;
-
-    }
-
-    return media;
-}
-
-void impresion(float mediaAImprimir){
-
-    //entradas: la media a imprimir
-
-    //proceso: se imprime la media si no es cero, y si lo es se informa de ello
-
-    if (mediaAImprimir == 0)
-    {
-        printf("Ningun dato fue ingresado");
-
-    } else {
-
-        printf("La media es %f", mediaAImprimir);
-
-    }
-
-
-}
-/*
-Autor QA: Alejandro Torre Reyes
-Entradas: [10,9,0]
-Salidas: 9.5000
-Proceso: OK
-Modularidad: OK. el main no puede estar más simple.
-  Función LecturaDeValores: Ok.
-  Función media: OK.
-  Función impresion: OK.
-*/
diff --git a/Unidad 3-Funciones/Ejercicio16.js b/Unidad 3-Funciones/Ejercicio16.js
deleted file mode 100644
index 89b84ff..0000000
--- a/Unidad 3-Funciones/Ejercicio16.js	
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-Autor:Jorge Chí 16/Febrero/19
-Entradas: numero (colección de números).
-Salidas: media (de la suma de numero)
-Procedimiento general: Se ingresan numeros que se suman en la variable numero y luego se
-calcula la media de estos. Si se teclea un 0 se deja de tomar entradas. si se teclea un negativo se informa de esto.
-*/
-
-//se inicia la variable que lee los numeros, la suma de estos y un contador
-var mediaFinal = 0;
-var suma = 0;
-var contador = 0;
-
-//Entradas: se solicitan los numeros del conjunto, se cuentan los numeros en total y se suman
-lecturaValores();
-/*Proceso : si ningun dato fue ingresado se infor de ello, en otro caso
-se calcula la media y se imprime */
-media();
-//salida: la media impresa
-impresion();
-
-function lecturaValores(){
-  //entradas: la suma de valores y el contador
-  //proceso: se leen los números y despues se pasa por referencia la suma y el contador aumenta
-  while(true){
-  	var numero = 0;
-    alert("Ingresa un numero que pertenesca a la coleccion:");
-    numero = parseFloat(prompt());
-    if (numero == 0){
-        break;
-    } else if (numero < 0){
-        alert("Error numero menor que 0:");
-    } else {
-        suma = suma + numero;
-        alert(`La suma es ${suma}`);
-        contador = contador + 1;
-        alert(`Hay tanto numeros: ${contador}`);
-    }
-}
-}
-
-function media(){
-	//proceso: si la suma no es 0 se saca la media
-	if (suma != 0){
-    mediaFinal = suma / contador;
-    }
-}
-
-function impresion(){
-	//entradas: la media a imprimir
-    //proceso: se imprime la media si no es cero, y si lo es se informa de ello
-    if (mediaFinal == 0){
-        alert("Ningun dato fue ingresado");
-    } else {
-        alert(`La media es ${mediaFinal}`);
-    }
-}
-/*
-Autor QA: Alejandro Torre Reyes
-Entradas: 1,10,100
-Salida: 37
-Proceso: Ok
-Modularidad: OK. Se realizan funciones para entradas, procedimientos y salidas.
-	Funcion lecturaValores: OK
-	Funcion media: OK
-	Funcion impresion: OK
-*/
diff --git a/Unidad 3-Funciones/Ejercicio18.c b/Unidad 3-Funciones/Ejercicio18.c
new file mode 100644
index 0000000..7bd0b32
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio18.c	
@@ -0,0 +1,76 @@
+#include <stdio.h>
+/*
+EJERCICIO 18
+Realizar una calculador b�sica, recibe 2 n�meos y un si�mbolo y raliza la operaci�n
++ es suma de los n�meros
+- es resta de los n�meros
+* es producto de los n�meros
+/ es divisi�n de los n�meros
+% es el modulo de los n�meros
+AUTOR : Audny Desire� Correa Ceballos
+Equipo '(about : blank)'
+*/
+
+//PROTOTIPOS
+void leerPrimerNumero(int* );
+void leerOperador(char* );
+void leerSegundoNumero(int* );
+int realizarCalculo(int, char, int);
+void imprimirSalidas(int );
+
+int main(){
+	int num1, num2, respuesta;
+	char operador;
+	// ENTRADAS
+	leerPrimerNumero(&num1);
+	leerOperador(&operador);
+	leerSegundoNumero(&num2);
+	//PROCESO
+	respuesta = realizarCalculo(num1, operador, num2);
+	//SALIDAS
+	imprimirSalidas(respuesta);
+	
+	return 0;
+}
+
+//Leer el primer numero 
+void leerPrimerNumero(int* num1){
+	scanf("%d", num1);
+}
+
+//Leer el operador
+void leerOperador(char* operador){
+	scanf("%s", operador);
+}
+
+//Leer el segundo Numero
+void leerSegundoNumero(int* num2){
+	scanf("%d", num2);
+}
+
+//Se buscar� que operador es hasta encontrarlo y se realizar� la operaci�n correspondiente
+int realizarCalculo(int num1, char operador, int num2){
+	int resultado;
+	if(operador == '+'){
+		resultado = num1 + num2;	
+	}
+	else if(operador == '-'){
+		resultado = num1 - num2;
+	}
+	else if(operador== '*'){
+		resultado = num1 * num2;
+	}
+	else if (operador == '/'){
+		resultado = num1 / num2;
+	}
+	else if (operador == '%'){
+		resultado = num1 % num2;
+	}
+	
+	return resultado;
+}
+
+//Imprimir el resultado de la operaci�n
+void imprimirSalidas(respuesta){
+	printf("%d", respuesta);
+}
diff --git a/Unidad 3-Funciones/Ejercicio18.py b/Unidad 3-Funciones/Ejercicio18.py
new file mode 100644
index 0000000..592ed03
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio18.py	
@@ -0,0 +1,48 @@
+#EJERCICIO 18
+#Realizar una calculadora basica que lea 2 numeros y un operador y que realice la operacion correspondiente
+# + suma los 2 numeros
+# - resta los 2 numeros
+# * multiplica los 2 numeros
+# / divide los dos numeros
+# % calcula el modulo de los numeros
+# AUTOR: Audny Desiree Correa Ceballos
+# Equipo '(about: blank)'
+ 
+#Leer los numeros
+def leerNumeros():
+    num = int(input())
+    return num
+
+#leer el operador
+def leerOperador():
+    operador = input()
+    return operador
+
+#PROCESO: comparar al operador hasta encontarlo y realizar la operación correspondiente
+def realizarOperacion (num1,caracter,num2):
+    resultado = 0
+    if caracter == '+' :
+        resultado == num1 + num2
+    elif caracter == '-' :
+        resultado = num1 - num2
+    elif caracter == '*' :
+        resultado = num1 * num2
+    elif caracter == '/' :
+        resultado = num1 / num2
+    elif caracter == '%' :
+        resultado = num1 % num2
+    return resultado
+
+#Imprimir el resultado d la operacion
+def imprimirResultado (respuesta):
+    print(respuesta)
+
+def main():
+    #Entradas
+    num1 = leerNumeros()
+    caracter = leerOperador()
+    num2 = leerNumeros()
+    #Proceso
+    respuesta = realizarOperacion(num1,caracter,num2)
+    #Salidas
+    imprimirResultado(respuesta)
diff --git a/Unidad 3-Funciones/Ejercicio19.c b/Unidad 3-Funciones/Ejercicio19.c
deleted file mode 100644
index 7a1dff8..0000000
--- a/Unidad 3-Funciones/Ejercicio19.c	
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-	Autor: Carlos Chan Gongora 15/02/2019
-	Entradas: Tres numeros.
-	Salidas: El mayor de los 3 numeros.
-	Procedimiento general: Lee los 3 numeros, posterior verifica si son iguales y encuentra
-  el mayor de los 3 numeros, si los numeros no son iguales imprime el mayor, de ser iguales
-  imprime un texto indicando que los numeros son iguales.
-*/
-#include <stdio.h>
-
-int entrada();
-int encontrarMayor(int, int, int);
-int verificarIgualdad(int, int, int);
-void imprimirResultados(int, int);
-
-int main(){
-  // Entradas
-  int num1, num2, num3, mayor, igualdad;
-  num1 = entrada();
-  num2 = entrada();
-  num3 = entrada();
-
-  // Procesos
-  igualdad = verificarIgualdad(num1, num2, num3);
-  if(!igualdad){
-    mayor = encontrarMayor(num1, num2, num3);
-  }
-
-  // Salidas
-  imprimirResultados(igualdad, mayor);
-
-  return 0;
-}
-
-// Lee un numero
-int entrada(){
-  int numero = 1;
-  printf("Ingrese un numero: ");
-  scanf("%d", &numero);
-  return numero;
-}
-// Verifica si los numeros son iguales, de ser verdad regresa 1 o de lo contrario regresa 0
-int verificarIgualdad(int num1, int num2, int num3){
-  int igualdad = 0;
-  if(num1 == num2 && num2 == num3){
-    igualdad = 1;
-  }
-  return igualdad;
-}
-// Compara 3 numeros para encontrar el mayor
-int encontrarMayor(int num1, int num2, int num3){
-  int mayor = 0;
-  if((num1 > num2 && num1 > num3) || (num1 >= num2 && num1 >= num3)){
-    mayor = num1;
-  }
-  else if(num2 > num1 && num2 > num3){
-    mayor = num2;
-  }
-  else{
-    mayor = num3;
-  }
-  return mayor;
-}
-// Verifica si los numeros son iguales, en ese caso imprime que "son iguales",
-// de lo contrario imprime al mayor
-void imprimirResultados(int igualdad, int mayor){
-  if(igualdad){
-    printf("Los numeros son iguales");
-  }
-  else{
-    printf("El mayor es: %d", mayor);
-  }
-}
-
-/*AUTOR QA: RONSSON RAMIRO MAY SANTOS
-ENTRADAS: 9,9, -3
-SALIDAS: EL MAYOR ES -3
-OBSERVACIONES: SOLO FUNCIONA CON NUMEROS POSITIVOS, CON UN NEGATIVO DICE QUE EL NEGATIVO ES EL MAYOR.
-*/
diff --git a/Unidad 3-Funciones/Ejercicio19.lua b/Unidad 3-Funciones/Ejercicio19.lua
deleted file mode 100644
index 13cb774..0000000
--- a/Unidad 3-Funciones/Ejercicio19.lua	
+++ /dev/null
@@ -1,73 +0,0 @@
---[[
-  Autor: Carlos Chan Gongora 15/02/2019
-  Entradas: Tres numeros.
-  Salidas: El mayor de los 3 numeros.
-  Procedimiento general: Lee los 3 numeros, posterior verifica si son iguales y encuentra
-  el mayor de los 3 numeros, si los numeros no son iguales imprime el mayor, de ser iguales
-  imprime un texto indicando que los numeros son iguales.
-]]--
---[[ Funciones ]]--
--- lee un numero
-function entrada()
-  numero = 0
-  io.write("Ingresa un numero: ")
-  numero = io.read("*n")
-  return numero
-end
--- Verfica si los numeros son iguales, de serlo regresa true o si no false.
-function verificarIgualdad(num1, num2, num3)
-  igualdad = false
-  if(num1 == num2 and num2 == num3) then
-    igualdad = true
-  end
-  return igualdad
-end
--- Compara 3 numeros para encontrar el mayor
-function encontrarMayor(num1, num2, num3)
-  mayor = 0;
-  if(num1 > num2 and num1 > num3) then
-    mayor = num1;
-  else if(num2 > num1 and num2 > num3) then
-    mayor = num2;
-  else
-    mayor = num3;
-  end
-  return mayor;
-end
--- Verifica si los numeros son iguales, en ese caso imprime que "son iguales",
--- de lo contrario imprime al mayor
-function imprimirResultados(igualdad, mayor)
-  if igualdad then
-    io.write("Los numeros son iguales")
-  else
-    io.write("El mayor es: "..mayor)
-  end
-end
-
---[[ Main ]]--
--- Entradas
-num1 = entrada();
-num2 = entrada();
-num3 = entrada();
-
--- Procesos
-igualdad = verificarIgualdad(num1, num2, num3);
-if not igualdad then
-  mayor = encontrarMayor(num1, num2, num3);
-end
-
--- Salidas
-imprimirResultados(igualdad, mayor);
-
---[[AUTOR QA : RONSSON RAMIRO MAY SANTOS
-COMPILADO Y PROBADO EN :
-https://www.tutorialspoint.com/execute_lua_online.php
-
-ENTRADAS: NUMERO 1: 34
-          NUMERO 2: -1
-          NUMERO 3: 100
-SALIDAS: "El  mayor es 100"
-
-OBSERVACIONES: MUY BIEN MODULADO EL CODIGO
-
-]]
diff --git a/Unidad 3-Funciones/Ejercicio20.c b/Unidad 3-Funciones/Ejercicio20.c
deleted file mode 100644
index f10f45a..0000000
--- a/Unidad 3-Funciones/Ejercicio20.c	
+++ /dev/null
@@ -1,42 +0,0 @@
-//20.Determinar el valor de la secuencia 1 + 2 + 3 + 4 + 5 +... + n.
-//  Autor: Rodrigo Hernandez Gongora
-#include <stdio.h>
-int entradas(int a);
-int proceso(int x);
-void salidas(int y, int z);
-int main(){
-    int num1=0, val1, flag;
-    val1=entradas(num1);
-    flag=proceso(val1);
-    salidas(val1, flag);
-    
-    return 0;
-}
-
-int entradas(int a){
-    printf("Introduce un numero\n");
-    scanf("%d", &a);
-    return a;
-}
-
-int proceso(int x){
-    int res=0, cont=1;
-    while (cont<=x) {
-        res=res+cont;
-        cont++;
-    }
-    return res;
-}
-void salidas(int y, int z){
-    printf("La suma de los primeros %d numeros naturales es %d\n", y,z);
-}
-/*
-Autor QA: Alejandro Torre Reyes
-Entradas: 100
-Salidas: 5050
-Proceso: Ok
-Modularidad: OK. El main no puede estar más simple.
-    funcion entradas: ok
-    funcion proceso: Ok. También se pudo haber realizado con la formula de n(n+1)/2
-    funcion salidas: Ok
-*/
diff --git a/Unidad 3-Funciones/Ejercicio20.js b/Unidad 3-Funciones/Ejercicio20.js
deleted file mode 100644
index bd23713..0000000
--- a/Unidad 3-Funciones/Ejercicio20.js	
+++ /dev/null
@@ -1,34 +0,0 @@
-//20.Determinar el valor de la secuencia 1 + 2 + 3 + 4 + 5 +... + n.
-//Autor: Rodrigo Hernandez Gongora
-var n;
-
-entradas();
-proceso(n);
-
-function entradas(){
-	n=prompt('Introduce hasta que numero quieres sumar')
-}
-
-function proceso(x){
-	var cont=0;
-	var sum=0;
-	while (cont<x){
-		cont++;
-		sum=sum+cont;
-	}
-	salidas(sum);
-}
-
-function salidas(y) {
-	alert("La suma de los numeros es " + y)
-}
-/*
-Autor QA: Alejandro Torre Reyes
-Entradas: 100
-Salidas: 5050
-Proceso: Ok
-Modularidad: OK. Se realizan funciones para las entradas, el proceso y las salidas.
-    funcion entradas: ok
-    funcion proceso: Ok. También se pudo haber realizado con la formula de n(n+1)/2
-    funcion salidas: Ok
-*/
diff --git a/Unidad 3-Funciones/Ejercicio23.c b/Unidad 3-Funciones/Ejercicio23.c
deleted file mode 100644
index d02eaaf..0000000
--- a/Unidad 3-Funciones/Ejercicio23.c	
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-  Autor: Raul Rivadeneyra
-  Entradas: cualquier numero
-  Salidas: euler a la potencia del numero asignado
-  Proceso general: aplica la siguiente formula e^x = 1 + x + x^2/2! + x^3/3! + ... + x^n/n!
-*/
-#include "stdio.h"
-
-double factorial(float);
-double power(float, int);
-void formula(float*, double*);
-
-int main() {
-  float x;
-  double result = 0;
-  printf("Insert a number: ");
-  scanf("%f", &x);
-
-  formula(&x, &result);
-
-  printf("The outcome is: %f\n", result);
-  return 0;
-}
-
-
-double factorial(float n){
-  double answer = 1;
-  for (int i = 1; i <= n; i++) {
-    answer *= i;
-  }
-  //printf("Factorial = %d\n", answer);
-  return answer;
-}
-
-double power(float base, int exponent){
-  double answer = 1;
-  for (int i = 0; i < exponent; i++) {
-    answer *= base;
-  }
-  //printf("Power = %d\n", answer);
-  return answer;
-}
-
-
-void formula(float *x, double *result){
-  int precision = 25;
-  for (int i = 0; i < precision; i++){
-    *result += (power(*x, i) / factorial(i));
-    //printf("interaion: %f\n",divison(power(*x, i), factorial(i)));
-  }
-}
-/*
-Autor QA: Ronsson RAMIRO MAY SANTOS
-ENTRADAS: 5,8,10
-SALIDAS : THE OUTCOME IS :148.413;
-          THE OUTCOME IS :2980.954493
-          THE OUTCOME IS :22025.43166
-OBSERVACIONES:EL PROGRAMA SI DETERMINA ex = 1 + x + x2/2! + x3/3! + … + xn/n! 
-          
-
-*/
diff --git a/Unidad 3-Funciones/Ejercicio23.lua b/Unidad 3-Funciones/Ejercicio23.lua
deleted file mode 100644
index 62a4c3d..0000000
--- a/Unidad 3-Funciones/Ejercicio23.lua	
+++ /dev/null
@@ -1,29 +0,0 @@
-
-x = io.read("*n")
-result = 0
-
-function factorial(n)
-  answer = 1;
-  for i = 1, n, 1 do
-    answer = answer * i;
-  end
-  return answer;
-end
-
-function formula()
-  precision = 18;
-  for i = 0, precision - 1, 1 do
-    result = result + (x^i / factorial(i));
-  end
-end
-
-
-formula()
-print(result)
-
---[[Autor QA: Ronsson RAMIRO MAY SANTOS
-ENTRADAS: 5,8,10
-SALIDAS : THE OUTCOME IS :148.413;
-          THE OUTCOME IS :2980.954493
-          THE OUTCOME IS :22025.43166
-OBSERVACIONES:EL PROGRAMA SI DETERMINA ex = 1 + x + x2/2! + x3/3! + … + xn/n! ]]
diff --git a/Unidad 3-Funciones/Ejercicio24.c b/Unidad 3-Funciones/Ejercicio24.c
index 8c94dbd..cfcca0f 100644
--- a/Unidad 3-Funciones/Ejercicio24.c	
+++ b/Unidad 3-Funciones/Ejercicio24.c	
@@ -1,62 +1,28 @@
-/*
-Autor: Eyder Concha Moreno 16/Febrero/19
-Entradas: un numero entero
-Salidas: la suma de la serie (1/2) + (2/4) + (3/8) + ... + (n/2^n)
-Procedimiento general:
-1.-Leemos un numero del usuario
-2.-Realizamos la serie hasta el numero establecido, sumando cada resultado a la variable "suma"
-3.-Retornamos el resultado
-4.-Asignamos el resultado a otra variable "sumaDeSerie"
-5.-Imprimimos el resultado
-*/
 #include <stdio.h>
+#include <math.h>
 
-void entradas(int*);
-float exponencial(int, int);
-float serie(int);
+// Variables Globales
 
-int main()
-{
-    int numero;
-    float sumaDeSerie;
+float initialNumber, acum, i;
 
-    printf("Introduce un numero para realizar la suma de la serie \n");
-    entradas(&numero);
-    sumaDeSerie = serie(numero);
-    printf("La suma de la serie es: %f", sumaDeSerie);
-
-	return 0;
-}
-
-void entradas(int* numero){
-    scanf("%i", numero);
+void entrada() {
+    scanf("%f", &initialNumber);
 }
 
-float serie(int repeticiones){
-    float suma = 0;
-    // Repetimos la serie n cantidad de veces
-    for(int i = 1; i <= repeticiones; i++){
-        suma += (i/exponencial(2, i));
+void proceso() {
+    acum = 0;
+    for (int i = 0; i <= initialNumber; i++)
+    {
+        acum = acum + ((i)/ (pow(2,i)));
     }
-    // Retornamos la suma
-    return suma;
+    
 }
-
-float exponencial(int base,int exponente){
-    int resultado = 1;
-    // Elevamos la base la cantidad de veces establecidas por la variable "exponente"
-    for(int i = exponente; i > 0; i--){
-        resultado *= base;
-    }
-    return resultado;
+void salida() {
+    printf("%f", acum);
 }
-/*
-Autor QA: Jorge Abraham Pinto López
-Entradas: 25
-Salidas:  1.999999
-Proceso: OK
-Modularidad: OK. el main no puede estar más simple.
-  Función LecturaDeValores: Ok.
-  Función media: OK.
-  Función impresion: OK.
-*/
+
+int main() {
+    entrada();
+    proceso();
+    salida();
+}
\ No newline at end of file
diff --git a/Unidad 3-Funciones/Ejercicio24.js b/Unidad 3-Funciones/Ejercicio24.js
deleted file mode 100644
index d9c90e3..0000000
--- a/Unidad 3-Funciones/Ejercicio24.js	
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-Autor: Eyder Concha Moreno 16/Febrero/19
-Entradas: un numero entero
-Salidas: la suma de la serie (1/2) + (2/4) + (3/8) + ... + (n/2^n)
-Procedimiento general:
-1.-Leemos un numero del usuario
-2.-Realizamos la serie hasta el numero establecido, sumando cada resultado a la variable "suma"
-3.-Retornamos el resultado
-4.-Asignamos el resultado a otra variable "sumaDeSerie"
-5.-Imprimimos el resultado
-*/
-
-
-var numero;
-var sumaDeSerie;
-
-alert("Introduce un numero para realizar la suma de la serie");
-entradas();
-sumaDeSerie = serie(numero);
-alert(`La suma de la serie es: ${sumaDeSerie}`);
-
-function entradas(){
-    numero = prompt();
-}
-
-function serie(repeticiones){
-    var suma = 0;
-    // Repetimos la serie n cantidad de veces
-    for(var i = 1; i <= repeticiones; i++){
-        suma += (i/exponencial(2, i));
-    }
-    // Retornamos la suma
-    return suma;
-}
-
-function exponencial(base, exponente){
-    var resultado = 1;
-    // Elevamos la base la cantidad de veces establecidas por la variable "exponente"
-    for(var i = exponente; i > 0; i--){
-        resultado *= base;
-    }
-    return resultado;
-}
-/*
-Autor QA: Jorge Abraham Pinto López
-Entradas: 25
-Salidas:  1.999999
-Proceso: OK
-Modularidad: OK. Se realizan las funciones de entrada,proceso y salida.
-  Función LecturaDeValores: Ok.
-  Función media: OK.
-  Función impresion: OK.
-*/
-
-
-
diff --git a/Unidad 3-Funciones/Ejercicio24.py b/Unidad 3-Funciones/Ejercicio24.py
new file mode 100644
index 0000000..0cab38f
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio24.py	
@@ -0,0 +1,31 @@
+#----------------------------------Datos del problema-------------------------------------
+#Ejercicio #36
+# Escribe un programa que dado un número N, imprima  las  posiciones  de  las  celdas  de  la  
+# diagonal  superior hacia abajo.
+# Miguel R. Ávila (Equipo 'about:blank')
+
+#----------------------------------------Funciones------------------------------------------
+# Entrada
+def entrada():
+    initialNumber = int(input())
+    return initialNumber
+
+# Proceso
+def proceso(initialNumber):
+    acum = int(0)
+    for i in range (1, initialNumber+1):
+        acum += ((i) / (2**i))
+
+    return acum
+
+#Salida
+def salida(processNumber):
+    print(processNumber)
+
+#----------------------------------------Proceso-------------------------------------------
+#Primero pedimos el número iniciañ
+initialNumber= entrada()
+#Guardamos lo obtenido en nuestro proceso
+processNumber = proceso(initialNumber)
+#Imprimimos <3 
+salida(processNumber)
\ No newline at end of file
diff --git a/Unidad 3-Funciones/Ejercicio27.c b/Unidad 3-Funciones/Ejercicio27.c
deleted file mode 100644
index 534e640..0000000
--- a/Unidad 3-Funciones/Ejercicio27.c	
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
-	Autor: Carlos Chan Gongora 15/02/2019
-	Entradas: Cualquier numero hasta que se ingrese 999.
-	Salidas: La media aritmetica de los numeros ingresados.
-	Procedimiento general: Lee y suma los numeros que el usuario ingrese, a la vez
-  que cuenta el total de numeros ingresados, al ingresar 999 deja de leer y
-  calcula la media aritmetica.
-*/
-#include <stdio.h>
-
-void leerNumeros();
-
-int main(){
-
-  leerNumeros();
-
-  return 0;
-}
-// Lee los numeros hasta que se ingrese 999
-void leerNumeros(){
-  int num = 0, contador = 0;
-  float media = 0, suma = 0;
-
-  while(num != 999){
-    printf("Ingresa un numero: ");
-    scanf("%d", &num);
-    if(num != 999){
-      suma += num;
-      contador += 1;
-    }
-  }
-  if(contador > 0){
-    media = suma / contador;
-    printf("La media es: %f", media);
-  }
-  else{
-    printf("No ingreso ningun numero.");
-  }
-
-}
-/*AUTOR QA : RONSSON RAMIRO MAY SANTOS
-ENTRADAS:4,5,6,7,8,9,999
-SALIDAS: 6.500000;
-OBSERVACIONES: EL PROGRAMA CALCULA LA MEDIA ARICMETICA DE N NUMEROS CORRECTAMENTE*/
diff --git a/Unidad 3-Funciones/Ejercicio27.lua b/Unidad 3-Funciones/Ejercicio27.lua
deleted file mode 100644
index 5a64d36..0000000
--- a/Unidad 3-Funciones/Ejercicio27.lua	
+++ /dev/null
@@ -1,39 +0,0 @@
---[[
-  Autor: Carlos Chan Gongora 15/02/2019
-  Entradas: Cualquier numero hasta que se ingrese 999.
-  Salidas: La media aritmetica de los numeros ingresados.
-  Procedimiento general: Lee y suma los numeros que el usuario ingrese, a la vez
-  que cuenta el total de numeros ingresados, al ingresar 999 deja de leer y
-  calcula la media aritmetica.
-]]--
---[[ Funciones ]]--
--- Lee los numeros hasta que se ingrese 999
-function leerNumeros()
-  num = 0
-  contador = 0
-  media = 0
-  suma = 0
-
-  while num ~= 999 do
-    io.write("Ingresa un numero: ")
-    num = io.read("*n")
-    if num ~= 999 then
-      suma = suma + num
-      contador = contador + 1
-    end
-  end
-  if contador > 0 then
-    media = suma / contador
-    io.write("La media es: "..media)
-  else
-    io.write("No ingreso ningun numero")
-  end
-end
-
---[[ Main ]]--
-leerNumeros()
-
---[[AUTOR QA : RONSSON RAMIRO MAY SANTOS
-ENTRADAS:4,5,6,7,8,9,999
-SALIDAS: 6.500000;
-OBSERVACIONES: EL PROGRAMA CALCULA LA MEDIA ARICMETICA DE N NUMEROS CORRECTAMENTE]]
diff --git a/Unidad 3-Funciones/Ejercicio28.c b/Unidad 3-Funciones/Ejercicio28.c
deleted file mode 100644
index 0f57a86..0000000
--- a/Unidad 3-Funciones/Ejercicio28.c	
+++ /dev/null
@@ -1,55 +0,0 @@
-//28.Leer una secuencia de números no determinada (finalizará la lectura cuando el último número sea igual a 999) y determinar el valor mayor y el valor menor .
-// Autor: Rodrigo Hernandez Gongora
-/*int main(){
- int x=0, trMax=0, trMin=99999;
- while (x!=999) {
- printf("Introduce un numero\n");
- scanf("%d", &x);
- if (x>trMax) {
- trMax=x;
- }
- if (x<trMin) {
- trMin=x;
- }
- }
- printf("%d, %d", trMax, trMin);
- return 0;
- }
- */
-#include <stdio.h>
-void asignacion(int* x, int* y);
-void salidas(int a, int b);
-int main(){
-    int trMax=0, trMin=99999;
-    asignacion(&trMax, &trMin);
-    salidas(trMax, trMin);
-}
-
-void asignacion(int* x, int* y){
-    int num=0;
-    while (num!=999) {
-        printf("Introduce un numero\n");
-        scanf("%d", &num);
-        if (num>*x) {
-            *x=num;
-        }
-        if (num<*y) {
-            *y=num;
-        }
-    }
-}
-
-void salidas(int a, int b){
-    printf("El numero mayor es %d y el numero menor es %d\n", a, b);
-}
-
-/*
-Autor QA: Jorge Abraham Pinto López
-Entradas: (54, 3, 5, 7, 3467, 3, 35, 998,999)
-Salidas:  El numero mayor es 3467 y el numero menor es 3
-Proceso: OK
-Modularidad: OK. el main no puede estar más simple.
-  Función LecturaDeValores: Ok.
-  Función media: OK.
-  Función impresion: OK.
-*/
diff --git a/Unidad 3-Funciones/Ejercicio28.js b/Unidad 3-Funciones/Ejercicio28.js
deleted file mode 100644
index 8069a22..0000000
--- a/Unidad 3-Funciones/Ejercicio28.js	
+++ /dev/null
@@ -1,37 +0,0 @@
-//28.Leer una secuencia de números no determinada (finalizará la lectura cuando el último número sea igual a 999) y determinar el valor mayor y el valor menor .
-//Autor: Rodrigo Hernandez Gongora
-
-asignacion();
-
-function asignacion(){
-	var x=0;
-	var trMax=0;
-	var trMin=99999;
-	while(x!=999){
-		x=prompt('Introduce un numero');
-		if (x>trMax) {
-			trMax=x;
-		}
-		if (x<trMin) {
-			trMin=x;
-		}
-	}
-	salidas(trMax,trMin)
-}
-
-function salidas(x,y){
-	alert("El numero mayor es " + x);
-	alert("El numero menor es "+ y);
-}
-
-/*
-Autor QA: Jorge Abraham Pinto López
-Entradas: (25, 8, 4, 67, 289, 456, 78, 998, 999)
-Salidas:  El numero mayor es 998 
-	  El numero menor es 4
-Proceso: OK
-Modularidad: OK.
-  Función LecturaDeValores: Ok.
-  Función media: OK.
-  Función impresion: OK.
-*/
diff --git a/Unidad 3-Funciones/Ejercicio3.c b/Unidad 3-Funciones/Ejercicio3.c
deleted file mode 100644
index 9d94bb1..0000000
--- a/Unidad 3-Funciones/Ejercicio3.c	
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-	Autor: Carlos Chan Gongora 15/02/2019
-	Entradas: Un numero entero.
-	Salidas: El dia de la semana correspondiente al numero ingresado.
-	Procedimiento general: Lee un numero, valida que este en el rango de 1 a 7 e Imprime
-  el dia correspondiente.
-*/
-#include <stdio.h>
-
-int entrada();
-int validarNumero(int);
-void imprimirDia(int);
-
-int main(){
-  // Entradas
-  int num;
-  do{
-    num = entrada();
-  }while(!validarNumero(num));
-
-  // Proceso
-  imprimirDia(num);
-
-  return 0;
-}
-
-// Lee un numero
-int entrada(){
-	int numero = 1;
-	printf("Ingrese un numero entre 1 y 7: ");
-	scanf("%d", &numero);
-	return numero;
-}
-// Valida que el numero ingresado sea mayor a cero y menor a 8, devuelve 1 si es mayor y 0 si es menor.
-int validarNumero(int num){
-	int validar = 0;
-	if(num > 0 && num < 8){
-		validar = 1;
-	}
-	else{
-		validar = 0;
-	}
-	return validar;
-}
-// Recibe un entero e imprime el dia correspondiente
-void imprimirDia(int num){
-  printf("El dia correspondiente al numero %d es: ", num);
-  switch (num) {
-    case 1: printf("Lunes");
-            break;
-    case 2: printf("Martes");
-            break;
-    case 3: printf("Miercoles");
-            break;
-    case 4: printf("Jueves");
-            break;
-    case 5: printf("Viernes");
-            break;
-    case 6: printf("Sabado");
-            break;
-    case 7: printf("Domingo");
-            break;
-    default: printf("El numero no esta en el rango de 1 a 7.\n");
-  }
-}
-/*
-QA: Hector Abraham V. Cosgalla
-Entradas: 4, 2, 8 y 7
-Salidas: Jueves, Martes, nada y Domingo (respectivamente)
-Comentarios: Todo excelente.
-*/
diff --git a/Unidad 3-Funciones/Ejercicio3.lua b/Unidad 3-Funciones/Ejercicio3.lua
deleted file mode 100644
index cd98092..0000000
--- a/Unidad 3-Funciones/Ejercicio3.lua	
+++ /dev/null
@@ -1,66 +0,0 @@
---[[
-  Autor: Carlos Chan Gongora 15/02/2019
-  Entradas: Un numero entero.
-  Salidas: El dia de la semana correspondiente al numero ingresado.
-  Procedimiento general: Lee un numero, valida que este en el rango de 1 a 7 e Imprime
-  el dia correspondiente.
-]]--
-
---[[ Funciones ]]--
--- lee un numero
-function entrada()
-  numero = 0
-  io.write("Ingresa un numero entre 1 y 7: ")
-  numero = io.read("*n")
-  return numero
-end
-
--- Valida que el numero este entre 1 y 7
-function validarNumero(num)
-  validar = false
-  if(num >= 1 and num <= 7) then
-    validar = true
-  else
-    validar = false
-  end
-  return validar
-end
-
--- Recibe un entero e imprime el dia correspondiente
-function imprimirDia(num)
-  if n == 1 then
-	   io.write("\nLunes")
-  elseif n == 2 then
-	   io.write("\nMartes")
-  elseif n == 3 then
-	   io.write("\nMiercoles")
-  elseif n == 4 then
-	   io.write("\nJueves")
-  elseif n == 5 then
-	   io.write("\nViernes")
-  elseif n == 6 then
-	   io.write("\nSabado")
-  elseif n == 7 then
-	   io.write("\nDomingo")
-  else
-	   io.write("\nError")
-  end
-end
-
---[[ Main ]]--
--- Entradas
-n = 1
-repeat
-  io.write("Ingresa un numero entre 1 y 7: ")
-  n = io.read("*n")
-until validarNumero(n)
-
--- Salida
-imprimirDia(n)
---[[
-QA: Hector Abraham V. Cosgalla
-Entradas: 5, 2
-Salidas: viernes, martes (respectivamente)
-Funciona correctamente solo que por algun motivo cuando lo 
-ejecutaba primero leia el numero y luego aparecia lo demas.
-]]
\ No newline at end of file
diff --git a/Unidad 3-Funciones/Ejercicio30.c b/Unidad 3-Funciones/Ejercicio30.c
new file mode 100644
index 0000000..9978160
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio30.c	
@@ -0,0 +1,76 @@
+#include <stdio.h>
+/* EJERCICIO 30
+Calcular el MCD de dos N�meros enteros
+Autor: Audny Desire� Correa Ceballos
+Equipo: (�about : blank�)
+*/
+
+//PARAMETROS
+void leerPrimerNumero(int *);
+void leerSegundoNumero(int *);
+int definirNumeroMayor(int, int);
+int definirNumeroMenor(int, int);
+int calcularMCD(int, int);
+void imprimirSalidas(int );
+
+int main(){
+	int num1, num2, nMayor, nMenor, MCD;
+	
+	//Entradas
+	leerPrimerNumero(&num1);
+	leerSegundoNumero(&num2);
+	//Proceso
+	nMayor = definirNumeroMayor(num1, num2);
+	nMenor = definirNumeroMenor(num1, num2);
+	MCD = calcularMCD(nMayor, nMenor);
+	//Salidas
+	imprimirSalidas(MCD);
+	
+	return 0;
+}
+
+//Leer el primer numero
+void leerPrimerNumero(int*num1){
+	scanf("%d", num1);
+	
+}
+//leer el segundo numero
+void leerSegundoNumero(int* num2){
+	scanf("%d", num2);
+}
+
+//Establecer el numero mayor para poder realizar la divisi�n y no obtener decimales
+int definirNumeroMayor(int num1,int num2){
+	if (num1 > num2){
+		return num1;
+	}else{
+		return num2;
+	}
+}
+
+//Establecer el numero menor
+int definirNumeroMenor(int num1,int num2){
+	if (num1 < num2){
+		return num1;
+	}else{
+		return num2;
+	}
+}
+
+//dividir el numero mayor entre el menor y obtener el m�dulo, este se convertir� en el nuevo numero menor y se calcular� de nuevo hasta que 
+//el moduo de 0 el numero menor que logre dar modulo 0 es el MCD
+int calcularMCD(int nMayor, int nMenor){
+	int aux = 0;
+	aux = nMayor % nMenor;
+	while(aux > 0){
+		nMayor = nMenor;
+		nMenor = aux;
+		aux = nMayor % nMenor;
+	}
+	return nMenor;
+}
+
+//Imprimir Salidas
+void imprimirSalidas(MCD){
+	printf("%d", MCD);
+}
diff --git a/Unidad 3-Funciones/Ejercicio30.py b/Unidad 3-Funciones/Ejercicio30.py
new file mode 100644
index 0000000..3f42839
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio30.py	
@@ -0,0 +1,53 @@
+#Ejercicio 30
+#Calcular el MCD de dos numeros enteros
+#AUTOR : Audny Desiree Correa Ceballos
+#Equipo: '(about: blank)'
+
+#Leer primer Numero
+def leerPrimerNumero():
+    num = int(input())
+    return num
+
+#Leer el segundo Numero
+def leerSegundoNumero():
+    num = int(input())
+    return num
+
+# Establecer el numero mayor para poder realizar la división y no obtener decimales
+def definirNumeroMayor(num1,num2):
+    if num1 > num2:
+        return num1
+    else:
+        return num2
+
+#Establecer el numero menor
+def definirNumeroMenor(num1,num2):
+    if num1 < num2:
+        return num1
+    else:
+        return num2
+
+#dividir el numero mayor entre el menor y obtener el módulo, 
+#este se convertirá en el nuevo numero menor y se calculará de nuevo hasta que
+#el modulo de 0 el numero menor que logre dar modulo 0 es el MCD
+def calcularMCD(nMayor, nMenor):
+    aux = nMayor % nMenor
+    while aux > 0:
+        nMayor = nMenor
+        nMenor = aux
+        aux = nMayor % nMenor
+    return nMenor
+    
+#Imprimir el resultado
+def imprimirSalida(resultado):
+    print(resultado)
+
+#ENTRADAS
+num1 = leerPrimerNumero()
+num2 = leerSegundoNumero()
+#PROCESO
+nMayor = definirNumeroMayor(num1, num2)
+nMenor = definirNumeroMenor(num1, num2)
+resultado = calcularMCD(nMayor, nMenor)
+#SALIDA
+imprimirSalida(resultado)
\ No newline at end of file
diff --git a/Unidad 3-Funciones/Ejercicio31.c b/Unidad 3-Funciones/Ejercicio31.c
deleted file mode 100644
index 02cce49..0000000
--- a/Unidad 3-Funciones/Ejercicio31.c	
+++ /dev/null
@@ -1,56 +0,0 @@
-/*Autor: Guillermo Canto Dzul
-Entradas: Un numero entero
-Salidas: Imprime si es primo o no
-*/
-
-#include <stdio.h>
-int entrada();
-int proceso(int n);
-void salida(int n, int esPrimo);
-int main(int argc, char *argv[]) {
-	int n, esPrimo;
-	n = entrada();
-	esPrimo = proceso(n);
-	salida(n, esPrimo);
-	return 0;
-}
-//Lee el numero
-int entrada(){
-	int n;
-	printf("Ingrese un numero:\n");
-	scanf("%d", &n );
-	return n;
-}
-//Verifica si el numero es primo o no.
-int proceso(int n){
-	int suma = 0;
-	int i, flag;
-	for (i=1; i<n ; i++){
-		if (n % i == 0){
-			suma = suma + 1;
-		}
-	}
-	if (suma == 1){
-		flag = 1;
-	}
-	else{
-		flag = 0;
-	}
-	return flag;
-}
-//Imprime el resultado.
-void salida(int n, int esPrimo){
-	if (esPrimo == 1){
-		printf("%d es primo\n", n);
-	}
-	else{
-		printf("%d no es primo\n", n);
-	}
-}
-/*AUTOR QA : DANIEL DELFIN
-ENTRADAS -1,2,17
-SALIDAS -1 NO ES UN NUMERO PRIMO
-	2 ES UN NUMERO PRIMO
-	17 ES UN NUMERO PRIMO
-OBSERVACIONES. MUY BIEN LA MODULARIZACION DEL CODIGO*/
-
diff --git a/Unidad 3-Funciones/Ejercicio31.lua b/Unidad 3-Funciones/Ejercicio31.lua
deleted file mode 100644
index 9b4209a..0000000
--- a/Unidad 3-Funciones/Ejercicio31.lua	
+++ /dev/null
@@ -1,48 +0,0 @@
---[[
-Autor: Guillermo Canto Dzul
-Entradas: Un numero entero
-Salidas: Imprime si es primo o no.
-]]
-
---Funciones
-function entrada()
-  n = io.read("*n")
-end
-
-function proceso()
-  suma = 0
-  for i=1, n, 1
-    if n%i == 0 then
-      suma = suma + 1
-    end
-  end
-  if suma == 1 then
-    flag = 1
-  else
-    flag = 0
-  end
-  return flag
-end
-
-function salida()
-  if esPrimo == 1 then
-    io.write("El numero es primo")
-  else
-    io.write("No es un numero primo")
-  end
-end
-
---Main
-
-entrada()
-esPrimo = proceso()
-salida ()
---[[AUTOR QA: DANIEL DELFIN
-ENTRADAS: -1,2,17,69
-SALIDAS: EL NUMERO NO ES PRIMO,
-         EL NUMERO ES PRIMO,
-         EL NUMERO ES PRIMO
-         EL NUMERO NO ES PRIMO
-OBSERVACIONES: MUY BIEN MODULARIZADO EL CODIGO]]
-
-  
diff --git a/Unidad 3-Funciones/Ejercicio32.c b/Unidad 3-Funciones/Ejercicio32.c
deleted file mode 100644
index 2fc4047..0000000
--- a/Unidad 3-Funciones/Ejercicio32.c	
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * @author: Luis Gerardo Leon Ortega | ejercicio 32
- * Entrada: Dos años
- * Salida general: Los años biciestos comprendidos entre ellos
- * Proceso general:
- *  - calcula la diferencia de años y en un for al mas pequeño se le suma 1 hasta llegar al mas grande
- *  - si el año es divisible por 4 y no es divisible por 100 o el numero es divisible por 400 es biciesto
- */
-#include <stdio.h>
-
-void entradas(int*, int*);
-void proceso(int*, int*);
-void salidas(int);
-
-int main() {
-    /* entradas */
-    int x,y;
-    entradas(&x, &y);
-    /* proceso */
-    proceso(&x, &y);
-    /* salidas */
-    salidas(x);
-
-}
-
-/*
- * Entradas
- */
-void entradas(int* x, int* y){
-    printf("Ingresa el primer año");
-    scanf("%i", x);
-    printf("Ingresa el segundo año");
-    scanf("%i", y);
-}
-
-/*
- * Proceso
- */
-void proceso(int* x, int* y){
-    int temp;
-    if(*x < *y){
-        temp = *x; *x = *y; *y = temp;
-    }
-    temp = 0;
-    for (int i = 1; i < (*x-*y); ++i) {
-        if( ((*y+i)%4 == 0 && (*y+i)%100 != 100) || ((*y+i)%400 == 0)){
-            temp++;
-        }
-    }
-    *x = temp;
-}
-
-/*
- * salidas
- */
-void salidas(int x){
-    printf("Cantidad de años biciesto entre ellos %i", x);
-}
-
-/*
-Autor QA: Jorge Abraham Pinto López
-Entradas: 1947, 2018
-Salidas:  Cantidad de años biciesto entre ellos 18
-Proceso: El programa presenta un error debido a que en la línea 22 se tiene una variable (y) demás en la función "salidas" que no está declarada. Se realiza corrección y el proceso es OK.
-(Solucionado)
-Modularidad: OK. el main no puede estar más simple. 
-  Función LecturaDeValores: OK
-  Función media: OK.
-  Función impresion: OK
-*/
diff --git a/Unidad 3-Funciones/Ejercicio32.js b/Unidad 3-Funciones/Ejercicio32.js
deleted file mode 100644
index 9639d8e..0000000
--- a/Unidad 3-Funciones/Ejercicio32.js	
+++ /dev/null
@@ -1,57 +0,0 @@
-/**
- * @author: Luis Gerardo Leon Ortega | ejercicio 32
- * Entrada: Un año
- * Salida general: Es biciesto o no es biciesto
- * Proceso general:
- *  - si el año es divisible por 4 y no es divisible por 100 o el numero es divisible por 400 es biciesto
- */
-
-/* entradas */
-let x,y
-entradas()
-/* proceso */
-proceso()
-/* salidas */
-salidas()
-
-/**
- * Entradas 
- */
-function entradas(){
-  x = parseInt(prompt("Ingresa el año")) 
-  y = parseInt(prompt("Ingresa el segundo año"))
-}
-
-/**
- * Proceso 
- */
-function proceso(){
-  let temp
-    if(x < y){
-        temp = x; x = y; y = temp
-    }
-    temp = 0
-    for (let i = 1; i < (x-y); ++i) {
-        if( ((y+i)%4 == 0 && (y+i)%100 != 100) || ((y+i)%400 == 0)){
-            temp++
-        }
-    }
-    x = temp
-}
-
-/**
- * Salidas
- */
-function salidas(){
-  alert(`Cantidad de años biciestos entre los años: ${x}`)
-}
-/*
-Autor QA: Jorge Abraham Pinto López
-Entradas: 1947, 2018
-Salidas:  Cantidad de años biciesto entre los años: 18
-Proceso:  OK.
-Modularidad: OK. 
-  Función LecturaDeValores: OK
-  Función media: OK.
-  Función impresion: OK
-*/
diff --git a/Unidad 3-Funciones/Ejercicio35.c b/Unidad 3-Funciones/Ejercicio35.c
deleted file mode 100644
index b21907e..0000000
--- a/Unidad 3-Funciones/Ejercicio35.c	
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-Autor: Amílcar A. Ramírez Patrón
-Entradas: Número de celdas (n)
-Proceso: Iterar por cada parte del número necesario del ejercicio y condicionar que sólo se imprima cuando se necesite,
-imprimirlos con un espacio para la fácil legibilidad.
-Salidas: El orden de los números pedidos.
-*/
-#include <stdio.h>
-void entradaNCeldas(int*);
-void seleccionEspacioCelda(int*);
-
-
-int main(int argc, char *argv[]) {
-	//entrada
-	int n;
-	entradaNCeldas(&n);
-	//proceso
-	seleccionEspacioCelda(&n);
-	//salida
-	return 0;
-}
-
-
-void entradaNCeldas(int *n){
-	scanf("%d", n);
-}
-
-void seleccionEspacioCelda(int *n){
-	int i = 0, j = 0;
-	for(i = 0; i < *n; i = i + 1){
-		for(j = 0; j < *n; j = j + 1){
-			if (i <= j){
-				printf("%d%d  ", i, j);
-			}
-			printf("	");
-		}
-		printf("\n");
-	}
-
-}
-/*
-QA: Realizo: Daniel
-Entradas: 5
-Salidas: la diagonal superior de una matriz de 5 numeros
-Todo bien
-*/
diff --git a/Unidad 3-Funciones/Ejercicio35.lua b/Unidad 3-Funciones/Ejercicio35.lua
deleted file mode 100644
index 5bb1122..0000000
--- a/Unidad 3-Funciones/Ejercicio35.lua	
+++ /dev/null
@@ -1,33 +0,0 @@
---[[Autor: Amílcar A. Ramírez Patrón
-Entradas: Número de celdas (n)
-Proceso: Iterar por cada parte del número necesario del ejercicio y condicionar que sólo se imprima cuando se necesite,
-imprimirlos con un espacio para la fácil legibilidad.
-Salidas: El orden de los números pedidos.
-]]
---[[ Funciones ]]--
-function entradaNCeldas()
-    n = io.read("*n")
-end
-
-function seleccionEspacioCelda()
-    for i = 0, n - 1, 1 do
-        for j = 0, n - 1, 1 do
-            if i >= j then
-                print(i, j, " ") --En Lua no deja imprimir seguido--
-            end
-            print ("    ")
-        end
-    end
-end
-
-
---[[ Main ]]--
-entradaNCeldas()
-seleccionEspacioCelda()
---[[
-QA: Realizo: Daniel
-Entradas: Numero 5
-Salidas: Diagonal superior de una matriz de 5 por 5
-No tiene el formato requerido
-
-]]
diff --git a/Unidad 3-Funciones/Ejercicio36.c b/Unidad 3-Funciones/Ejercicio36.c
index f6289f5..68c074e 100644
--- a/Unidad 3-Funciones/Ejercicio36.c	
+++ b/Unidad 3-Funciones/Ejercicio36.c	
@@ -1,69 +1,36 @@
-/*
-Autor: Eyder Concha Moreno 16/Febrero/19
-Entradas: Un numero entero que representa el tama�o de la tabla diagonal
-Salidas: Una tabla diagonal de "n" celdas
-Procedimiento general:
-1.-Leemos el tama�o de la tabla
-2.-Imprimimos primero las columnas de cada fila, al imprimir toda, aumentamos el tama�o m�ximo
-   de columnas para representar la diagonal
-3.-Pasamos a la siguiente fila y repetimos hasta llegar al tama�o establecido para la tabla
-*/
 #include <stdio.h>
+#include <math.h>
 
-void entradas(int*);
-void procedimiento(int);
+// Variables Globales
 
-int main()
-{
-    int numero;
-    entradas(&numero);
-    procedimiento(numero);
+int initialNumber, j, i;
 
-	return 0;
+void entrada() {
+    scanf("%d", &initialNumber);
 }
 
-void entradas(int* numero){
-    scanf("%i", numero);
-}
-
-void procedimiento(int tamanoTablaDiagonal){
-    int largo = 1;
-    int valorColumna = 0;
-    int valorFila = 0;
-
-    // Imprimimos filas
-    while(valorFila < tamanoTablaDiagonal){
-        valorColumna = 0;
-        // Imprimimos las columnas para cada fila, segun la cantidad de columnas
-        while(valorColumna < largo){
-            printf(" %i%i ", valorFila, valorColumna);
-            valorColumna++;
+void proceso() {
+    for (int i = 0; i < initialNumber; i++)
+    {
+        for (int j = 0; j < initialNumber; j++)
+        {
+            if (j <= i)
+            {
+                printf("%d", i);
+                printf("%d", j);
+                printf(" ");
+            }
+            
         }
         printf("\n");
-        // Aumentamos uno al largo de columnas para representar la diagonal tras cada iteraci�n
-        largo++;
-        valorFila++;
+        
     }
+    
+    
 }
 
-/*QA: Amaury Morales Cerecedo
-
-Funcion: main()
-Entradas: printf despues de cada linea.
-Salidas: El codigo se ejecuta.
-
-Funcion: entradas()
-Entradas: 4
-Salidas: scanf - numero
-
-Funcion: procedimiento()
-Entradas: 4
-Salidas:  
- 00 
- 10  11 
- 20  21  22 
- 30  31  32  33 
-
- Final: El codigo funciona correctamente.
-*/
 
+int main() {
+    entrada();
+    proceso();
+}
\ No newline at end of file
diff --git a/Unidad 3-Funciones/Ejercicio36.js b/Unidad 3-Funciones/Ejercicio36.js
deleted file mode 100644
index 44fe68f..0000000
--- a/Unidad 3-Funciones/Ejercicio36.js	
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-Autor: Eyder Concha Moreno 16/Febrero/19
-Entradas: Un numero entero que representa el tama�o de la tabla diagonal
-Salidas: Una tabla diagonal de "n" celdas
-Procedimiento general:
-1.-Leemos el tama�o de la tabla
-2.-Imprimimos primero las columnas de cada fila, al imprimir toda, aumentamos el tama�o m�ximo
-   de columnas para representar la diagonal
-3.-Pasamos a la siguiente fila y repetimos hasta llegar al tama�o establecido para la tabla
-*/
-
-
-var numero;
-entradas();
-procedimiento(numero);
-
-
-function entradas(){
-   //Imprimimos el resultado
-    numero = prompt('Ingresa el tamaño de la tabla diagonal');
-}
-
-function procedimiento(tamanoTablaDiagonal){
-    var largo = 1;
-    var valorColumna = 0;
-    var valorFila = 0;
-
-    // Imprimimos filas
-    while(valorFila < tamanoTablaDiagonal){
-        valorColumna = 0;
-        // Imprimimos las columnas para cada fila, segun la cantidad de columnas
-        while(valorColumna < largo){
-            document.write(`(${valorFila},${valorColumna})`);
-            valorColumna++;
-        }        
-        document.write('<br>');
-        // Aumentamos uno al largo de columnas para representar la diagonal tras cada iteraci�n
-        largo++;
-        valorFila++;
-    }
-}
-
-/*QA: Amaury Morales Cerecedo
-
-Funcion: main() (campo de pruebas aparte)
-Entradas: document.write despues de cada linea.
-Salidas: El codigo se ejecuta.
-
-Funcion: entradas()
-Entradas: 4
-Salidas: scanf - numero
-
-Funcion: procedimiento()
-Entradas: 4
-Salidas:  
- 00 
- 10  11 
- 20  21  22 
- 30  31  32  33 
-
- Final: El codigo funciona correctamente al igual que su equivalente en C.
-*/
-
-
diff --git a/Unidad 3-Funciones/Ejercicio36.py b/Unidad 3-Funciones/Ejercicio36.py
new file mode 100644
index 0000000..32f292a
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio36.py	
@@ -0,0 +1,27 @@
+#----------------------------------Datos del problema-------------------------------------
+#Ejercicio #36
+# Escribe un programa que dado un número N, imprima  las  posiciones  de  las  celdas  de  la  
+# diagonal  superior hacia abajo.
+# Miguel R. Ávila (Equipo 'about:blank')
+
+#----------------------------------------Funciones------------------------------------------
+# Entrada
+def entrada():
+    initialNumber = int(input())
+    return initialNumber
+# Proceso
+def proceso(initialNumber):
+    
+    for i in range(0,initialNumber):
+        for j in range(0, initialNumber):
+            if j <= i:
+                print(i, end="")
+                print(j, "", end="")
+        print("")
+        print("")
+
+#----------------------------------------Proceso-------------------------------------------
+#Primero pedimos nuestra N inicial
+initialNumber= entrada()
+#Ya que en si, la salida es el proceso de nuestro código, solo hacemos el proceso
+proceso(initialNumber)
diff --git a/Unidad 3-Funciones/Ejercicio39.c b/Unidad 3-Funciones/Ejercicio39.c
deleted file mode 100644
index b286129..0000000
--- a/Unidad 3-Funciones/Ejercicio39.c	
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-Autor: Amílcar A. Ramírez Patrón
-Proceso: La suma de los impares del 0 al 10 en una variable
-Salida: El resultado de la suma
-*/
-#include <stdio.h>
-void sumaDeImpares(int*);
-
-int main(int argc, char *argv[]) {
-	int resultado;
-	sumaDeImpares(&resultado);
-	return 0;
-}
-
-void sumaDeImpares(int *resultado){
-	printf("%d", *resultado = (1 + 3 + 5 + 7 + 9));
-}
-
-/*
-QA: Realizó: Daniel Delfin
-Entradas: None
-Salidas: 25 
-Funciona Correctamente. 
-*/
diff --git a/Unidad 3-Funciones/Ejercicio39.lua b/Unidad 3-Funciones/Ejercicio39.lua
deleted file mode 100644
index 5b9311d..0000000
--- a/Unidad 3-Funciones/Ejercicio39.lua	
+++ /dev/null
@@ -1,19 +0,0 @@
---[[Autor: Amílcar A. Ramírez Patrón
-Proceso: La suma de los impares del 0 al 10 en una variable
-Salida: El resultado de la suma]]
---[[ Funcion ]]--
-function sumaDeImpares()
-    resultado = 1 + 3 + 5 + 7 + 9
-    print(resultado)
-end
-
---[[ Main ]]--
-sumaDeImpares()
-
---[[
-QA: Realizó: Daniel Delfin
-Entradas: None
-Salidas: 25
-Funciona Correctamente. 
-No tiene la documentacion completa
-]]
diff --git a/Unidad 3-Funciones/Ejercicio4.c b/Unidad 3-Funciones/Ejercicio4.c
deleted file mode 100644
index dbcd887..0000000
--- a/Unidad 3-Funciones/Ejercicio4.c	
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-Autor:Jorge Chí 16/Febrero/19
-Entradas: numero (a redondear).
-Salidas: cadena con el número redondeado
-Procedimiento general: Se ingresa un numero. Si es negativo se pide de nuevo.
-Se redondea el numero a la centena más cercana
-*/
-
-
-#include <stdio.h>
-
-int lectura();
-int redondeo(int numeroX);
-void impresionNumero(int numeroX);
-
-int main(void){
-
-//se inicia la variable que guarda el número
-
-int numero = 0;
-
-//Entradas: se solicita el número a redondear que no sea negativo
-
-numero = lectura();
-
-/*Proceso : si el número es 100 o menor que 100 se imprime el redondeo 100. sino,
-se hace el proceso de redondeo a la siguiente centena cercana */
-
-numero = redondeo(numero);
-
-//salidas: se imprime el número
-
-impresionNumero(numero);
-
-return 0;
-
-}
-
-int lectura(){
-//entradas: ninguna
-
-    int dato = 0;
-
-//procedimiento: se imprime la petición del dato y se lee
-
-while (1){
-
-    printf("Ingresa un numero que quieras redondear a la centena mas cercana:\n");
-    scanf("%i", &dato);
-
-    if (dato < 0){
-
-        printf("ERROR, numero menor que 0\n");
-
-    } else {
-
-        break;
-
-    }
-
-}
-
-//salida: el dato leido
-
-    return dato;
-}
-
-int redondeo(int numero){
-
-//entradas: el numero a redondear
-
-    int numeroRedondeado = 0;
-
-//procedimiento: se redondea el número
-
-    if (numero <= 100){
-
-    numeroRedondeado = 100;
-
-} else {
-
-   numero = (numero + 50) / 100 ;
-   numeroRedondeado = numero * 100;
-
-}
-
-//salida: el numero redondeado
-
-return numeroRedondeado;
-}
-
-void impresionNumero(int numero){
-
-//entrada: el numero redondeado
-
-//procedimiento: se imprime el númerp
-
-printf("El numero redondeado es: %i", numero);
-
-}
-
-/*QA: Amaury Morales Cerecedo
-
-Funcion: main()
-Entradas: printf despues de cada linea.
-Salidas: El codigo se ejecuta.
-
-Funcion: lectura()
-Entradas: 1, 101, 151
-Salidas: los numeros introducidos.
-
-Funcion: redondeo()
-Entradas: 1, 101, 151
-Salidas: 100, 100, 200.
-
-Funcion: impresionNumero()
-Entradas: ninguna
-Salidas: solo imprime el numero redondeado
-
- Final: El codigo funciona correctamente.
-*/
diff --git a/Unidad 3-Funciones/Ejercicio4.js b/Unidad 3-Funciones/Ejercicio4.js
deleted file mode 100644
index 76ef9e0..0000000
--- a/Unidad 3-Funciones/Ejercicio4.js	
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-Autor:Jorge Chí 16/Febrero/19
-Entradas: numero (a redondear).
-Salidas: cadena con el número redondeado
-Procedimiento general: Se ingresa un numero. Si es negativo se pide de nuevo.
-Se redondea el numero a la centena más cercana
-*/
-
-var numero = 0;
-
-alert("Ingresa un numero que quieras redondear a la centena mas cercana:");
-lectura();
-numero = redondeo(numero);
-impresion(numero);
-
-function lectura(){
-//se lee el numero hasta que no sea negativo
-    while(true){
-        numero = parseInt(prompt());
-        if (numero < 0){  
-             alert("ERROR, numero menor que 0:");  
-         } else { 
-              break; 
-        }
-     }
- }
-
-function redondeo(numeroX){ 
-//entradas: el numero a redondear
-var numeroRedondeado = 0;
-//procedimiento: se redondea el número
-if (numeroX <= 100){
-numeroRedondeado = 100;
-    } else {
-            numeroX = parseInt(parseInt(parseInt(numeroX + 50) / 100));
-            numeroRedondeado = parseInt(numeroX * 100);
-           }
-//salida: el numero redondeado
-return numeroRedondeado;     
-}
-
-function impresion(numeroY){    
-    //entrada: el numero redondeado
-    //procedimiento: se imprime el númerp
-   alert(`El numero redondeado es ${numeroY}`); 
-}
-
-/*QA: Amaury Morales Cerecedo
-
-Funcion: main() (campo de pruebas)
-Entradas: alert despues de cada linea.
-Salidas: El codigo se ejecuta.
-
-Funcion: lectura()
-Entradas: 1, 101, 151
-Salidas: los numeros introducidos.
-
-Funcion: redondeo()
-Entradas: 1, 101, 151
-Salidas: 100, 100, 200.
-
-Funcion: impresion()
-Entradas: ninguna
-Salidas: solo imprime el numero redondeado
-
- Final: El codigo funciona correctamente asi como su version en C
-*/
diff --git a/Unidad 3-Funciones/Ejercicio40.c b/Unidad 3-Funciones/Ejercicio40.c
deleted file mode 100644
index d3bc774..0000000
--- a/Unidad 3-Funciones/Ejercicio40.c	
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-Autor: Eyder Concha Moreno 16/Febrero/19
-Entradas: Una "n" cantidad de trabajadores
-Salidas: El sueldo de cada trabajador con el aumento (de haber uno)
-
-Procedimiento general:
-1.-Leemos la cantidad de trabajadores
-2.-Preguntamos el sueldo de cada trabajador
-3.-Imprimimos el sueldo de cada uno con el aumento (de haber uno)
-*/
-#include <stdio.h>
-
-void entradas(int*);
-void procedimiento(int);
-void impresionSueldo(float, float);
-
-int main()
-{
-    int numeroTrabajadores;
-
-    printf("Introduce el numero de trabajadores");
-    entradas(&numeroTrabajadores);
-
-    printf("Ingrese el sueldo de el/los %i empleado(s) \n", numeroTrabajadores);
-    procedimiento(numeroTrabajadores);
-
-	return 0;
-}
-
-void entradas(int* numeroTrabajadores){
-    scanf("%i", numeroTrabajadores);
-}
-
-void impresionSueldo(float sueldo, float aumento){
-    // Si el aumento es mayor a 0, entonces imprimimos el sueldo con el aumento
-    if(aumento > 0){
-        printf("El sueldo es de %f y el aumento fue de %f \n", sueldo, aumento);
-    }else {
-        printf("El sueldo es de %f \n", sueldo);
-    }
-}
-
-void procedimiento(int numeroTrabajadores){
-    // Definimos el porcentaje de aumento
-    float porcentajeAumento = .15;
-
-    // Preguntamos a cada trabajador su sueldo
-    for(int i = 0; i < numeroTrabajadores; i++){
-        float sueldo = 0;
-        float aumento = 0;
-        scanf("%f", &sueldo);
-
-        // De ser menor a 800, determinamos un aumento
-        if(sueldo < 800){
-            aumento = sueldo*porcentajeAumento;
-            sueldo += aumento;
-        }
-        impresionSueldo(sueldo, aumento);
-    }
-}
-
-
-/*QA: Amaury Morales Cerecedo
-
-Funcion: main()
-Entradas: printf despues de cada linea.
-Salidas: El codigo se ejecuta.
-
-Funcion: entrada()
-Entradas: trajadores 5, sueldo 100, trabajadores 1, sueldo 900
-Salidas: 5 trabajadores. c/sueldo 100. 1 trabajador, sueldo 900.
-
-Funcion: procedimiento()
-Entradas: trabajadores 5, trabajadores 1
-Salidas: sueldo 115, aumento 15. sueldo 900, aumento 0.
-
-Funcion: impresionSueldo()
-Entradas: ninguna
-Salidas: solo imprime el sueldo de cada trabajador
-
- Final: El codigo funciona correctamente.
-*/
-
diff --git a/Unidad 3-Funciones/Ejercicio40.js b/Unidad 3-Funciones/Ejercicio40.js
deleted file mode 100644
index 10e41ed..0000000
--- a/Unidad 3-Funciones/Ejercicio40.js	
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
-Autor: Eyder Concha Moreno 16/Febrero/19
-Entradas: Una "n" cantidad de trabajadores
-Salidas: El sueldo de cada trabajador con el aumento (de haber uno)
-
-Procedimiento general:
-1.-Leemos la cantidad de trabajadores
-2.-Preguntamos el sueldo de cada trabajador
-3.-Imprimimos el sueldo de cada uno con el aumento (de haber uno)
-*/
-
-var numeroTrabajadores;
-entradas();
-
-procedimiento(numeroTrabajadores);
-
-function entradas(){
-    numeroTrabajadores = prompt('Introduce el numero de trabajadores');
-}
-
-function procedimiento(numeroTrabajadores){
-    // Definimos el porcentaje de aumento
-    var porcentajeAumento = .15;
-
-    // Preguntamos a cada trabajador su sueldo
-    for(var i = 0; i < numeroTrabajadores; i++){
-        var sueldo = 0;
-        var aumento = 0;
-        sueldo = prompt('Ingresa el sueldo del trajador');
-
-        // De ser menor a 800, determinamos un aumento
-        if(sueldo < 800){
-            aumento = sueldo*porcentajeAumento;
-            sueldo = parseFloat(sueldo) + aumento;
-        }
-        impresionSueldo(sueldo, aumento);
-    }
-}
-
-function impresionSueldo(sueldo, aumento){
-  // Si el aumento es mayor a 0, entonces imprimimos el sueldo con el aumento
-  if(aumento > 0){
-      alert(`El sueldo es de ${sueldo} y el aumento fue de ${aumento}`);
-  }else {
-      alert(`El sueldo es de ${sueldo}`);
-  }
-}
-
-/*QA: Amaury Morales Cerecedo
-
-Funcion: main() (campo de pruebas)
-Entradas: alert despues de cada linea.
-Salidas: El codigo se ejecuta.
-
-Funcion: entradas()
-Entradas: trajadores 5, sueldo 100, trabajadores 1, sueldo 900
-Salidas: 5 trabajadores. c/sueldo 100. 1 trabajador, sueldo 900.
-
-Funcion: procedimiento()
-Entradas: trabajadores 5, trabajadores 1
-Salidas: sueldo 115, aumento 15. sueldo 900, aumento 0.
-
-Funcion: impresionSueldo()
-Entradas: ninguna
-Salidas: solo imprime el sueldo de cada trabajador
-
- Final: El codigo funciona correctamente.
-*/
-
diff --git a/Unidad 3-Funciones/Ejercicio42.c b/Unidad 3-Funciones/Ejercicio42.c
new file mode 100644
index 0000000..e71440b
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio42.c	
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <math.h>
+
+//Prototipos de las funciones
+float num = 0;
+float numRaiz= 0 ;
+float raizProceso(float,float);
+//Salida 
+int main() {
+	
+	raizProceso(num,numRaiz);
+	
+return 0;
+}
+//Funciones
+float raizProceso(float num,float numRaiz){
+	//Se obtiene la raiz
+	for (num=0; num<=100; num++){
+		numRaiz=sqrt(num);
+		return num;
+		return numRaiz;
+	}
+	return num;
+	return numRaiz;
+}
+	
diff --git a/Unidad 3-Funciones/Ejercicio42.py b/Unidad 3-Funciones/Ejercicio42.py
new file mode 100644
index 0000000..f27906a
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio42.py	
@@ -0,0 +1,18 @@
+#Ejercicio #42
+#Escribe el programa que calcule las raíces cuadradas de los cien primeros números naturales. Como resultado se desean dos columnas de valores: #
+#En la primera columna se escribirán los números naturales y en la segunda sus raíces correspondientes.
+#Pamela Citlali Canul Chacón (Equipo 'about:blank')
+
+#El problema no necesita entradas 
+
+#Proceso
+import math 
+#Se define la funcion
+def raiz (numRaiz,num):
+    #Se obtiene la raiz
+    for num in range (1,101):
+        numRaiz=math.sqrt(num)
+        print (num)
+        print (numRaiz)
+#Salida 
+print (raiz (numRaiz=0,num=0))
\ No newline at end of file
diff --git a/Unidad 3-Funciones/Ejercicio43.c b/Unidad 3-Funciones/Ejercicio43.c
deleted file mode 100644
index d25edfb..0000000
--- a/Unidad 3-Funciones/Ejercicio43.c	
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
-  Autor: Raul Rivadeneyra
-  Entradas: Numeros enteros
-  Salidas: Cuantos numeros positivos y negativos hay
-  Proceso general: lee numeros enteros del usuario y si es positivo le suma uno al contador de positivos y lo similar
-  si es negativo.
-*/
-
-#include "stdio.h"
-
-void process(int*, int*);
-char getNumbers(int*);
-void checkSign(int, int*, int*);
-
-int main() {
-  int positive = 0;
-  int negative = 0;
-
-  //Da instrucciones al usuario
-  printf("Insert numbers to check how many positives or negatives are (type 0 to stop):\n");
-
-  //Proceso
-  process(&positive, &negative);
-
-  //Imprime el resultado
-  printf("There are %d positive numbers and %d negative numbers\n", positive, negative);
-  return 0;
-}
-
-//Funciones//
-
-//Combina las funciones de getNumber y checkSign en un ciclo
-void process(int *positive, int *negative) {
-  int number;
-  while (getNumbers(&number) == 0) {
-    checkSign(number, positive, negative);
-  }
-}
-
-/*
-  Lee numeros enteros y le asigna el valor directamente a la variable externa (paso por referencia),
-  si el numero es 0 entonces devuelve 1 para finalizar el ciclo donde se llamo, de lo contrario hace
-  return 0 por lo que sigue el ciclo
-*/
-char getNumbers(int *number) {
-  scanf("%d", number);
-  if (*number == 0){
-    return 1;
-  }
-  return 0;
-}
-
-//Evalua si el numero dado es postitivo o negativo y suma 1 a el asignado
-void checkSign(int value, int *positive, int *negative) {
-  if (value > 0){
-    *positive = *positive + 1;
-  }
-  else{
-    *negative = * negative + 1;
-  }
-}
-
-/*
-Autor: Raul Rivadeneyra
-Entradas: Numeros enteros
-Salidas: Cuantos numeros positivos y negativos hay
-Proceso general: lee numeros enteros del usuario y si es positivo le suma uno al contador de positivos y lo similar
-si es negativo.
-*/
-
-#include "stdio.h"
-
-void process(int*, int*);
-char getNumbers(int*);
-void checkSign(int, int*, int*);
-
-int main() {
-	int positive = 0;
-	int negative = 0;
-	
-	//Da instrucciones al usuario
-	printf("Insert numbers to check how many positives or negatives are (type 0 to stop):\n");
-	
-	//Proceso
-	process(&positive, &negative);
-	
-	//Imprime el resultado
-	printf("There are %d positive numbers and %d negative numbers\n", positive, negative);
-	return 0;
-}
-
-//Funciones//
-
-//Combina las funciones de getNumber y checkSign en un ciclo
-void process(int *positive, int *negative) {
-	int number;
-	while (getNumbers(&number) == 0) {
-		checkSign(number, positive, negative);
-	}
-}
-
-/*
-Lee numeros enteros y le asigna el valor directamente a la variable externa (paso por referencia),
-si el numero es 0 entonces devuelve 1 para finalizar el ciclo donde se llamo, de lo contrario hace
-return 0 por lo que sigue el ciclo
-*/
-char getNumbers(int *number) {
-	scanf("%d", number);
-	if (*number == 0){
-		return 1;
-	}
-	return 0;
-}
-
-//Evalua si el numero dado es postitivo o negativo y suma 1 a el asignado
-void checkSign(int value, int *positive, int *negative) {
-	if (value > 0){
-		*positive = *positive + 1;
-	}
-	else{
-		*negative = * negative + 1;
-	}
-}
-
-/*
-QA: Realizó: Jose Mendez
-Entradas: (5, -6, 9, -7, 99, -99 , 0)
-Salidas: 3 positivps y 3 negativos
-Funciona Correctamente.
-*/
diff --git a/Unidad 3-Funciones/Ejercicio43.lua b/Unidad 3-Funciones/Ejercicio43.lua
deleted file mode 100644
index 292b435..0000000
--- a/Unidad 3-Funciones/Ejercicio43.lua	
+++ /dev/null
@@ -1,36 +0,0 @@
-x = 0
-positive = 0
-negative = 0
-
-function getNumber()
-  x = io.read("*n")
-  return x
-end
-
-function checkSign(num)
-  if num > 0 then
-    return 0
-  elseif num < 0 then
-    return 1
-  end
-end
-
-function process()
-  while (getNumber() ~= 0) do
-    if (checkSign(x) == 0) then
-      positive = positive + 1
-    elseif (checkSign(x) == 1) then
-      negative = negative + 1
-    end
-  end
-end
-
-process()
-print("Hay "..positive.." numeros positivos y "..negative.." numeros negativos")
-
---[[
-QA: Realizó: Jose Mendez
-Entradas: (3, -5, 5, -7, 99, -99 , 0)
-Salidas: 3 positivos y 3 negativos
-Funciona Correctamente.
-]]
diff --git a/Unidad 3-Funciones/Ejercicio44.c b/Unidad 3-Funciones/Ejercicio44.c
deleted file mode 100644
index 9fcd977..0000000
--- a/Unidad 3-Funciones/Ejercicio44.c	
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * @author: Luis Gerardo Leon Ortega | ejercicio 44
- * Entrada: un numero n
- * Salida general: MCD de dos numeros con algoritmo de Euclides
- * Proceso general:
- * a. Dividir el mayor de los dos números por el más pequeño
- * b. A continuación dividir el divisor por el resto
- * c. Continuar el proceso de dividir el último resto hasta que la división
- * sea exacta.
- * d. El último divisor es el MCD
- */
-#include <stdio.h>
-
-void entradas(int*, int*);
-void proceso(int*, int*);
-void salida(int);
-
-int main() {
-    /* entrada */
-    int x,y;
-    entradas(&x,&y);
-    /* procedimiento */
-    proceso(&x, &y);
-    /* salida */
-    salida(x);
-    return 0;
-}
-
-/**
- * Entradas
- */
-void entradas(int* x, int* y){
-    printf("Ingresa un numero: ");
-    scanf("%d", x);
-    printf("Ingresa tu segundo numero: ");
-    scanf("%d", y);
-}
-
-/**
- * Proceso
- */
-void proceso(int* x, int* y){
-    while(*x != *y){
-        if(*x > *y){
-            *x = *x - *y;
-        }else{
-            *y = *y - *x;
-        }
-    }
-}
-
-/**
- * Salidas
- */
-void salida(int x){
-    printf("resultado: %i", x);
-}
-
-/*QA: Amaury Morales Cerecedo
-
-Funcion: main()
-Entradas: printf despues de cada linea.
-Salidas: El codigo se ejecuta.
-
-Funcion: entradas()
-Entradas: 250, 12
-Salidas: ninguna, solo sobreescribir
-
-Funcion: proceso()
-Entradas: 250, 12
-Salidas: el MCM.
-
-Funcion: salida()
-Entradas: el resultado del proceso
-Salidas: solo imprime el mcm, en este caso fue 2.
-
- Final: El codigo funciona correctamente.
-*/
diff --git a/Unidad 3-Funciones/Ejercicio44.js b/Unidad 3-Funciones/Ejercicio44.js
deleted file mode 100644
index f5327f8..0000000
--- a/Unidad 3-Funciones/Ejercicio44.js	
+++ /dev/null
@@ -1,68 +0,0 @@
-/**
- * @author: Luis Gerardo Leon Ortega
- * Entrada: un numero n
- * Salida general: MCD de dos numeros con algoritmo de Euclides
- * Proceso general:
- * a. Dividir el mayor de los dos números por el más pequeño
- * b. A continuación dividir el divisor por el resto
- * c. Continuar el proceso de dividir el último resto hasta que la división
- * sea exacta.
- * d. El último divisor es el MCD
- */
-
-/* entradas */
-let x,y
-entradas()
-/* proceso */
-proceso()
-/* salidas */
-salidas()
-
-/**
- * Entradas 
- */
-function entradas(){
-  x = parseInt(prompt("primer numero")) 
-  y =  parseInt(prompt("segundo numero"))
-}
-
-/**
- * Proceso 
- */
-function proceso(){
-  while(x != y){
-        if(x > y){
-            x = x - y
-        }else{
-            y = y - x
-        }
-    }
-}
-
-/**
- * Salidas
- */
-function salidas(){
-  alert(x)
-}
-
-/*QA: Amaury Morales Cerecedo
-
-Funcion: main() (campo de pruebas)
-Entradas: alert despues de cada linea.
-Salidas: El codigo se ejecuta.
-
-Funcion: entradas()
-Entradas: 9999, 13
-Salidas: ninguna, solo sobreescribir
-
-Funcion: proceso()
-Entradas: 9999, 13
-Salidas: el MCM.
-
-Funcion: salidas()
-Entradas: el resultado del proceso
-Salidas: solo imprime el mcm, en este caso fue 1.
-
- Final: El codigo funciona correctamente.
-*/
diff --git a/Unidad 3-Funciones/Ejercicio47.c b/Unidad 3-Funciones/Ejercicio47.c
index cddbb61..aecd945 100644
--- a/Unidad 3-Funciones/Ejercicio47.c	
+++ b/Unidad 3-Funciones/Ejercicio47.c	
@@ -1,97 +1,88 @@
-/*Autor: Guillermo Canto Dzul
-Entradas: Nombre, edad, salario por hora, horas trabajadas, impuesto.
-Salidas: El sueldo neto.
-*/
-#include <stdio.h>
-//Entradas
-char getName();
-int getAge();
-int getSalary();
-int getHours();
-int getTax();
-//Proceso
-int proceso(int salary, int hours, int tax);
-//Salidas
-void salida(int sueldoNeto);
-
-int main(int argc, char *argv[]) {
-	char name[15];
-	int age, salary, hours, tax, sueldoNeto;
-	//Entradas
-	name[15] = getName();
-	age = getAge();
-	salary = getSalary();
-	hours = getHours();
-	tax = getTax();
-	//Proceso
-	sueldoNeto = proceso(salary, hours, tax);
-	//Salida
-	salida(sueldoNeto);
-	return 0;
-}
-//Las funciones get leen la entrada correspondiente
-char getName(){
-	char name[15];
-	printf("Ingrese su nombre: ");
-	scanf ("%s", &name);
-	return name[15];
-}
-int getAge(){
-	int age;
-	do{
-		printf("Ingrese su edad: ");
-		scanf("%d", &age);
-	} while (age<=0);
-	return age;
-}
-int getSalary(){
-	int salary;
-	do{
-		printf("Ingrese su sueldo por hora: ");
-		scanf("%d", &salary);
-	} while (salary<=0);
-	return salary;
-}
-int getHours(){
-	int hours;
-	do{
-		printf("Ingrese horas trabajadas en la semana: ");
-		scanf("%d", &hours);
-	}while (hours <= 0);
-	return hours;
-}
-int getTax(){
-	int tax;
-	do{
-		printf("Porcentaje de impuestos: ");
-		scanf("%d", &tax);	
-	}while (tax<=0);
-	return tax;
-}
-//Calcula el sueldo neto de acuerdo a las condiciones del problema
-int proceso(int salary, int hours, int tax){
-	int horas_extra, horas_tot, impuestos_tot, sueldoNeto;
-
-	if(hours > 40){ //condicional en caso de que el empleado haya trabajado más de 40 horas.
-		horas_extra = hours - 40;
-		horas_tot = ((salary)*(hours))+((salary)*(horas_extra)); //En caso verdadero; se paga doble.
-	}
-	else{
-		horas_tot = ((salary)*(hours)); //Caso contrario se paga normal.
-	}
-	
-	impuestos_tot = ((tax)*(horas_tot)/(100));
-	sueldoNeto = ((horas_tot) - (impuestos_tot));
-	return sueldoNeto;
-}
-//imprime el sueldo neto
-void salida(int sueldoNeto){
-	printf("SUELDO NETO: %d", sueldoNeto);
-}
-
-/*
-QA: Realizó: Jose Mendez
-Entradas: (Martin , 26, 100, 45, 10)
-Salidas: 3 positivps y 3 negativos
-Funciona Correctamente. pero no deberia aceptar numeros negativos. (corregido)
-*/
+/*#----------------------------------Datos del problema-------------------------------------
+#Escribe elprogramaque lea datos de muchos empleados de una fábrica. De cada uno se #leerá: Nombre, Edad, Sueldo por hora, Horas trabajadas en la semana  y  Porcentaje  de  #impuestos  a  pagar.    El  pseudocódigo  calculará  e imprimirá el sueldo neto semanal #de cada empleado, el cual es el sueldo ya con    los  impuestos  deducidos.  Se  debe  #considerar  que  las  horas  extra (después de 40 horas semanales se pagan al doble).
+# Roberto Carlos Llanes Montero (Equipo 'about:blank')*/
+
+
+#include <stdio.h>
+//Hago struct para almacenar todos los datos de un empleado.
+struct person{
+  char name[100];
+  int age;
+  float salary;
+  float timeWork;
+  float tax;
+};
+struct person p;
+
+//Prototipo de funciones
+void getName();
+void getAge();
+void getSalary();
+void getTimeWork();
+void getTax();
+void entrada();
+
+float proceso();
+
+void salida();
+
+int main() {
+  //Declaraci[on de variables]
+  float finale;
+  //Entrada
+  entrada();
+  //Proceso
+  finale = proceso(p.timeWork, p.salary, p.tax);
+  //Salida
+  salida(finale);
+
+  return 0;
+}
+
+//Funciones
+//Entrada de datos
+void getName(){
+  scanf("%[^\n]", p.name);
+}
+void getAge(){
+  scanf("%d", &p.age);
+}
+void getSalary(){
+  scanf("%f", &p.salary);
+}
+void getTimeWork(){
+  scanf("%f", &p.timeWork);
+}
+void getTax(){
+  scanf("%f", &p.tax);
+}
+//Creaci[on del perfil de la persona]
+void entrada(){
+  getName();
+  getAge();
+  getSalary();
+  getTimeWork();
+  getTax();
+}
+
+//Procesamiento de datos
+float proceso(timeWork, salary, tax){
+  float cuenta;
+  //Calculo del porcentaje final.
+  tax = 1 - ( tax / 100 );
+  if( timeWork > 40 ){
+    //Horas extra trabajadas
+    float extra = timeWork - 40;
+    cuenta = (( timeWork * salary ) + ( 2 * extra * salary )) * tax;
+    return cuenta;
+  }
+  else{
+    cuenta = ( timeWork * salary ) * tax; 
+    return cuenta;
+  }
+}
+
+//Salida de resultados
+void salida(result){
+  printf("%d", result);
+}
diff --git a/Unidad 3-Funciones/Ejercicio47.py b/Unidad 3-Funciones/Ejercicio47.py
new file mode 100644
index 0000000..0792dd8
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio47.py	
@@ -0,0 +1,71 @@
+#----------------------------------Datos del problema-------------------------------------
+#Escribe elprogramaque lea datos de muchos empleados de una fábrica. De cada uno se leerá: Nombre, Edad, Sueldo por hora, Horas trabajadas en la semana  y  Porcentaje  de  impuestos  a  pagar.    El  pseudocódigo  calculará  e imprimirá el sueldo neto semanal de cada empleado, el cual es el sueldo ya con    los  impuestos  deducidos.  Se  debe  considerar  que  las  horas  extra (después de 40 horas semanales se pagan al doble).
+# Roberto Carlos Llanes Montero (Equipo 'about:blank')
+
+#----------------------------------Prototipo de funciones----------------------------------
+#Python no permite la creación de prototipos debido al funcionamiento de la definición de 
+#sus funciones, de hecho, gran parte de estos conceptos estan haciendo más lento al proceso
+#de python :c
+
+#----------------------------------------Funciones------------------------------------------
+#También python no acepta poner funciones al final :c
+
+def getEmployees():
+	employees = input()
+	return employees 
+
+def getName():
+	name = input()
+	return name
+
+def getAge():
+	age = input()
+	return age
+
+def getSalary():
+	salary = input()
+	return salary
+	
+def getTimeWork():
+	timeWork = input()
+	return timeWork
+	
+def getTax():
+	tax = input()
+	return tax
+
+def process(timeWork,salary,tax):
+	#Obtiene el impuesto general
+	tax = 1-(float(tax) / 100)
+	if( int(timeWork) > 40 ):
+		#Saca las horas extra
+		extra = int(timeWork) - 40
+		#Calcula el sueldo
+		return ((float(timeWork)*float(salary))+(2*float(extra)*float(salary)))*float(tax)
+	else:
+		return (float(timeWork)*float(salary))*float(tax)	
+		
+def printOut(finale):
+	print(finale)
+
+#----------------------------------------Proceso-------------------------------------------
+def main():
+	#Obtener el numero de empleados
+	employees = getEmployees()
+
+	#Pedir los datos de todos los empleados
+	for employe in range(int(employees)):
+		#Obtener datos del empleado 
+		name = getName()
+		age = getAge()
+		salary = getSalary()
+		timeWork = getTimeWork()
+		tax = getTax()
+
+		#Proceso
+		result = process(timeWork, salary, tax)
+
+		#Imprimir resultado
+		printOut(result)
+	
+main()
diff --git a/Unidad 3-Funciones/Ejercicio48.c b/Unidad 3-Funciones/Ejercicio48.c
deleted file mode 100644
index d0a5baf..0000000
--- a/Unidad 3-Funciones/Ejercicio48.c	
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
-Autor: Eyder Concha Moreno 16/Febrero/19
-Entradas: sueldo base, antiguedad en la empresa
-Salidas: Incentivo, sueldo total y sueldo base, o error por entradas incorrectas
-
-Procedimiento general:
-1.-Preguntamos el número de años de antiguedad
-2.-Preguntamos antiguedad del empleado
-3.-Verificamos si los datos ingresados son válidos
-4.-Con su antiguedad, determinamos el porcentaje a otorgar
-5.-Definimos el incentivo con el porcentaje obtenido
-6.-Calculamos el sueldo total
-7.-Asignamos un mensaje de salida de acuerdo a lo escrito por el usuario
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-
-void entradas(float*, int*);
-int validacionValores(float, int);
-float calculoIncentivo(float, int);
-float calculoSueldoTotal(float, float);
-void salidas(int, float, float, float);
-
-int main()
-{
-    /*Entradas*/
-
-    float sueldoBase;
-    int antiguedad;
-
-    float incentivo;
-    float sueldoTotal;
-
-    int cantidadValida;
-
-    /*Procedimiento*/
-    printf("Ingresa el sueldo base y la antiguedad en la empresa respectivamente\n");
-    entradas(&sueldoBase, &antiguedad);
-
-    //Comprobamos si valores ingresados son validos
-    cantidadValida = validacionValores(sueldoBase, antiguedad);
-
-    //Determinamos incentivo y sueldo total
-    incentivo = calculoIncentivo(sueldoBase, antiguedad);
-    sueldoTotal = calculoSueldoTotal(sueldoBase, incentivo);
-
-    //Con base a la validación, determinamos la salida
-    salidas(cantidadValida, sueldoTotal, sueldoBase, incentivo);
-
-    return 0;
-}
-
-void entradas(float* sueldoBase, int* antiguedad){
-    scanf("%f", sueldoBase);
-    scanf("%d", antiguedad) !=2;
-}
-
-void salidas(int cantidadValida, float sueldoTotal, float sueldoBase, float incentivo){
-    if(cantidadValida){
-        printf("El sueldo total es de: $ %f \nEl sueldo base es de: $ %f \nEl incentivo es de: %f", sueldoTotal, sueldoBase, incentivo);
-    } else {
-        printf("Entrada invalida");
-    }
-}
-
-float calculoSueldoTotal(float sueldoBase, float incentivo){
-    float suma = sueldoBase + incentivo;
-    return suma;
-}
-
-float calculoIncentivo(float sueldoBase, int antiguedad){
-    float porcentajeIncentivo;
-    float incentivo;
-
-    // Determinamos el incentivo con base a la antiguedad
-    if(antiguedad < 1){
-      porcentajeIncentivo = 0;
-
-    } else if(antiguedad < 4){
-      porcentajeIncentivo = .01;
-
-    } else if(antiguedad < 7){
-      porcentajeIncentivo = .03;
-
-    } else if(antiguedad < 10){
-      porcentajeIncentivo = .05;
-
-    } else {
-      porcentajeIncentivo = .07;
-    }
-
-    incentivo = porcentajeIncentivo * sueldoBase;
-    return incentivo;
-}
-
-int validacionValores(float sueldoBase, int antiguedad){
-    // Se valida si las entradas leidas son validas
-    int cantidadValida = 1;
-    if(antiguedad <= 0 || sueldoBase <= 0){
-        cantidadValida = 0;
-    }
-    return cantidadValida;
-}
-/*
-Autor QA: Jimmy Nathan Ojeda Arana
-Entradas: 1000,8
-Salidas: El sueldo total es de: $ 1050.000000    El sueldo base es de: $ 1000.000000    El incentivo es de: 50.000000
-Proceso: OK
-Modularización: OK. El main no puede estar más simple.
- Función entradas: OK
- Función validacionValores: OK
- Función calculoIncentivo: OK
- Función calculoSueldoTotal: OK
- Función salidas: OK
-*/
diff --git a/Unidad 3-Funciones/Ejercicio48.js b/Unidad 3-Funciones/Ejercicio48.js
deleted file mode 100644
index 433f289..0000000
--- a/Unidad 3-Funciones/Ejercicio48.js	
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-Autor: Eyder Concha Moreno 16/Febrero/19
-Entradas: sueldo base, antiguedad en la empresa
-Salidas: Incentivo, sueldo total y sueldo base, o error por entradas incorrectas
-
-Procedimiento general:
-1.-Preguntamos el número de años de antiguedad
-2.-Preguntamos antiguedad del empleado
-3.-Verificamos si los datos ingresados son válidos
-4.-Con su antiguedad, determinamos el porcentaje a otorgar
-5.-Definimos el incentivo con el porcentaje obtenido
-6.-Calculamos el sueldo total
-7.-Asignamos un mensaje de salida de acuerdo a lo escrito por el usuario
-*/
-
-/*Entradas*/
-
-var sueldoBase;
-var antiguedad;
-
-var incentivo;
-var sueldoTotal;
-
-var cantidadValida;
-
-/*Procedimiento*/
-alert("Ingresa el sueldo base y la antiguedad en la empresa respectivamente\n");
-entradas();
-
-//Comprobamos si valores ingresados son validos
-validacionValores(sueldoBase, antiguedad);
-
-//Determinamos incentivo y sueldo total
-calculoIncentivo();
-sueldoTotal = calculoSueldoTotal();
-
-//Con base a la validación, determinamos la salida
-salidas();
-
-
-function entradas(){
-    sueldoBase = prompt('Sueldo base');
-    antiguedad = prompt('Antiguedad');
-}
-
-function salidas(){
-    // Comprobamos si la cantidad ingresada por el usuario fue válida
-    if(cantidadValida){
-        document.write(`El sueldo total es de: ${sueldoTotal} <br> El sueldo base es de: ${sueldoBase} <br> El incentivo es de: ${incentivo}`);
-    } else {
-        document.write(`Entrada valida`);
-    }
-}
-
-function calculoSueldoTotal(){
-    // Sumamos el incentivo al sueldo base
-    var suma = parseFloat(sueldoBase) + incentivo;
-    return suma;
-}
-
-function calculoIncentivo(){
-    var porcentajeIncentivo;
-
-    // Determinamos el incentivo con base a la antiguedad
-    if(antiguedad < 1){
-      porcentajeIncentivo = 0;
-
-    } else if(antiguedad < 4){
-      porcentajeIncentivo = .01;
-
-    } else if(antiguedad < 7){
-      porcentajeIncentivo = .03;
-
-    } else if(antiguedad < 10){
-      porcentajeIncentivo = .05;
-
-    } else {
-      porcentajeIncentivo = .07;
-    }
-
-    incentivo = porcentajeIncentivo * sueldoBase;
-}
-
-function validacionValores(){
-    // Se valida si las entradas leidas son validas
-    cantidadValida = 1;
-    if(antiguedad <= 0 || sueldoBase <= 0){
-        cantidadValida = 0;
-    }
-}
-/*
-Autor QA: Jimmy Nathan Ojeda Arana
-Entradas: 1000,5
-Salidas: El sueldo total es de: 1030    El sueldo base es de: 1000    El incentivo es de: 30
-Proceso: OK
-Modularización: OK
- Función entradas: OK
- Función validacionValores: OK
- Función calculoIncentivo: OK
- Función calculoSueldoTotal: OK
- Función salidas: OK
-*/
diff --git a/Unidad 3-Funciones/Ejercicio51.c b/Unidad 3-Funciones/Ejercicio51.c
deleted file mode 100644
index 340ec11..0000000
--- a/Unidad 3-Funciones/Ejercicio51.c	
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
-	Autor: Carlos Chan Gongora 16/02/2019
-	Entradas: ID, Edad y sueldo de 10 personas.
-	Salidas: El numero de personas con mas de 35 años  entre 5000 y 7500.
-	Procedimiento general: Lee los datos y luego compara si el sueldo esta en
- 	el rango de 5000 y 7500 para aumentar el valor de un contador.
-*/
-#include <stdio.h>
-
-void leerDatos(int[], int[], int[]);
-int contarMayores(int[], int[]);
-void imprimirResultados(int);
-
-int main(){
-  // Entradas
-  int id[10], edad[10], sueldo[10];
-  int mayores35 = 0;
-
-  // Procedimiento
-  leerDatos(id, edad, sueldo);
-  mayores35 = contarMayores(edad, sueldo);
-
-  // Salida
-  imprimirResultados(mayores35);
-
-  return 0;
-}
-// Lee los datos
-void leerDatos(int id[], int edad[],int sueldo[]){
-  for(int i = 0; i < 10; i++){
-    printf("Persona: %d\n", (i + 1));
-    printf("ID: ");
-    scanf("%d", &id[i]);
-    printf("Edad: ");
-    scanf("%d", &edad[i]);
-    printf("Sueldo: ");
-    scanf("%d", &sueldo[i]);
-    printf("\n");
-  }
-}
-// Recorre el array de sueldo y cuenta los que esten entre 5000 y 7500
-int contarMayores(int edad[], int sueldo[]){
-  int contador = 0;
-  for(int i = 0; i < 10; i++){
-    if(edad[i] > 35){
-      if(sueldo[i] >= 5000 && sueldo[i] <= 7500){
-        contador++;
-      }
-    }
-  }
-  return contador;
-}
-// Imprime los resultados
-void imprimirResultados(int mayores35){
-  printf("La cantidad de personas con mas de 35 anios y sueldo entre 5000 - 7500 es: %d", mayores35);
-}
-
-/*
-QA: Realizó: Jose Mendez
-Entradas: (id,35,5000)(id,64,6500)(id, 65,7500)
-Salidas: 3 personas mayores. 
-Funciona Correctamente.
-*/
diff --git a/Unidad 3-Funciones/Ejercicio51.lua b/Unidad 3-Funciones/Ejercicio51.lua
deleted file mode 100644
index f2b7368..0000000
--- a/Unidad 3-Funciones/Ejercicio51.lua	
+++ /dev/null
@@ -1,112 +0,0 @@
---[[
-  Autor: Carlos Chan Gongora 16/02/2019
-  Entradas: ID, Edad y sueldo de 10 personas.
-  Salidas: El numero de personas con mas de 35 años  entre 5000 y 7500.
-  Procedimiento general: Lee los datos y luego compara si el sueldo esta en
-  el rango de 5000 y 7500 para aumentar el valor de un contador.
-]]--
---[[ Funciones ]]--
--- Lee el id, edad y sueldo
-function leerDatos(id)
-  for i = 1, 10, 1 do
-    io.write("Persona: "..i.."\n")
-    io.write("ID: ")
-    id[i] = io.read("*n")
-    io.write("Edad: ")
-    edad[i] = io.read("*n")
-    io.write("Sueldo: ")
-    sueldo[i] = io.read("*n")
-    io.write("\n")
-  end
-end
--- Recorre el array de sueldo y cuenta los que esten entre 5000 y 7500
-function contarMayores(edad, sueldo)
-  contador = 0;
-  for i = 1, 10, 1 do
-    if edad[i] > 35 then
-      if(sueldo[i] >= 5000 and sueldo[i] <= 7500) then
-        contador = contador + 1;
-      end
-    end
-  end
-  return contador;
-end
--- Imprime los resultados
-function imprimirResultados(num)
-  io.write("La cantidad de personas mayores a 35 anios con sueldo entre 5000 - 7500 es: "..num)
-end
-
---[[ Main ]]--
--- Entrada
-id = {}
-edad = {}
-sueldo = {}
-mayores35 = 0
-
-leerDatos(id, edad, suelo)
-
--- Proceso
-mayores35 = contarMayores(edad, sueldo)
-
--- Salidas
-imprimirResultados(mayores35)
-
---[[
-  Autor: Carlos Chan Gongora 16/02/2019
-  Entradas: ID, Edad y sueldo de 10 personas.
-  Salidas: El numero de personas con mas de 35 años  entre 5000 y 7500.
-  Procedimiento general: Lee los datos y luego compara si el sueldo esta en
-  el rango de 5000 y 7500 para aumentar el valor de un contador.
-]]--
---[[ Funciones ]]--
--- Lee el id, edad y sueldo
-function leerDatos(id)
-  for i = 1, 2, 1 do
-    io.write("Persona: "..i.."\n")
-    io.write("ID: ")
-    id[i] = io.read("*n")
-    io.write("Edad: ")
-    edad[i] = io.read("*n")
-    io.write("Sueldo: ")
-    sueldo[i] = io.read("*n")
-    io.write("\n")
-  end
-end
--- Recorre el array de sueldo y cuenta los que esten entre 5000 y 7500
-function contarMayores(edad, sueldo)
-  contador = 0;
-  for i = 1, 2, 1 do
-    if edad[i] > 35 then
-      if(sueldo[i] >= 5000 and sueldo[i] <= 7500) then
-        contador = contador + 1;
-      end
-    end
-  end
-  return contador;
-end
--- Imprime los resultados
-function imprimirResultados(num)
-  print("La cantidad de personas mayores a 35 anios con sueldo entre 5000 - 7500 es: "..num)
-end
-
---[[ Main ]]--
--- Entrada
-id = {}
-edad = {}
-sueldo = {}
-mayores35 = 0
-
-leerDatos(id, edad, suelo)
-
--- Proceso
-mayores35 = contarMayores(edad, sueldo)
-
--- Salidas
-imprimirResultados(mayores35)
-
---[[
-QA: Realizó: Jose Mendez
-Entradas: (id,35,5000)(id,64,6500)(id, 65,7500)
-Salidas: 3 personas mayores. 
-Funciona Correctamente.
-]]
diff --git a/Unidad 3-Funciones/Ejercicio52.c b/Unidad 3-Funciones/Ejercicio52.c
deleted file mode 100644
index 1b2f576..0000000
--- a/Unidad 3-Funciones/Ejercicio52.c	
+++ /dev/null
@@ -1,63 +0,0 @@
-/**
- * @author: Luis Gerardo Leon Ortega | ejercicio 52
- * Entrada:  valor futuro, valor presente invertido, tasa de interés expresada como fracción decimal y número de períodos de inversión
- * Salida general:  el valor futuro de la inversión.
- * Proceso general:
- *  - se calcula F = P ( 1 + i / 100 ) n y acaba el programa cuando se escribe un 0
- */
-#include <stdio.h>
-
-void entradas(float*, float*, float*);
-void proceso(float*, float*, float*, float*);
-void salidas(float, int*);
-
-int main() {
-    float x, y, z, inversion;
-    int salida = 1;
-    while (salida){
-        /* entradas */
-        entradas(&x, &y, &z);
-        /* proceso */
-        proceso(&inversion, &x, &y, &z);
-        /* salidas */
-        salidas(inversion, &salida);
-    }
-    return 0;
-}
-/*
- * Entradas
- */
-void entradas(float* x, float* y, float* z){
-    printf("Ingresa una cantidad de dinero \n");
-    scanf("%f", x);
-    printf("Ingresa el PORCENTAJE de interes al que sera sometida tu inversion \n");
-    scanf("%f", y);
-    printf("Por cuantos meses \n");
-    scanf("%f", z);
-}
-
-/*
- * Proceso
- */
-void proceso(float* inversion, float* x, float* y, float* z){
-    *inversion = (*x)*((1 + *y)/ 100)*(*z);
-}
-
-/*
- * Salidas
- */
-void salidas(float inversion, int* salida){
-    printf("La inversion a futuro sera: %f \n", inversion);
-    printf("¿Desea continuar calculado inversiones a futuro? presione 1 para si, y 0 para no \n");
-    scanf("%i", salida);
-}
-/*
-Autor QA: Jimmy Nathan Ojeda Arana
-Entradas: 2000,10,10
-Salidas: 2200
-Proceso: OK. Se puede seguir mejor la instrucción del ejercicio (interés decimal, cerrar al leer un valor 0 como cantidad de dinero).
-Modularización: OK. El main no puede estar más simple.
- Función entradas: OK
- Función proceso: OK
- Función salidas: OK
-*/
diff --git a/Unidad 3-Funciones/Ejercicio52.js b/Unidad 3-Funciones/Ejercicio52.js
deleted file mode 100644
index 44d1eb7..0000000
--- a/Unidad 3-Funciones/Ejercicio52.js	
+++ /dev/null
@@ -1,52 +0,0 @@
-/**
- * @author: Luis Gerardo Leon Ortega | ejercicio 32
- * Entrada: valor futuro, valor presente invertido, tasa de interés expresada como fracción decimal y número de períodos de inversión
- * Salida general:  el valor futuro de la inversión.
- * Proceso general:
- * - se calcula F = P ( 1 + i / 100 ) n y acaba el programa cuando se escribe un 0
- */
-
-let x,y,z,inversion, salida = 1
-while(salida){
-  /* entradas */
-  entradas()
-  /* proceso */
-  proceso()
-  /* salidas */
-  salidas()
-}
-
-/**
- * Entradas 
- */
-function entradas(){
-  x = parseInt(prompt("Ingresa una cantidad de dinero")) 
-  y = parseInt(prompt("Ingresa el PORCENTAJE de interes al que sera sometida tu inversion"))
-  z = parseInt(prompt("Por cuantos meses"))
-}
-
-/**
- * Proceso 
- */
-function proceso(){
-  inversion = x*((1 + y)/ 100)*z
-}
-
-/**
- * Salidas
- */
-function salidas(){
-  alert(`La inversiona a futuro es ${inversion}`)
-  salida = parseInt(prompt("¿Desea continuar calculado inversiones a futuro? presione 1 para si, y 0 para no"))
-}
-/*
-Autor QA: Jimmy Nathan Ojeda Arana
-Entradas: 2000,10,10
-Salidas: 2200
-Proceso: OK. Se puede seguir mejor la instrucción del ejercicio (interés decimal, cerrar al leer un valor 0 como cantidad de dinero).
-Modularización: OK. El main no puede estar más simple.
- Función entradas: OK
- Función proceso: OK
- Función salidas: OK
- Nota: No se cambió la información del ejercicio (Dice ejercicio 32 y la instrucción del ejercicio 32). (SOLVED)
-*/
diff --git a/Unidad 3-Funciones/Ejercicio53.py b/Unidad 3-Funciones/Ejercicio53.py
new file mode 100644
index 0000000..fe8474e
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio53.py	
@@ -0,0 +1,36 @@
+#----------------------------------Datos del problema-------------------------------------
+#Ejercicio #
+# Escribe el programaque lea muchos valores de n  y que calcule la expresión
+# Roberto Carlos Llanes Montero (Equipo 'about:blank')
+
+#----------------------------------Prototipo de funciones----------------------------------
+#Python no permite la creación de prototipos debido al funcionamiento de la definición de 
+#sus funciones, de hecho, gran parte de estos conceptos estan haciendo más lento al proceso
+#de python :c
+
+#----------------------------------------Funciones------------------------------------------
+#También python no acepta poner funciones al final :c
+
+def getEne():
+	Ene = int(input())
+	return Ene 
+def proceso(n):
+	print("y = 1",end = ' ')
+	if( n == 1 ):
+		print("+ x",end = ' ')	
+	else:
+		for i in range(1,Ene+1):
+			salida(i)
+				
+def salida(n):
+	if( n > 1 ):
+		if( n % 2 == 0 ):
+			print("+ {}x^{}/{}!".format(n,n,n),end = ' ')
+		else:
+			print("- {}x^{}/{}!".format(n,n,n),end = ' ')
+
+#----------------------------------------Proceso-------------------------------------------
+#Obtener el dato de inicio
+Ene = getEne()
+#Proceso
+proceso(Ene)
diff --git a/Unidad 3-Funciones/Ejercicio6.c b/Unidad 3-Funciones/Ejercicio6.c
new file mode 100644
index 0000000..37b652f
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio6.c	
@@ -0,0 +1,32 @@
+/* Escribir un programa que reciba tres números enteros que representan dos catétos y una hipotenusa y que determine si cumple con la ecuación de pitágoras. */
+
+#include <stdio.h>
+
+// Variables Globales
+int c1,c2,h,resultado;
+
+// Entrada de los números
+void entrada() {
+  scanf("%d %d %d", &c1, &c2, &h);
+}
+
+// Comprobación 
+void proceso(){
+  if((c1*c1)+(c2*c2) == (h*h)) {
+    resultado = 1;
+  } else {
+    resultado = 0;
+  }
+}
+
+// Impresion de los resultados
+void salida(){
+  printf("%d", resultado);
+}
+
+// MAIN 
+int main() {
+  entrada();
+  proceso();
+  salida();
+}
diff --git a/Unidad 3-Funciones/Ejercicio6.py b/Unidad 3-Funciones/Ejercicio6.py
new file mode 100644
index 0000000..c2bc5be
--- /dev/null
+++ b/Unidad 3-Funciones/Ejercicio6.py	
@@ -0,0 +1,18 @@
+# Escribir un programa que reciba tres números enteros que representan dos catétos y una hipotenusa y que determine si cumple con la ecuación de pitágoras.
+
+# Variables Globales
+c1 = int(input())
+c2 = int(input())
+h = int(input())
+resultado = 0
+
+# Comprobación 
+def proceso(a,b,c):
+  if((a*a)+(b*b) == c*c):
+    return 1;
+  else:
+    return 0;
+
+# MAIN #
+resultado = proceso(c1,c2,h)
+print(resultado);
diff --git a/Unidad 3-Funciones/Ejercicio7.c b/Unidad 3-Funciones/Ejercicio7.c
deleted file mode 100644
index d224a48..0000000
--- a/Unidad 3-Funciones/Ejercicio7.c	
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-  Autor: Raul Rivadeneyra
-  Entradas: numeros positivos
-  Salidas: la adicion al numero ingresado respecto a ciertos factores
-  Proceso general: si el numero ingresado es mayor a 1000 o 3000 o 5000 aumenta cierta cantidad respectivamente
- */
-#include "stdio.h"
-
-void getNumber(float*);
-void moreThan1K(float*);
-void moreThan3K(float*);
-void moreThan5K(float*);
-
-int main() {
-  float number;
-  getNumber(&number);
-  moreThan1K(&number);
-  moreThan3K(&number);
-  moreThan5K(&number);
-
-  printf("The outcome is: %f\n", number);
-  return 0;
-}
-
-void getNumber(float *number) {
-  printf("Insert a positive number: ");
-  scanf("%f", number);
-  while (number <= 0) {
-    printf("The number isn\'t positive, try again: ");
-    scanf("%f", number);
-  }
-}
-
-void moreThan1K(float *number) {
-  if (*number > 1000){
-    *number += (*number * 0.05);
-  }
-}
-
-void moreThan3K(float *number) {
-  if (*number > 3000){
-    *number += (*number * 0.1);
-  }
-}
-
-void moreThan5K(float *number) {
-  if (*number > 5000){
-    *number += (*number * 0.05);
-  }
-}
-/*
-QA: Hector Abraham V. Cosgalla
-TODO MAL!!
-*/
diff --git a/Unidad 3-Funciones/Ejercicio7.lua b/Unidad 3-Funciones/Ejercicio7.lua
deleted file mode 100644
index d77fac0..0000000
--- a/Unidad 3-Funciones/Ejercicio7.lua	
+++ /dev/null
@@ -1,27 +0,0 @@
---[[
-  Autor: Raul Rivadeneyra
-  Entradas: numeros positivos
-  Salidas: la adicion al numero ingresado respecto a ciertos factores
-  Proceso general: si el numero ingresado es mayor a 1000 o 3000 o 5000 aumenta cierta cantidad respectivamente
-]]--
-x = io.read("*n")
-
-function addingSum()
-  if x > 1000 then
-    x = x * 1.05
-  end
-  if x > 3000 then
-    x = x * 1.1
-  end
-  if x > 5000 then
-    x = x * 1.05
-  end
-end
-addingSum()
-print(x)
---[[
-QA: Hector Abraham V. Cosgalla
-Entradas: 1050, 3050, 5050
-Salidas:37655.8875, 36564.4125, 60686677.0125
-Comentarios: Falto la documentacion!
-]]
diff --git a/Unidad 3-Funciones/Ejercicio8.c b/Unidad 3-Funciones/Ejercicio8.c
deleted file mode 100644
index 2640972..0000000
--- a/Unidad 3-Funciones/Ejercicio8.c	
+++ /dev/null
@@ -1,52 +0,0 @@
-//8. Escribir el programa para un programa que reciba 2 números y te indique si el 1er numero es múltiplo del segundo.
-//  Autor: Rodrigo Hernandez Gongora
-
-#include <stdio.h>
-int entradas(int a);
-int proceso(int x, int y);
-void salidas(int z);
-int main(){
-    int num1=0, num2=0, val1, val2, flag;
-    val1=entradas(num1);
-    val2=entradas(num2);
-    flag=proceso(val1,val2);
-    salidas(flag);
-    
-    return 0;
-}
-
-int entradas(int a){
-    printf("Introduce un numero\n");
-    scanf("%d", &a);
-    return a;
-}
-
-int proceso(int x, int y){
-    int res;
-    if ((x % y)==0) {
-        res=1;
-    }
-    else {
-        res=0;
-    }
-    return res;
-}
-void salidas(int z){
-    if (z==1) {
-        printf("El primer numero es multiplo del segundo\n");
-    }
-    else{
-        printf("No son multiplos\n");
-    }
-    return;
-}
-/*
-Autor QA: Jimmy Nathan Ojeda Arana
-Entradas: 10,2
-Salidas: "El primer numero es multiplo del segundo"
-Proceso: OK
-Modularización: OK. El main no puede estar más simple.
- Función entradas: OK
- Función proceso: OK
- Función salidas: OK
-*/
diff --git a/Unidad 3-Funciones/Ejercicio8.js b/Unidad 3-Funciones/Ejercicio8.js
deleted file mode 100644
index 89b1e45..0000000
--- a/Unidad 3-Funciones/Ejercicio8.js	
+++ /dev/null
@@ -1,46 +0,0 @@
-//8. Escribir el programa para un programa que reciba 2 números y te indique si el 1er numero es múltiplo del segundo.
-//Autor: Rodrigo Hernanadez Gongora
-var num1;
-var num2;
-
-entradas();
-proceso(num1, num2);
-
-
-function entradas(){
-	num1=prompt('Introduce el primer numero');
-	num2=prompt('Introduce el segundo numero');
-}
-
-function proceso(x,y){
-	var res;
-	if ((x%y)==0) {
-		res=1;
-	}
-	else {
-		res=0;
-	}
-	salidas(res);
-}
-
-function salidas(z){
-	if (z==1) {
-		alert("El primero es multiplo del segundo");
-	}
-	else{
-		alert("No son multiplos");
-	}
-}
-/*
-Autor QA: Jimmy Nathan Ojeda Arana
-Entradas: Vacío
-Salidas: Vacío
-Proceso: Vacío
-Modularización: Vacío
- Función lectura: Vacío
- Función ascendente: Vacío
- Función impresion: Vacío
- 
- -CORREGIDO
- PROBLEMA AL SUBIR EL EJERCICIO INICIALMENTE, SIN EMBARGO SE ASEGURO QUE FUNCIONE DE LA MISMA MANERA QUE C
-*/