Capítulo 10

EJERCICIOS DE AUTOEVALUACION

10.1 Arreglos Unidimensionales

10.2 Arreglos Bidimensionales

10.3 Cadenas

10.4 Ejercicios Varios

10.1 Arreglos Unidimensionales

/**********************Inicio del Programa*************************** Ejercicio 01: Se tiene un vector de 20 elementos de tipo entero. Genere y muestre en el vector numeros aleatorios entre el 50 y 150. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int Longitud=20; int A[Longitud], tiempo, desde, hasta, i, mayor; tiempo=time(NULL); srand(tiempo); desde=50; hasta=150; for(i=0 ; i<Longitud ; i++){ A[i]=desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); } printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 02: Se tiene un vector de N elementos de tipo entero con numeros al azar. Calcule y muestre la suma y promedio del vector. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, S; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo);

desde=2; hasta=19; S=0; for(i=0 ; i<N ; i++){ A[i]=desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); S+=A[i]; } printf("\n\nSuma del Vector: %d", S); printf("\nPromedio del Vector: %8.2lf\n\n", S/double(N)); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 03: Se tiene un vector de N elementos de tipo entero con numeros al azar. Muestre el Mayor y Menor elemento con sus respectivas posiciones dentro del vector. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, mayor, menor, posmay, posmen; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; mayor=desde; menor=hasta; posmay=posmen=0; for(i=0 ; i<N ; i++){ A[i]=desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); if(A[i] > mayor){ mayor=A[i]; posmay=i + 1; } if(A[i] < menor){

menor=A[i]; posmen=i + 1; } } printf("\n\nMayor elemento del Vector: %d posicion: %d", mayor, posmay); printf("\nMenor elemento del Vector: %d posicion: %d\n\n", menor, posmen); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 04: Se tiene un vector de N elementos de tipo entero con numeros al azar. Diga cuantos numeros pares e impares hay. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, cp, ci; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; cp=ci=0; for(i=0 ; i<N ; i++){ A[i]=desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); if(A[i] % 2 ==0)cp++; else ci++; } printf("\n\nCantidad de elementos Pares: %d", cp); printf("\nantidad de elementos Impares: %d\n\n", ci); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa***************************

Ejercicio 05: Se tiene un vector de n elementos, muestre los elementos múltiplos de su índice. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; for(i=0 ; i<N ; i++){ A[i]=desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); } printf("\n\n"); //i=1, para evitar la division sobre cero for(i=1 ; i<N ; i++) if(A[i] % i ==0) printf("\nA[%d] = %d es multiplo de %d", i, A[i], i); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 06: Se tiene un vector de 50 elementos con numeros al azar se desea llevar dicho contenido a otros 2 vectores uno con todos los múltiplos de 5 y el otro con los números no múltiplos de 5. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], M5[LongitudMax], NM5[LongitudMax], tiempo, desde, hasta, i;

int N, c5, cn5; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; c5=cn5=0; for(i=0 ; i<N ; i++){ A[i]=desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); if(A[i] % 5 ==0){ M5[c5]=A[i]; c5++; }else{ NM5[cn5]=A[i]; cn5++; } } printf("\n\nMultiplos de 5\n\n"); for(i=0 ; i<c5 ; i++) printf("%d\t ", M5[i]); printf("\n\nNO Multiplos de 5\n\n"); for(i=0 ; i<cn5 ; i++) printf("%d\t ", NM5[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 07:Se tiene un vector con n elementoscon numeros al azar, realice el proceso de invertir el contenido de dicho vector. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, aux; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin);

printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; for(i=0 ; i<N ; i++){ A[i]=desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); } printf("\n\nInvirtiendo contenido...\n\n"); for(i=0 ; i<N/2 ; i++) { aux=A[i]; A[i]=A[N-i-1]; A[N-i-1]=aux; } printf("Vector Invertido\n\n"); for(i=0 ; i<N ; i++) printf("%d\t",A[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 08: Se tiene un vector de N elementos de tipo entero con numeros al azar. Diga si el promedio de los numeros pares es mayor al promedio de los numeros impares hay. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, cp, ci, sp, si; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19;

cp=ci=sp=si=0; for(i=0 ; i<N ; i++){ A[i]=desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); if(A[i]%2==0){ cp++; sp+=A[i]; }else{ ci++; si+=A[i]; } } if(sp/double(cp) > si/double(ci)) printf("\n\nEl promedio de los Pares es mayor"); else printf("\n\nEl promedio de los Impares es mayor"); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 09: Se tiene un vector de N elementos de tipo entero con numeros al azar. Realice la insercion de un elemento por posicion. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, nro_insertar, posicion; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; for(i=0 ; i<N ; i++){ A[i]=desde + rand() % (1 + hasta - desde); printf("%4d", A[i]); } printf("\n\nIngrese nro a insertar.."); scanf("%d",&nro_insertar); printf("\nIngrese nro de posicion a insertar.."); scanf("%d",&posicion);

for(i = N-1 ; i>=posicion-1 ; i--) A[i+1] = A[i]; A[posicion-1] = nro_insertar; N++; printf("\n\nEl nro ha sido insertado\n\n"); for(i=0 ; i<N ; i++) printf("%4d", A[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 10: Se tiene un vector de N elementos de tipo entero con numeros al azar. Muestre la cantidad de digitos pares e impares que existe en el vector. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, cdp, cdi, nro, u; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; for(i=0 ; i<N ; i++){ A[i] = desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); } cdp=cdi=0; for(i=0;i<N;i++){ nro=A[i]; do{ u=nro%10; nro=nro/10; if(u%2==0) cdp++; else cdi++; }while(nro>0); } printf("\n\nCantidad de digitos Pares es..%d", cdp); printf("\nCantidad de digitos Impares es..%d", cdi); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 12: Se tiene un vector de N elementos de tipo entero con numeros al azar. Se pide realizar el ordenamiento burbuja. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, j, nro, aux; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; for(i=0 ; i<N ; i++){ A[i] = desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); } //ORDENAMIENTO BURBUJA(Ascendente) for(i=0 ; i<N-1 ; i++) for(j=i+1 ; j<N ; j++) if(A[i] > A[j]){ aux=A[i]; A[i]=A[j]; A[j]=aux; } printf("\nVector Ordenado Ascendente..\n\n"); for(i=0;i<N;i++) printf("%d\t", A[i]); //ORDENAMIENTO BURBUJA(Descendente) for(i=0 ; i<N-1 ; i++) for(j=i+1 ; j<N ; j++) if(A[i] < A[j]){ aux = A[i]; A[i]= A[j]; A[j]= aux; } printf("\nVector Ordenado..Descendente..\n\n"); for(i=0;i<N;i++) printf("%d\t", A[i]); printf("\n\n"); system("PAUSE");

} /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 12: Se tiene un vector de N elementos de tipo entero con numeros al azar. Se pide realizar realizar la insercion ordenada de un elemento. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, j, nro, aux; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; for(i=0 ; i<N ; i++){ A[i] = desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); } printf("\n\nIngrese nro a insertar..");scanf("%d",&nro); //ORDENAMIENTO BURBUJA(Ascendente) for(i=0 ; i<N-1 ; i++) for(j=i+1 ; j<N ; j++) if(A[i] > A[j]){ aux=A[i]; A[i]=A[j]; A[j]=aux; } for(i=0 ; i < N && A[i] < nro ; i++); for(j=N-1 ; j>=i ; j--) A[j+1] = A[j]; A[j+1]=nro;

N++; printf("\n\n\n"); for(i=0 ; i<N ; i++) printf("%d\t", A[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 13: Se tiene un vector de N elementos de tipo entero con numeros al azar. Se pide realizar realizar la eliminacion de elementos por valor. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, j, k, nro, aux; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; for(i=0 ; i<N ; i++){ A[i] = desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); } printf("\n\nIngrese nro a eliminar.."); scanf("%d",&nro); fflush(stdin); for(i=0 ; i<N ; i++) if(nro==A[i]){ for(j=i+1 ; j<N ; j++) A[j-1]=A[j]; N--; i--; printf("\nHa sido Eliminado.."); //Descomentar break; si solo se quiere eliminar un solo elemento //break; } printf("\n\n\n");

for(i=0 ; i<N ; i++) printf("%d\t", A[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 14: Se tiene un vector de N elementos de tipo entero con numeros al azar. Se pide realizar la eliminacion de elementos repetidos. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, j, k, nro, aux; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; for(i=0 ; i<N ; i++){ A[i] = desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); } //Ordenamiento Burbuja, solo para efecto de visualizacion for(i=0 ; i<N-1 ; i++) for(j=i+1 ; j<N ; j++) if(A[i] > A[j]){ aux=A[i]; A[i]=A[j]; A[j]=aux; } printf("\n\nVector Ordenado\n\n"); for(i=0 ; i<N ; i++) printf("%d\t", A[i]); printf("\n\n"); //Eliminacion for(i=0 ; i<N-1 ; i++)

for(j=i+1 ; j<N ; j++) if(A[i]==A[j]){ for(k=j+1;k<N;k++) A[k-1]=A[k]; N--; j--; printf("\nEliminado %d", A[i]); } printf("\n\n\nVector sin elementos repetidos\n\n\n"); for(i=0 ; i<N ; i++) printf("%d\t", A[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 15: Se tiene un vector de N elementos de tipo entero con numeros al azar. Se pide realizar la eliminacion de elementos por posicion. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, j, posicion; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; for(i=0 ; i<N ; i++){ A[i] = desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); } printf("\n\nIngrese # de posicion a Eliminar.."); scanf("%d",&posicion); fflush(stdin); for(i=0 ; i<N ; i++) if(i == posicion-1){ for(j=i+1 ; j<N ; j++) A[j-1] = A[j]; N--; printf("Ha sido Eliminado!.."); } printf("\n\n\n"); for(i=0 ; i<N ; i++) printf("%d\t", A[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa***************************

Ejercicio 16: Se tiene un vector de N elementos de tipo entero con numeros al azar. Se pide realizar la generacion ordenada de elementos. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, j, k, nro; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; for(i=0 ; i<N ; i++){ nro = desde + rand() % (1 + hasta - desde); //Modificar el for para ordenar descendente //for(j=0 ; j<i && A[j] > nro ; j++); for(j=0 ; j<i && A[j] < nro ; j++); for(k=i-1 ; k>=j ; k--) A[k+1]=A[k]; A[k+1]=nro; } for(i=0 ; i<N ; i++) printf("%d\t", A[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 17: Se tiene un vector de N elementos de tipo entero con numeros al azar. Se pide realizar la generacion de elementos sin repeticion. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h"

void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, j, k, nro; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; i=0; do{ nro = desde + rand() % (1 + hasta - desde); for(j=0 ; j<i && A[j]!=nro ; j++); if(A[j]!=nro){ for(k=i-1 ; k>=j ; k--) A[k+1]=A[k]; A[k+1]=nro; i++; } }while(i<N); for(i=0 ; i<N ; i++) printf("%d\t", A[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 18: Aplicar la teoría de vectores paralelos, realice lo siguiente: X[0] + Y[9] = Z[0] X[1] + Y[8] = Z[1] X[2] + Y[7] = Z[2] . . . . . . X[9] + Y[0] = Z[9] *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h"

void main(){ const int LongitudMax = 50; int A[LongitudMax], B[LongitudMax], C[LongitudMax], tiempo, desde, hasta, i; int N, j, k, nro; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); desde=2; hasta=19; for(i=0;i<N;i++){ A[i]=desde + rand() % (1 + hasta - desde); B[i]=desde + rand() % (1 + hasta - desde); } for(i=0;i<N;i++) C[i]= A[i] + B[N-i-1]; for(i=0;i<N;i++) printf("\n%d\t+\t%d\t=\t%d\t", A[i], B[i], C[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 19: Se tiene un vector de N elementos de tipo entero con numeros al azar. Se pide realizar un programa para determinar si un vector esta ordenado o no. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax = 50; int A[LongitudMax], tiempo, desde, hasta, i; int N, j, k, nro; printf("\nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo);

desde=2; hasta=19; for(i=0;i<N;i++){ A[i]=desde + rand() % (1 + hasta - desde); printf("%d\t", A[i]); } for(i=0 ; i<N-1 && A[i]<=A[i+1] ; i++); if(i == N-1){ printf("\nVector Ordenado Ascendentemente"); printf("\n\n"); system("PAUSE"); exit(0); } for(i=0 ; i<N-1 && A[i]>=A[i+1] ; i++); if(i==N-1){ printf("\nVector Ordenado Descendentemente"); printf("\n\n"); system("PAUSE"); exit(0); } printf("\nVector Desordenado"); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 20: Se dice que en un salon de N alumnos de un colegio, se encontraban en una incertidumbre porque no sabian quien era el encargado que tenia que ir a hablar con el director para pedir la autorizacion para la fiesta de promocion. No obstante contaban con dos dados y decidieron ponerlo al azar, entonces los alumnos se colocaron en un circulo en orden alfabetico a jugar para seleccionar al alumno que tenia la dificil mision. El juego consiste en seleccionar al azar el alumno que empieza, el lanzaba los dados y el resultado era las posiciones que se tenia que avanzar incluyendose el mismo hacia el lado izquierdo el alumno es deacartado pero antes de salir de su posicion tira los dados, el juego acaba cuando queda un solo alumno. *********************************************************************/ #include <iostream> using namespace std;

#include "stdlib.h" #include "time.h" void main(){ const int LongitudMax=50; int N, salvado, turno, cg, c, i, desde, hasta; int a[LongitudMax], tiempo; printf("\nIngrese numero de alumnos: "); scanf("%d", &N); fflush(stdin); for(i=0;i<N;i++) a[i]=0; tiempo=time(NULL); srand(tiempo); printf("\n"); cg=0; salvado=0; desde=1; hasta=6; for(cg=1 ; cg<=N-1 ; cg++){ for(i=0 ; i<N ; i++) if(a[i]!=1) printf("%d\t", i+1); turno = desde + rand() % (1 + hasta - desde); printf("\n\rEl alumno %d saco con el dado %d", salvado + 1, turno); c=0; do{ c++; salvado++; if(salvado > N-1) salvado=0; if(a[salvado]== 1 ) c--; }while(c < turno); a[salvado]=1; printf("\t\t\tSe salvo el alumno %d\n\n", salvado + 1); getchar(); } for(i=0 ; i<N ; i++){ if(a[i]!=0)continue; printf("\n\n\rEl alumno %d y tiene que ir a hablar con el director\n\n", i+1); } system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 21: Mostrar la cantidad de veces que se repite los numeros entre (a-b) en el vector. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int LongitudMax=50; int a[LongitudMax], N, i, j, c, tiempo, desde, hasta; printf("\n\rIngrese cantidad de # que tendra el vector..."); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese numero minimo de los elementos..."); scanf("%d", &desde); fflush(stdin); printf("\n\rIngrese numero maximo de los elementos..."); scanf("%d", &hasta); fflush(stdin); printf("\n\n"); tiempo=time(NULL); srand(tiempo); for(i=0;i<N;i++){ a[i]=desde + rand() % (1 + hasta - desde); printf("%d\t",a[i]); } for(i=desde;i<=hasta;i++){ c=0; for(j=0;j<N;j++){ if(a[j]!=i) continue; c++; } if(c > 0) printf("\n\r%d Se repite...%d veces", i, c); } printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

10.2 Arreglos Bidimensionales

/**********************Inicio del Programa***************************

Ejercicio 1: Se tiene una matriz de orden N*M de tipo entero, se pide generar numeros aleatorios entre 1 y 16 en la matriz. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N, M; int tiempo, desde, hasta, fila, columna; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese # de columnas de la matriz: "); scanf("%d", &M); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=16; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<M ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 2: Se tiene una matriz de orden N*M de tipo entero con numeros al azar, se pide encontrar el mayor y menor elemento de toda la matriz. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N, M; int tiempo, desde, hasta, fila, columna; int Mayor, Menor; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese # de columnas de la matriz: "); scanf("%d", &M); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=16; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<M ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } Mayor=desde; Menor=hasta; for(fila=0 ; fila<N ; fila++) for(columna=0 ; columna<M ; columna++){ if(A[fila][columna] > Mayor) Mayor = A[fila][columna]; if(A[fila][columna] < Menor) Menor = A[fila][columna]; } printf("\n\n\nEl Mayor elemento: %d", Mayor); printf("\nEl Menor elemento: %d\n\n", Menor); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 3: Se tiene una matriz de orden N*M de tipo entero con numeros al azar, se pide encontrar el mayor y menor elemento por fila y por columna.

*********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N, M; int tiempo, desde, hasta, fila, columna; int Mayor, Menor; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese # de columnas de la matriz: "); scanf("%d", &M); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=16; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<M ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } printf("\n\n\nEl Mayor y Menor elemento por filas...\n\n"); for(fila=0 ; fila<N ; fila++){ Mayor=desde; Menor=hasta; for(columna=0 ; columna<M ; columna++){ if(A[fila][columna] > Mayor) Mayor = A[fila][columna]; if(A[fila][columna] < Menor) Menor = A[fila][columna]; } printf("\nFila: %d -> Mayor: %d\t Menor: %d", fila + 1, Mayor, Menor); } printf("\n\n\nEl Mayor y Menor elemento por Columnas...\n\n"); for(columna=0 ; columna<M ; columna++){ Mayor=desde; Menor=hasta; for(fila=0 ; fila<N ; fila++){ if(A[fila][columna] > Mayor) Mayor = A[fila][columna]; if(A[fila][columna] < Menor) Menor = A[fila][columna]; } printf("\nColumna: %d -> Mayor: %d\t Menor: %d", columna + 1, Mayor, Menor); } printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 4: Se tiene una matriz de orden N*M de tipo entero con numeros al azar, se pide encontrar el promedio de la matriz. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N, M; int tiempo, desde, hasta, fila, columna; int S; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese # de columnas de la matriz: "); scanf("%d", &M); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=16; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<M ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } S=0; for(fila=0 ; fila<N ; fila++) for(columna=0 ; columna<M ; columna++) S+= A[fila][columna]; printf("\n\nEl Promedio de la Matriz: %8.2lf\n\n", double(S) / (N*M) ); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 5: Se tiene una matriz de orden N*M de tipo entero con numeros al azar, se pide encontrar la suma de los elementos de la periferie de la matriz. *********************************************************************/

#include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N, M; int tiempo, desde, hasta, fila, columna; int S; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese # de columnas de la matriz: "); scanf("%d", &M); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=5; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<M ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } S=0; for(fila=0 ; fila<N ; fila++){ S+= A[fila][0]; S+= A[fila][M-1]; } for(columna=1 ; columna<M-1 ; columna++){ S+= A[0][columna]; S+= A[N-1][columna]; } printf("\n\nLa Suma de la periferie de la Matriz: %d\n\n", S ); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 6: Se tiene una matriz de orden N*M de tipo entero con numeros al azar, se pide encontrar la suma de los elementos que no pertenecen la periferie de la matriz. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h"

void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N, M; int tiempo, desde, hasta, fila, columna; int S; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese # de columnas de la matriz: "); scanf("%d", &M); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=5; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<M ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } S=0; for(fila=1 ; fila<N-1 ; fila++) for(columna=1 ; columna<M-1 ; columna++) S+= A[fila][columna]; printf("\n\nLa Suma de la No periferie de la Matriz: %d\n\n", S ); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 7: Se tiene una matriz cuadrada de orden N de tipo entero con numeros al azar, Mostrar la suma de los elementos de la diagonal principal y la suma de la diagonal secundaria. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N, M; int tiempo, desde, hasta, fila, columna; int SP, SS; printf("\n\rIngrese orden de la matriz: "); scanf("%d", &N); fflush(stdin);

tiempo=time(NULL); srand(tiempo); desde=1; hasta=5; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<N ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } SP=SS=0; for(fila=0 ; fila<N ; fila++){ SP+= A[fila][fila]; SS+= A[fila][N-fila-1]; } printf("\n\nLa Suma de la diagonal Principal: %d", SP ); printf("\nLa Suma de la diagonal Secundaria: %d\n\n", SS ); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 8: Se tiene una matriz de orden N*M de tipo entero con numeros al azar, se pide realizar el concepto de matriz transpuesta. *********************************************************************/ /* ANALISIS: Matriz transpuesta es transponer los elementos de las filas a las columnas y viceversa. */ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], B[OrdenMax][OrdenMax], N, M; int tiempo, desde, hasta, fila, columna; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese # de columnas de la matriz: "); scanf("%d", &M); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=5; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<M ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } printf("\n\nMatriz Transpuesta...\n\n"); for(fila=0 ; fila<M ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<N ; columna++){ B[fila][columna] = A[columna][fila]; printf("\t%d", B[fila][columna]); } } printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 9: Se tiene una matriz cuadrada de orden N de tipo entero con numeros al azar, se pide realizar la suma de la matriz triangular superior. *********************************************************************/ /* ANALISIS: Matriz triangular superior son los elementos por encima de la diagonal principal inclusive. Ejm: Matriz 2 3 4 1 3 2 3 2 4 Matriz triangular superior: 1 3 4 3 2 4 */ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N; int tiempo, desde, hasta, fila, columna; int S; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=5; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<N ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } S=0; for(fila=0 ; fila<N ; fila++) for(columna=fila ; columna<N ; columna++) S+=A[fila][columna]; printf("\n\nSumatoria de la Matriz Triangular Superior %d\n\n", S); system("PAUSE"); }

/***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 10: Se tiene una matriz cuadrada de orden N de tipo entero con numeros al azar, se pide realizar la suma de la matriz triangular inferior. *********************************************************************/ /* ANALISIS: Matriz triangular inferior son los elementos por debajo de la diagonal principal inclusive. Ejm: Matriz 2 3 4 1 3 2 3 2 4 Matriz triangular inferior: 2 1 3 3 2 4 */ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N; int tiempo, desde, hasta, fila, columna; int S; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=5; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<N ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } S=0;

for(columna=0 ; columna<N ; columna++) for(fila=columna ; fila<N ; fila++) S+=A[fila][columna]; printf("\n\nSumatoria de la Matriz Triangular Inferior %d\n\n", S); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 11: Se tiene una matriz cuadrada de orden N de tipo entero con numeros al azar, se pide realizar la suma de los elementos que no pertencen a la matriz triangular superior. *********************************************************************/ /* ANALISIS: No Matriz triangular superior son los elementos por debajo de la diagonal principal. Ejm: Matriz 2 3 4 1 3 2 3 2 4 No Matriz triangular superior: 1 3 2 */ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N; int tiempo, desde, hasta, fila, columna; int S; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=5; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<N ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); }

} S=0; for(columna=0 ; columna<N-1 ; columna++) for(fila=columna+1 ; fila<N ; fila++) S+=A[fila][columna]; printf("\n\nSumatoria de la No Matriz Triangular Superior %d\n\n", S); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 12: Se tiene una matriz cuadrada de orden N de tipo entero con numeros al azar, se pide realizar la suma de los elementos que no pertencen a las diagonales. *********************************************************************/ /* ANALISIS: No diagonales son los elementos que no se encuentran en la diagonal principal y la secundaria. Ejm: Matriz 2 3 4 1 3 2 3 2 4 No diagonales: 3 1 2 2 */ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N; int tiempo, desde, hasta, fila, columna; int S; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); tiempo=time(NULL); srand(tiempo);

desde=1; hasta=5; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<N ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } S=0; for(fila=0 ; fila<N ; fila++) for(columna=0 ; columna<N ; columna++) if(fila!=columna && fila!= N-columna-1) S+=A[fila][columna]; printf("\n\nSumatoria de la No diagonales %d\n\n", S); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 13: Se tiene una matriz cuadrada de orden N de tipo entero con numeros al azar, se pide intercambiar el contenido de sus diagonales. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N; int tiempo, desde, hasta, fila, columna; int aux; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=5; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<N ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } for(fila=0;fila<N;fila++){ aux=A[fila][fila]; A[fila][fila]=A[fila][N-fila-1]; A[fila][N-fila-1]=aux; } printf("\n\nDiagonales Intercambiadas\n\n"); for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<N ; columna++) printf("\t%d", A[fila][columna]); } printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 14: Se tiene una matriz orden N*M de tipo entero con numeros al azar, se pide invertir el contenido de sus columnas.

*********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N, M; int tiempo, desde, hasta, fila, columna; int aux; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese # de columnas de la matriz: "); scanf("%d", &M); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=5; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<M ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } for(fila=0 ; fila<N/2 ; fila++) for(columna=0 ; columna<M ; columna++){ aux = A[fila][columna]; A[fila][columna] = A[N-fila-1][columna]; A[N-fila-1][columna] = aux; } printf("\n\nColumnas Invertidas\n\n"); for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<M ; columna++) printf("\t%d", A[fila][columna]); } printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 15: Se tiene una matriz orden N*M de tipo entero con numeros al azar, se pide mostrar el promedio de los elementos pares e impares siempre y cuando la suma de sus indices sea par e impar respectivamente.

*********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], N, M; int tiempo, desde, hasta, fila, columna; int sp, si, cp, ci; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese # de columnas de la matriz: "); scanf("%d", &M); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=5; for(fila=0 ; fila<N ; fila++){ printf("\n\n\t"); for(columna=0 ; columna<M ; columna++){ A[fila][columna] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[fila][columna]); } } sp=cp=si=ci=0; for(fila=0;fila<N;fila++) for(columna=0;columna<M;columna++) if((fila+columna)%2==0 && A[fila][columna]%2==0){ sp+=A[fila][columna]; cp++; } else{ si+=A[fila][columna]; ci++; } printf("\n\nEl promedio de los pares es...%8.1lf",sp/double(cp)); printf("\nEl promedio de los impares es...%8.1lf\n\n",si/double(ci)); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 16: Se tiene una matriz de orden N*M y otra de orden M*Q ambos de tipo entero con numeros al azar, se pide realizar el concepto de Producto de Matrices. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h"

#include "time.h" void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax], B[OrdenMax][OrdenMax],C[OrdenMax][OrdenMax], N, M, Q; int tiempo, desde, hasta, filaA, columnaA, filaB, columnaB ; int S; printf("\n\rIngrese N de filas de la matriz 1: "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese M columnas de la matriz 1: "); scanf("%d", &M); fflush(stdin); printf("\n\rIngrese Q columnas de la matriz 2: "); scanf("%d", &Q); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=5; printf("\n\n Matriz 1 N*M\n\n"); for(filaA=0 ; filaA<N ; filaA++){ printf("\n\t"); for(columnaA=0 ; columnaA<M ; columnaA++){ A[filaA][columnaA] = desde + rand() % (1 + hasta - desde); printf("\t%d", A[filaA][columnaA]); } } printf("\n\n Matriz 2 M*Q\n\n"); for(filaB=0 ; filaB<M ; filaB++){ printf("\n\t"); for(columnaB=0 ; columnaB<Q ; columnaB++){ B[filaB][columnaB] = desde + rand() % (1 + hasta - desde); printf("\t%d", B[filaB][columnaB]); } } printf("\n\n Matriz Resultado 3 N*Q\n\n"); for(filaA=0 ; filaA<N ; filaA++){ printf("\n\t"); for(columnaB=0 ; columnaB<Q ; columnaB++){ S=0; for(columnaA=0 ; columnaA<M ; columnaA++) S+=A[filaA][columnaA] * B[columnaA][columnaB]; C[filaA][columnaB]=S; printf("\t%d", C[filaA][columnaB]); } } printf("\n\n \n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 17: Se tiene una matriz cuadrada de orden N tipo entero, se pide realizar el concepto del Cuadrado Magico. *********************************************************************/ #include <iostream> using namespace std; void main(){ const int OrdenMax = 10; int A[OrdenMax][OrdenMax],N; int fila, columna, c, i ; printf("\n\rIngrese orden N de la matriz (Impar): "); scanf("%d", &N); fflush(stdin); fila=0; c=N/2; for(i=1;i<=N*N;i++){ A[fila][c]=i; if(i%N==0)fila++; else{ if(fila==0) fila=N-1; else fila--; if(c==N-1) c=0; else c++; } } for(fila=0;fila<N;fila++){ printf("\n\n"); for(c=0;c<N;c++) printf("\t%d",A[fila][c]); } printf("\n\n \n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

10.3 Cadenas

/**********************Inicio del Programa*************************** Ejercicio 1: Ingrese una cadena de caracteres por teclado, desarrolle la simulacion de la funcion longitud. *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char cadena[LongitudMax]; int L; printf("\n\rIngrese cadena: "); gets(cadena); fflush(stdin); for(L=0 ; cadena[L]!='\0' ; L++); printf("\n\nLa longitud es %d\n\n", L); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 2: Ingrese una cadena de caracteres por teclado, desarrolle la simulacion de la funcion extraer. *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char cadena[LongitudMax], Resultado[LongitudMax]; int i, inicio, fin, nrocar, c; printf("\n\rIngrese Cadena: "); gets(cadena); fflush(stdin); printf("\n\rPosicion de Inicio a Extraer: "); scanf("%d", &inicio); fflush(stdin); printf("\n\rNumero de caracteres a Extraer: "); scanf("%d", &nrocar); fflush(stdin); c=0; fin=(inicio-1) + nrocar; for(i=inicio-1 ; i < fin ; i++){ Resultado[c]=cadena[i]; c++; } Resultado[c]='\0'; printf("\n\nLa cadena extraida es %s\n\n", Resultado);

system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 3: Ingrese una cadena de caracteres por teclado, desarrolle la simulacion de la funcion izquierda. *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char cadena[LongitudMax], Resultado[LongitudMax]; int i, nrocar, c; printf("\n\rIngrese Cadena: "); gets(cadena); fflush(stdin); printf("\n\rNumero de caracteres a Extraer: "); scanf("%d", &nrocar); fflush(stdin); c=0; for(i=0 ; i<nrocar; i++){ Resultado[c]=cadena[i]; c++; } Resultado[c]='\0'; printf("\n\nLa cadena extraida es %s\n\n", Resultado); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 4: Ingrese una cadena de caracteres por teclado, desarrolle la simulacion de la funcion derecha. *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char cadena[LongitudMax], Resultado[LongitudMax]; int i, nrocar, c, L; printf("\n\rIngrese Cadena: "); gets(cadena); fflush(stdin); printf("\n\rNumero de caracteres a Extraer: "); scanf("%d", &nrocar);

fflush(stdin); L=strlen(cadena); c=0; for(i=L-nrocar ; cadena[i]!='\0' ; i++){ Resultado[c]=cadena[i]; c++; } Resultado[c]='\0'; printf("\n\nLa cadena extraida es %s\n\n", Resultado); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 5: Ingrese una cadena de caracteres por teclado, desarrolle la simulacion de la funcion concatenar. *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char cadena1[LongitudMax], cadena2[LongitudMax], Resultado[LongitudMax]; int i, c, L; printf("\n\rIngrese Cadena 1: "); gets(cadena1); fflush(stdin); printf("\n\rIngrese Cadena 2: "); gets(cadena2); fflush(stdin); L=strlen(cadena1); c=0; for(i=0 ; i<L ; i++){ Resultado[c]=cadena1[i]; c++; } L=strlen(cadena2); for(i=0 ; i<L ; i++){ Resultado[c]=cadena2[i]; c++; } Resultado[c]='\0'; printf("\n\nLa cadena resultado es:\n\n%s\n\n", Resultado); system("PAUSE"); }

/***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 6: Ingrese una cadena de caracteres por teclado, desarrolle la simulacion de la funcion comparar. *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char cadena1[LongitudMax], cadena2[LongitudMax]; int i, L1, L2; printf("\n\rIngrese Cadena: "); gets(cadena1); fflush(stdin); printf("\n\rIngrese Cadena: "); gets(cadena2); fflush(stdin); L1=strlen(cadena1); L2=strlen(cadena2); for(i=0 ; cadena1[i]!='\0' && cadena1[i]==cadena2[i] ; i++); if(i==L1 && i==L2) printf("\n\nLa cadena son iguales\n\n"); else printf("\n\nLa cadena son distintas\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 7: Ingrese una cadena de caracteres por teclado, desarrolle la simulacion de la funcion ascii y chr. *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char caracter; int N; printf("\n\rIngrese caracter: "); caracter=getchar(); fflush(stdin); printf("\n\rIngrese numero: "); scanf("%d",&N); fflush(stdin);

printf("\n\nCodigo Ascii de caracter: %d", int(caracter)); printf("\nCaracter de Numero: %c\n\n", char(N)); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 8: Ingrese una cadena de caracteres por teclado, desarrolle la simulacion de la funcion mayuscula y minuscula. *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char cadena[LongitudMax], Resultado1[LongitudMax], Resultado2[LongitudMax]; int i, L; printf("\n\rIngrese Cadena: "); gets(cadena); fflush(stdin); L=strlen(cadena); for(i=0 ; i<L ; i++){ //Hacia Mayusculas if(cadena[i]>='a' && cadena[i]<='z') Resultado1[i]=char(int(cadena[i]) - 32); else Resultado1[i]=cadena[i]; //Hacia Minusculas if(cadena[i]>='A' && cadena[i]<='Z') Resultado2[i]=char(int(cadena[i]) + 32); else Resultado2[i]=cadena[i]; } Resultado1[L]='\0'; Resultado2[L]='\0'; printf("\n\nLa cadena mayuscula es: %s", Resultado1); printf("\nLa cadena minuscula es: %s\n\n", Resultado2); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 9: Ingrese una cadena de caracteres por teclado, muestrelo de la siguiente forma: Palabra=> WORD Salida: W O R D *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char cadena[LongitudMax]; int i, L; printf("\n\rIngrese Cadena: "); gets(cadena); fflush(stdin); L=strlen(cadena); for(i=0 ; i<L ; i++) printf("\n\t%c", cadena[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 10: Ingrese una cadena de caracteres por teclado, muestrelo de la siguiente forma: Palabra=> EXCEL Salida: E EX EXC EXCE EXCEL *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char cadena[LongitudMax]; int i, j, L;

printf("\n\rIngrese Cadena: "); gets(cadena); fflush(stdin); L=strlen(cadena); for(i=0 ; i<L ; i++){ printf("\n\t"); for(j=0 ; j<=i ; j++) printf("%c", cadena[j]); } printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 11: Ingrese una cadena de caracteres por teclado, muestrelo de la siguiente forma: Palabra=> EXCEL Salida: E XX CCC EEEE LLLLL *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char cadena[LongitudMax]; int i, j, L; printf("\n\rIngrese Cadena: "); gets(cadena); fflush(stdin); L=strlen(cadena); for(i=0 ; i<L ; i++){ printf("\n\t"); for(j=0 ; j<=i ; j++) printf("%c", cadena[i]); } printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 12: Ingrese una cadena de caracteres por teclado, muestrelo de la siguiente forma: Palabra=> HOLA Salida: HHHH OOO LL A *********************************************************************/ #include <iostream> using namespace std; void main(){ const int LongitudMax = 100; char cadena[LongitudMax]; int i, j, L; printf("\n\rIngrese Cadena: "); gets(cadena); fflush(stdin); L=strlen(cadena); for(i=L-1 ; i>=0 ; i--){ printf("\n\t"); for(j=0 ; j<=i ; j++) printf("%c", cadena[L-i-1]); } printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 13: Ingrese una cadena de caracteres por teclado, realice una funcion que elimine el primer y ultimo caracter de cada palabra. *********************************************************************/ #include <iostream> using namespace std; //Funcion para eliminar el primer y ultimo caracter de cada palabra char *elimina(char cad[]){ int i,j,k; i=strlen(cad); //i-1 para que no considere al ultimo caracter DE LA ULTIMA PALABRA for(j=0 ; j<i-1 ; j++) if(j==0){ //j==0 para que elimine al primer caracter

for(k=j+1 ; k<i ; k++) cad[k-1]=cad[k]; k--; i--; }else if(cad[j]==' '){ for(k=j ; k<i ; k++) //elimina el caracter anterior al espacio cad[k-1]=cad[k]; for(k=j+1 ; k<i ; k++) //elimina el caracter posterior al espacio cad[k-1]=cad[k]; k-=2; i-=2; } cad[j]='\0'; return(cad); } //Procedimiento Principal void main(){ const int LongitudMax = 100; char cadena[LongitudMax]; printf("\n\rIngrese Cadena: "); gets(cadena); fflush(stdin); printf("\nEliminacion de 1er y ultimo caracter"); printf(" de cada palabra..\n\n%s\n\n",elimina(cadena)); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 14: Ingrese una cadena de caracteres por teclado, realice una funcion que elimine todas las vocales de la cadena. *********************************************************************/ #include <iostream> using namespace std; //funcion para eliminar las vocales char *sinvocal(char cad[]){ int i,j,k; char car; i=strlen(cad); for(j=0;j<i;j++){ car=tolower(cad[j]); if(car=='a'|| car=='e'|| car=='i'|| car=='o'|| car=='u'){ for(k=j+1;k<i;k++)

cad[k-1]=cad[k]; j--; i--; } } return (cad); } //Procedimiento Principal void main(){ const int LongitudMax = 100; char cadena[LongitudMax]; printf("\n\rIngrese Cadena: "); gets(cadena); fflush(stdin); printf("\nFrase sin vocales..\n\n%s\n\n", sinvocal(cadena)); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 15: Ingrese una palabra, realice una funcion que diga si la palabra es palindromo o no. Recordar que una palabra es palindromo si se lee igual de izquierda a derecha y viceversa. Ejemplo: reconocer-> Es palindromo *********************************************************************/ #include <iostream> using namespace std; bool palindromo(char cad[]){ int i, L; char car; L=strlen(cad); for(i=0 ; cad[i]==cad[L-i-1] ; i++); return i==L; } void main(){ const int LongitudMax = 100; char cadena[LongitudMax]; printf("\n\rIngrese Cadena: "); gets(cadena); fflush(stdin); palindromo(cadena) ? printf("\n\nEs Palindromo\n\n"): printf("\n\nNo es Palindromo\n\n") ; system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 16: Ingrese una cadena de caracteres, realice una funcion que elimine los espacios, la funcion debe retornar la cantidad de espacios eliminados. Ejemplo: " Si tienes alguna duda sobre el uso de este programa, acude a la pagina oficial del programa, o pregunta en la lista de correo " Resultado "Si tienes alguna duda sobre el uso de este programa, acude a la pagina oficial del programa, o pregunta en la lista de correo" La funcion devolvera: 12 *********************************************************************/ #include <iostream> using namespace std; //Procedimiento para reemplazar espacios void reemplaza_espacios(char cad[], char car){ int i, L; L=strlen(cad); for(i=0 ; i<L; i++) if(cad[i]==' ') cad[i]=car; } //Funcion para eliminar espacios int elimina_espacios(char cad[], char car){ int i, j, L, p, can; L=strlen(cad); can=0; for(i=0 ; i<L; i++) if(cad[i]==car && cad[i+1]==car){ for(j=i+2 ; j<L ; j++) cad[j-1]=cad[j]; i--; L--; can++; cad[L]='\0'; } for(p=1;p<=2;p++){ (p==1) ? i=0: i=L-1; if(cad[i]==car){

for(j=i+1 ; j<L ; j++) cad[j-1]=cad[j]; L--; can++; cad[L]='\0'; } } return can; } void main(){ const int LongitudMax = 100; char cadena[LongitudMax], espacio_reemplazo='_'; int can; printf("\n\rIngrese Cadena:\n"); gets(cadena); fflush(stdin); reemplaza_espacios(cadena, espacio_reemplazo); printf("\n\nCadena con espacios reemplazados:\n%s", cadena); can=elimina_espacios(cadena, espacio_reemplazo); printf("\n\nCadena Procesada:\n%s", cadena); printf("\n\nEspacios Eliminados: %d\n\n", can); system("PAUSE"); } /***************************Fin del Programa****************************/

10.4 Ejercicios Varios

/**********************Inicio del Programa*************************** Ejercicio 1: SIMPLIFICADOR DE PALABRAS Elaborar un programa que simplifique una expresion formada con las letras A, B, C y E, de acuerdo con la sgte tabla de multiplicacion: P E A B C E E A B C A A B C E B B C E A C C E A B El significado de esta tabla es la sgte: Si se ingresa :AB El resultado es :C (ya que el producto<interseccion> de AB es C) Si se ingresa :AACB El resultado es :C Pues AA es igual a B, BC es igual a A y finalmente AB es vale C. *********************************************************************/ /* ANALISIS: Se toman dos caracteres entonces segun la tabla fijarse en la primera fila y en la primera columna entonces el resultado esta en la interseccion. Ejemplo: Ingreso: AB _ _ A _ _ _ _ _ _ _ B _ C _ _ _ _ _ _ _ Ingreso: BC _ _ _ _ C _ _ _ _ _ B _ _ _ A _ _ _ _ _ */ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ char tabla[5][5], cad[50],val; int i,j,k,l,lon;

bool sw=false; //creando tabla de multiplicacion tabla[0][0]='P';tabla[0][1]='E';tabla[0][2]='A';tabla[0][3]='B';tabla[0][4]='C'; tabla[1][0]='E';tabla[1][1]='E';tabla[1][2]='A';tabla[1][3]='B';tabla[1][4]='C'; tabla[2][0]='A';tabla[2][1]='A';tabla[2][2]='B';tabla[2][3]='C';tabla[2][4]='E'; tabla[3][0]='B';tabla[3][1]='B';tabla[3][2]='C';tabla[3][3]='E';tabla[3][4]='A'; tabla[4][0]='C';tabla[4][1]='C';tabla[4][2]='E';tabla[4][3]='A';tabla[4][4]='B'; printf("\nIngrese cadena..."); gets(cad); fflush(stdin); lon=strlen(cad); //validando caracteres for(i=0;i<lon;i++) if(cad[i]!='A' && cad[i]!='B' && cad[i]!='C' && cad[i]!='E' && cad[i]!=' '){ printf("\nError Caracter %c no permitido!",cad[i]); exit(0); } //Operacion for(k=0;k<lon;k++)//k-> cadena ingresada for(i=1;i<5;i++){//filas de la matriz if(cad[k] != tabla[i][0]) continue; for(j=1;j<5;j++){//columnas de la matriz if(cad[k+1] != tabla[0][j])continue; val=tabla[i][j]; printf("\n%c por %c es igual a %c",tabla[i][0], tabla[0][j], val); //eliminacion 1: primer caracter evaluado for(l=k+1;l<lon;l++) cad[l-1]=cad[l]; k--; lon--; //eliminacion 2:segundo caracter evaluado for(l=k+2;l<lon;l++) cad[l-1]=cad[l]; k--; lon--; //insertando resultado de la operacion for(l=lon-1 ; l>=k+2 ; l--) cad[l+1]=cad[l]; cad[l+1]=val; //Demarcando el final de la cadena lon++;cad[lon]='\0'; } } printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 2: Dos numeros se dicen amigos cuando uno de ellos es igual a la suma de todos los divisores del otro excepto el mismo. Ejemplo: 220(1 + 2 + 4 + 5 + 10 + 11 + 20 + 22 + 44 + 55 + 110 = 284) 284( 1 + 2 4 + 71 + 142 = 220) Por lo tanto son amigos. Se pide: a) Escribir una funcion booleana que llamada desde un programa, permita dicernir si dos numeros (parametros) son amigos. b) Usar otra funcion para calcular la suma de los divisores de un numero determinado. c) Hacer referencia a dichas funciones desde un programa o desde otro subprograma *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" //Funcion para extraer la suma de divisores long suma_divisores(long nro){ long k,sd=0; for(k=1 ; k<nro ; k++) if(nro % k==0) sd+=k; return sd; } //Funcion para dicernir numeros amigos bool amigo(long n, long m){ long sd_n=0,sd_m=0; sd_n = suma_divisores(n); printf("\n\rLa suma de los divisores de %ld es...%ld",n, sd_n); sd_m = suma_divisores(m); printf("\n\rLa suma de los divisores de %ld es...%ld",m, sd_m); return(sd_n==m && sd_m==n); } //Procedimiento Principal void main(){ long n, m; printf("Ingrese 1er #..");scanf("%ld",&n); fflush(stdin);

printf("Ingrese 2do #..");scanf("%ld",&m); fflush(stdin); if(amigo(n, m)) printf("\n\n\rSon numeros amigos"); else printf("\n\n\rNo son numeros amigos"); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 3: Un juego consiste en encontrar un numero de 5 digitos que ha sido generado aleatoriamente por la computadora. El jugador tiene 6 oportunidades, y en cada una de ellas imprimira los siguientes mensajes: -Si algun digito se encuentra en el numero, y esta en posicion correcta se debera imprimir 'y'. -Si algun digito se encuentra en el numero, pero no esta en la posicion correcta, se debera imprimir una 'x'. Ejemplo: Supongamos que el numero sea 28635 y el numero ingresado es 38165. La computadora mostrara por pantalla 'xy1xy' Si al final de los seis intentos no se acierta con m se debera mostrar el numero ingresado. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ long azar, n; int i, j, k, A[5], B[5], desde, hasta, intentos=6, cantidad_digitos=5; int u,d,c,m,um, u1,d1,c1,m1,um1, tiempo; char r; bool sw; tiempo=time(NULL); srand(tiempo); desde=10000; hasta=99999;

do{ azar=desde + rand() % (1 + hasta - desde); //azar= 28635; um=azar/10000; m=(azar%10000)/1000; c=((azar%10000)%1000)/100; d=(((azar%10000)%1000)%100)/10; u=azar%10; A[0]=um, A[1]=m, A[2]=c, A[3]=d, A[4]=u; //printf("\n\n%d...", azar); for(i=0 ; i<intentos ; i++){ printf("\n\nDigite # de 5 digitos..."); scanf("%ld",&n); fflush(stdin); if(!(n>=10000 && n<=99999)){ printf("\n\nNumero no es de 5 cifras\n\n"); system("PAUSE"); continue; } um1=n/10000; m1=(n%10000)/1000; c1=((n%10000)%1000)/100; d1=(((n%10000)%1000)%100)/10; u1=n%10; B[0]=um1,B[1]=m1,B[2]=c1,B[3]=d1,B[4]=u1; for(j=0 ; j<cantidad_digitos ; j++){ if(B[j]==A[j]){ printf("y"); continue; } sw=false; for(k=0 ; k<cantidad_digitos ; k++){ if(j==k)continue; if(B[j]==A[k]){ printf("x"); sw=true; break; } } if(!sw) printf("%d", B[j]); } if(n==azar){ printf("\n\nUsted ha acertado \t\"Felicitaciones\""); break; }else if(i<=intentos ) printf("\nNo acerto tiene %d oportunidades",intentos -i -1); }

if(n!=azar) printf("\n\nNo acerto \"QUE LASTIMA...\" el # de la PC era...%ld", azar); printf("\n\nContinua? S/N "); r=getchar(); fflush(stdin); }while(r=='s'|| r=='S'); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 4: CODIFICACION DE MENSAJES Elaborar un programa para codificar mensajes con la sgte clave: Se intercambia el caracter en blanco con el simbolo @, para las letras A-M con las letras N-Z y las letras N-Z con A-M, los otros carceteres se dejan intactos. Ejemplo Mensaje: HOLA COMO TE VA CODIFICADO: UBYN@PBZB@GR@IN *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ char frase[50]; int i, j, lon; printf("\nIngrese frase..."); gets(frase); fflush(stdin); lon=strlen(frase); for(i=0 ; i<lon ; i++) frase[i]=toupper(frase[i]); for(i=0 ; i<lon ; i++) if(frase[i]>='A' && frase[i]<='M') frase[i]=char(int(frase[i]) + 13); else if(frase[i]>='N' && frase[i]<='Z') frase[i]=char(int(frase[i]) - 13); else if(frase[i]==' ') frase[i]='@'; printf("\n\nLa nueva frase es..%s", frase); printf("\n\n"); system("PAUSE");

} /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 5: JUEGO 21 Se tiene un juego de cartas en las cuales se han separado las cartas con letras (J=11, Q=12, K=13). Es decir solo se cuentan con 4 rangos de numeros (1-11) corazones, espadas, treboles, diamantes. El juego consiste en asignar a un banquero (PC) el que reparte las cartas y a otro que es el retador. El banquero reparte las cartas una a una cuando el retador las solicita, el retador puede detenerse en cualquier momento. Si el retador o el banquero sobrepasa 21 acumulado pierde. Cuando el retador decide detenerse de solicitar cartas, es el turno del banquero. Gana el que acumula exactamente 21 Gana el banquero si el retador acumulo igual al banquero Gana el que se aproxime mas a 21. Para que sea aleatorio y variados las cartas, al iniciar el juego se deben barajar las cartas. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" /*CONSTANTES Y VARIABLES GLOBALES*/ const int Max_Carta=11, GrupoCartas=4, Tope=21; int tiempo; int MazoCartas[4][Max_Carta], cartas_retador[Max_Carta], cartas_banquero[Max_Carta]; /*************PROCEDIMIENTOS Y FUNCIONES**************/ void barajar(){ tiempo=time(NULL); srand(tiempo); } void IniciarMazoCartas(){ for(int fila=0 ; fila<GrupoCartas ; fila++) for(int columna=0 ; columna<Max_Carta ; columna++) MazoCartas[fila][columna]=columna+1; } int Cantidad_MazoCartas_Disponibles(){ int cant=0; for(int fila=0 ; fila<GrupoCartas ; fila++)

for(int columna=0 ; columna<Max_Carta ; columna++) if(MazoCartas[fila][columna]!=0) cant++; return cant; } void Añadir_Carta(int &ai_longitud, int ai_cartas[], int carta){ ai_cartas[ai_longitud]=carta; ai_longitud++; } int Carta_Aleatoria(int ai_numero){ int contador=0, carta; for(int fila=0 ; fila<GrupoCartas ; fila++) for(int columna=0 ; columna<Max_Carta ; columna++){ if(MazoCartas[fila][columna]==0)continue; contador++; if(contador==ai_numero){ carta=MazoCartas[fila][columna]; MazoCartas[fila][columna]=0; break; break; } } return carta; } int SumaCartas(int ai_longitud, int ai_cartas[]){ int S=0; for(int i =0 ; i<ai_longitud ; i++) S+=ai_cartas[i]; return S; } void Faltan_Cartas(){ int cantidad_cartas = Cantidad_MazoCartas_Disponibles(); if(cantidad_cartas!=0)return; printf("\n\n\rNo hay cartas disponibles, se van a barajar cartas"); IniciarMazoCartas(); barajar(); cantidad_cartas=Cantidad_MazoCartas_Disponibles(); printf("\n\n\rCartas disponibles: %d", cantidad_cartas); } /*****************PROCEDIMIENTO PRINCIPAL*****************/ void main(){ char solicitud, juego_nuevamente; int desde, hasta, azar, carta, cantidad_cartas; int longitud_retador, acumulado_retador, longitud_banquero, acumulado_banquero; do{

printf("\n\n\rCartas disponibles: %d\n\n", Cantidad_MazoCartas_Disponibles()); //Turno del retador longitud_retador=acumulado_retador=0; do{ Faltan_Cartas(); printf("\n\n\rDesea carta? S/N:");solicitud=getchar();fflush(stdin); if(toupper(solicitud)=='N')break; desde=1; hasta=Cantidad_MazoCartas_Disponibles(); azar=desde + rand() % (1 + hasta - desde); carta=Carta_Aleatoria(azar); Añadir_Carta(longitud_retador, cartas_retador, carta); acumulado_retador=SumaCartas(longitud_retador, cartas_retador); printf("\nHa Sacado %d, ha Acumulado %d", carta, acumulado_retador); if(acumulado_retador==Tope){ printf("\n\nHa ganado el retador, ha acumulado"); printf("%d\n\n", acumulado_retador); system("PAUSE"); goto final; }else if(acumulado_retador>Tope){ printf("\n\nRetador ha perdido, obtuvo %d", acumulado_retador); printf("y ha sobrepasado el tope %d\n\n", Tope); system("PAUSE"); goto final; } }while(toupper(solicitud)!='N' ); printf("\n\n.........Ud. se ha detenido en %d...........\n\n", acumulado_retador); printf("\n\n.........Ahora es turno del Banquero...........\n\n\n"); //Turno del Banquero longitud_banquero=acumulado_banquero=0; do{ Faltan_Cartas(); desde=1; hasta=Cantidad_MazoCartas_Disponibles(); azar=desde + rand() % (1 + hasta - desde); carta=Carta_Aleatoria(azar); Añadir_Carta(longitud_banquero, cartas_banquero, carta); acumulado_banquero=SumaCartas(longitud_banquero, cartas_banquero); printf("\nHa Sacado %d, ha Acumulado %d", carta, acumulado_banquero); if(acumulado_banquero==Tope){ printf("\n\nHa ganado el banquero, ha "); printf("acumulado %d\n\n", acumulado_banquero); system("PAUSE"); goto final; }else if(acumulado_banquero>Tope){ printf("\n\nBanquero ha perdido obtuvo %d ", acumulado_banquero); printf("y ha sobrepasado el tope %d\n\n", Tope); system("PAUSE");

goto final; } }while(acumulado_banquero < acumulado_retador && acumulado_banquero < Tope ); if(acumulado_banquero < Tope) if(acumulado_banquero>=acumulado_retador){ printf("\n\nHa ganado el banquero, ha acumulado "); printf("%d\n\n", acumulado_banquero); system("PAUSE"); goto final; }else{ printf("\n\nHa ganado el retador, ha acumulado "); printf("%d\n\n", acumulado_retador); system("PAUSE"); goto final; } final: printf("\n\n\rJugar de nuevo? S/N:"); juego_nuevamente=getchar(); fflush(stdin); }while(toupper(juego_nuevamente)!='N' ); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 6: Se tiene una matriz orden N*M de tipo entero, se pide llevar todos los numeros amstrong a un vector. *********************************************************************/ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" void main(){ const int OrdenMax = 100; int A[OrdenMax][OrdenMax],N, M, fila, columna; int V[OrdenMax * OrdenMax], i, L; int tiempo, desde, hasta; int nro, s, u; printf("\n\rIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese # de columnas de la matriz: "); scanf("%d", &M); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=1; hasta=1000;

for(fila=0;fila<N;fila++){ printf("\n\n"); for(columna=0;columna<M;columna++){ A[fila][columna]=desde + rand() % (1 + hasta - desde); printf("\t%d",A[fila][columna]); } } L=0; for(fila=0;fila<N;fila++) for(columna=0;columna<M;columna++){ nro=A[fila][columna]; s=0; do{ u=nro%10; nro/=10; s+=(u*u*u); }while(nro>0); if(s==A[fila][columna]){ V[L]=A[fila][columna]; L++; } } printf("\n\nVector con numeros amstrong...\n\n"); for(i=0;i<L;i++) printf("\t%d",V[i]); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/

/**********************Inicio del Programa*************************** Ejercicio 7: GRAFOS Se tiene una matriz cuadrada de orden N de tipo entero que representa un grafo. se pide mostrar la cantidad de formas de ir desde (a,b) pasando por (E arcos). Ingresar por teclado: -El orden de la matriz -Los puntos de conexion entre dos puntos (1 hay conexion, 0 No). -Cantidad de arcos E. El Resultado es una matriz con la cantidad de formas de ir desde un punto (a,b) pasando por E arcos. *********************************************************************/ /* ANALISIS

SE UTILIZA EL CONCEPTO DE PRODUCTO DE MATRICES. ML= A B C D 0 0 1 1 A 1 0 0 1 B 0 1 0 0 C 0 0 1 0 D SI E=2 MLxML= 0 0 1 1 0 0 1 1 1 0 0 1 X 1 0 0 1 0 1 0 0 0 1 0 0 0 0 1 0 0 0 1 0 MLxML= A B C D 0 1 1 0 A 0 0 2 1 B 1 0 0 1 C 0 1 0 0 D Existen 1 forma de ir de A hacia B pasando por dos arcos Existen 2 forma de ir de C hacia B pasando por dos arcos Existen 0 formas de ir de A hacia D pasando por dos arcos */ #include <iostream> using namespace std; #include "stdlib.h" #include "time.h" //CONSTANTES Y VARIABLES GLOBALES const int OrdenMax = 10; int N, E; //PROCEDIMIENTOS void Asignar_Matriz(int &indice, int ai_cubo[][OrdenMax][OrdenMax], int ai_matriz[][OrdenMax]){ for(int fila=0 ; fila<N ; fila++) for(int columna=0 ; columna<N ; columna++) ai_cubo[indice][fila][columna] = ai_matriz[fila][columna]; indice++; } void Mostrar_MatrizResultado(int indice, int ai_cubo[][OrdenMax][OrdenMax]){ int data, fila, columna; for(fila=0 ; fila<N ; fila++) printf("\t%c", char(65+fila)); printf("\n\n"); for( fila=0 ; fila<N ; fila++){ for(columna=0 ; columna<N ; columna++){ data=ai_cubo[indice-1][fila][columna]; printf("\t%d", data); } printf("%4c\n\n", char(65+fila)); }

for( fila=0 ; fila<N ; fila++) for(columna=0 ; columna<N ; columna++){ data=ai_cubo[indice-1][fila][columna]; if(data>0){ printf("\nExiste %d forma(s) de ir de ", data); printf("%c hasta %c ", char(65+fila), char(65+columna)); printf("pasando por %d arcos", E); } } } //PROCEDIMIENTO PRINCIPAL void main(){ int A[OrdenMax][OrdenMax], B[OrdenMax][OrdenMax], C[OrdenMax][OrdenMax], D[OrdenMax][OrdenMax], ML[OrdenMax][OrdenMax][OrdenMax], i, p; int tiempo, desde, hasta, filaA, columnaA, filaB, columnaB, S; printf("\n\rIngrese orden N de la matriz : "); scanf("%d", &N); fflush(stdin); printf("\n\rIngrese cantidad de arcos del resultado: "); scanf("%d", &E); fflush(stdin); tiempo=time(NULL); srand(tiempo); desde=0; hasta=1; printf("\n\nPuntos de conexion de grafo\n\n"); for(filaA=0 ; filaA<N ; filaA++) printf("\t%c", char(65+filaA)); printf("\n\n"); i=0; for(filaA=0 ; filaA<N ; filaA++){ for(columnaA=0 ; columnaA<N ; columnaA++){ printf("\t"); if(filaA!=columnaA){ A[filaA][columnaA] = desde + rand() % (1 + hasta - desde); }else A[filaA][columnaA]=0; printf("%d", A[filaA][columnaA]); } printf("%4c\n\n", char(65+filaA)); } Asignar_Matriz(i, ML, A); //Al cuadrado for(filaA=0 ; filaA<N ; filaA++) for(columnaB=0 ; columnaB<N ; columnaB++){ S=0; for(columnaA=0 ; columnaA<N ; columnaA++) S+=A[filaA][columnaA] * A[columnaA][columnaB]; B[filaA][columnaB]=S;

} Asignar_Matriz(i, ML, B); if(E==2) goto final; //Al cubo for(filaA=0 ; filaA<N ; filaA++) for(columnaB=0 ; columnaB<N ; columnaB++){ S=0; for(columnaA=0 ; columnaA<N ; columnaA++) S+=A[filaA][columnaA] * B[columnaA][columnaB]; C[filaA][columnaB]=S; } Asignar_Matriz(i, ML, C); if(E==3) goto final; //E > 3 for(p=3;p<E;p++){ for(filaA=0 ; filaA<N ; filaA++) for(columnaB=0 ; columnaB<N ; columnaB++){ S=0; for(columnaA=0 ; columnaA<N ; columnaA++) S+=ML[0][filaA][columnaA] * ML[p-1][columnaA][columnaB]; D[filaA][columnaB]=S; } Asignar_Matriz(i, ML, D); } final: printf("\n\nMatriz Resultado\n\n"); Mostrar_MatrizResultado(i, ML); printf("\n\n"); system("PAUSE"); } /***************************Fin del Programa****************************/