Esta es la entrega que ofrece una amplia enseñanza acerca de la resolución de problemas computacionales en lenguaje C++.Net. Este libro muestra ejercicios diseñados didácticamente para la fácil asimilación del estudiante. Además se incluye ejercicios de maratón, exámenes y ejercicios para aplicaciones actuales. Con este libro Usted podrá culminar su carrera de ciencias informáticas sin morir en el intento.

1. Capítulo 10
EJERCICIOS DE
AUTOEVALUACION
10.1 Arreglos Unidimensionales
10.2 Arreglos Bidimensionales
10.3 Cadenas
10.4 Ejercicios Varios

2. 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("%dt", A[i]);
}
printf("nn");
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("nn");
tiempo=time(NULL);
srand(tiempo);

3. desde=2;
hasta=19;
S=0;
for(i=0 ; i<N ; i++){
A[i]=desde + rand() % (1 + hasta - desde);
printf("%dt", A[i]);
S+=A[i];
}
printf("nnSuma del Vector: %d", S);
printf("nPromedio del Vector: %8.2lfnn", 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("nn");
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("%dt", A[i]);
if(A[i] > mayor){
mayor=A[i];
posmay=i + 1;
}
if(A[i] < menor){

4. menor=A[i];
posmen=i + 1;
}
}
printf("nnMayor elemento del Vector: %d posicion: %d", mayor, posmay);
printf("nMenor elemento del Vector: %d posicion: %dnn", 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("nn");
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("%dt", A[i]);
if(A[i] % 2 ==0)cp++;
else ci++;
}
printf("nnCantidad de elementos Pares: %d", cp);
printf("nantidad de elementos Impares: %dnn", ci);
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************

5. 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("nn");
tiempo=time(NULL);
srand(tiempo);
desde=2;
hasta=19;
for(i=0 ; i<N ; i++){
A[i]=desde + rand() % (1 + hasta - desde);
printf("%dt", A[i]);
}
printf("nn");
//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("nn");
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;

6. int N, c5, cn5;
printf("nIngrese numero de elementos: "); scanf("%d", &N); fflush(stdin);
printf("nn");
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("%dt", A[i]);
if(A[i] % 5 ==0){
M5[c5]=A[i];
c5++;
}else{
NM5[cn5]=A[i];
cn5++;
}
}
printf("nnMultiplos de 5nn");
for(i=0 ; i<c5 ; i++)
printf("%dt ", M5[i]);
printf("nnNO Multiplos de 5nn");
for(i=0 ; i<cn5 ; i++)
printf("%dt ", NM5[i]);
printf("nn");
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);

7. printf("nn");
tiempo=time(NULL);
srand(tiempo);
desde=2;
hasta=19;
for(i=0 ; i<N ; i++){
A[i]=desde + rand() % (1 + hasta - desde);
printf("%dt", A[i]);
}
printf("nnInvirtiendo contenido...nn");
for(i=0 ; i<N/2 ; i++)
{
aux=A[i];
A[i]=A[N-i-1];
A[N-i-1]=aux;
}
printf("Vector Invertidonn");
for(i=0 ; i<N ; i++)
printf("%dt",A[i]);
printf("nn");
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("nn");
tiempo=time(NULL);
srand(tiempo);
desde=2;
hasta=19;

8. cp=ci=sp=si=0;
for(i=0 ; i<N ; i++){
A[i]=desde + rand() % (1 + hasta - desde);
printf("%dt", A[i]);
if(A[i]%2==0){
cp++;
sp+=A[i];
}else{
ci++;
si+=A[i];
}
}
if(sp/double(cp) > si/double(ci)) printf("nnEl promedio de los Pares es mayor");
else printf("nnEl promedio de los Impares es mayor");
printf("nn");
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("nnIngrese nro a insertar.."); scanf("%d",&nro_insertar);
printf("nIngrese nro de posicion a insertar.."); scanf("%d",&posicion);

9. for(i = N-1 ; i>=posicion-1 ; i--)
A[i+1] = A[i];
A[posicion-1] = nro_insertar;
N++;
printf("nnEl nro ha sido insertadonn");
for(i=0 ; i<N ; i++)
printf("%4d", A[i]);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

10. /**********************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("nn");
tiempo=time(NULL);
srand(tiempo);
desde=2;
hasta=19;
for(i=0 ; i<N ; i++){
A[i] = desde + rand() % (1 + hasta - desde);
printf("%dt", 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("nnCantidad de digitos Pares es..%d", cdp);
printf("nCantidad de digitos Impares es..%d", cdi);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

12. /**********************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("nn");
tiempo=time(NULL);
srand(tiempo);
desde=2;
hasta=19;
for(i=0 ; i<N ; i++){
A[i] = desde + rand() % (1 + hasta - desde);
printf("%dt", 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..nn");
for(i=0;i<N;i++)
printf("%dt", 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..nn");
for(i=0;i<N;i++)
printf("%dt", A[i]);
printf("nn");
system("PAUSE");

13. }
/***************************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("nn");
tiempo=time(NULL);
srand(tiempo);
desde=2;
hasta=19;
for(i=0 ; i<N ; i++){
A[i] = desde + rand() % (1 + hasta - desde);
printf("%dt", A[i]);
}
printf("nnIngrese 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;

14. N++;
printf("nnn");
for(i=0 ; i<N ; i++)
printf("%dt", A[i]);
printf("nn");
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("nn");
tiempo=time(NULL);
srand(tiempo);
desde=2;
hasta=19;
for(i=0 ; i<N ; i++){
A[i] = desde + rand() % (1 + hasta - desde);
printf("%dt", A[i]);
}
printf("nnIngrese 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("nnn");

15. for(i=0 ; i<N ; i++)
printf("%dt", A[i]);
printf("nn");
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("nn");
tiempo=time(NULL);
srand(tiempo);
desde=2;
hasta=19;
for(i=0 ; i<N ; i++){
A[i] = desde + rand() % (1 + hasta - desde);
printf("%dt", 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("nnVector Ordenadonn");
for(i=0 ; i<N ; i++)
printf("%dt", A[i]);
printf("nn");
//Eliminacion
for(i=0 ; i<N-1 ; i++)

16. 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("nnnVector sin elementos repetidosnnn");
for(i=0 ; i<N ; i++)
printf("%dt", A[i]);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

17. /**********************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("nn");
tiempo=time(NULL);
srand(tiempo);
desde=2;
hasta=19;
for(i=0 ; i<N ; i++){
A[i] = desde + rand() % (1 + hasta - desde);
printf("%dt", A[i]);
}
printf("nnIngrese # 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("nnn");
for(i=0 ; i<N ; i++)
printf("%dt", A[i]);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
/**********************Inicio del Programa***************************

18. 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("nn");
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("%dt", A[i]);
printf("nn");
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"

19. 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("nn");
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("%dt", A[i]);
printf("nn");
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"

20. 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("nn");
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%dt+t%dt=t%dt", A[i], B[i], C[i]);
printf("nn");
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("nn");
tiempo=time(NULL);
srand(tiempo);

21. desde=2;
hasta=19;
for(i=0;i<N;i++){
A[i]=desde + rand() % (1 + hasta - desde);
printf("%dt", A[i]);
}
for(i=0 ; i<N-1 && A[i]<=A[i+1] ; i++);
if(i == N-1){
printf("nVector Ordenado Ascendentemente");
printf("nn");
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("nn");
system("PAUSE");
exit(0);
}
printf("nVector Desordenado");
printf("nn");
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;

22. #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("%dt", i+1);
turno = desde + rand() % (1 + hasta - desde);
printf("nrEl 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("tttSe salvo el alumno %dnn", salvado + 1);
getchar();
}
for(i=0 ; i<N ; i++){
if(a[i]!=0)continue;
printf("nnrEl alumno %d y tiene que ir a hablar con el directornn", i+1);
}
system("PAUSE");
}
/***************************Fin del Programa****************************/

23. /**********************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("nrIngrese cantidad de # que tendra el vector..."); scanf("%d", &N); fflush(stdin);
printf("nrIngrese numero minimo de los elementos..."); scanf("%d", &desde); fflush(stdin);
printf("nrIngrese numero maximo de los elementos..."); scanf("%d", &hasta); fflush(stdin);
printf("nn");
tiempo=time(NULL);
srand(tiempo);
for(i=0;i<N;i++){
a[i]=desde + rand() % (1 + hasta - desde);
printf("%dt",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("nr%d Se repite...%d veces", i, c);
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/
10.2 Arreglos Bidimensionales
/**********************Inicio del Programa***************************

24. 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("nrIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin);
printf("nrIngrese # 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("nnt");
for(columna=0 ; columna<M ; columna++){
A[fila][columna] = desde + rand() % (1 + hasta - desde);
printf("t%d", A[fila][columna]);
}
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

25. /**********************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("nrIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin);
printf("nrIngrese # 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("nnt");
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("nnnEl Mayor elemento: %d", Mayor);
printf("nEl Menor elemento: %dnn", 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.

26. *********************************************************************/
#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("nrIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin);
printf("nrIngrese # 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("nnt");
for(columna=0 ; columna<M ; columna++){
A[fila][columna] = desde + rand() % (1 + hasta - desde);
printf("t%d", A[fila][columna]);
}
}
printf("nnnEl Mayor y Menor elemento por filas...nn");
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: %dt Menor: %d", fila + 1, Mayor, Menor);
}
printf("nnnEl Mayor y Menor elemento por Columnas...nn");
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: %dt Menor: %d", columna + 1, Mayor, Menor);
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

27. /**********************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("nrIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin);
printf("nrIngrese # 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("nnt");
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("nnEl Promedio de la Matriz: %8.2lfnn", 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.
*********************************************************************/

28. #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("nrIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin);
printf("nrIngrese # 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("nnt");
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("nnLa Suma de la periferie de la Matriz: %dnn", 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"

29. void main(){
const int OrdenMax = 10;
int A[OrdenMax][OrdenMax], N, M;
int tiempo, desde, hasta, fila, columna;
int S;
printf("nrIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin);
printf("nrIngrese # 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("nnt");
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("nnLa Suma de la No periferie de la Matriz: %dnn", 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("nrIngrese orden de la matriz: "); scanf("%d", &N); fflush(stdin);

30. tiempo=time(NULL);
srand(tiempo);
desde=1; hasta=5;
for(fila=0 ; fila<N ; fila++){
printf("nnt");
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("nnLa Suma de la diagonal Principal: %d", SP );
printf("nLa Suma de la diagonal Secundaria: %dnn", SS );
system("PAUSE");
}
/***************************Fin del Programa****************************/

31. /**********************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("nrIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin);
printf("nrIngrese # 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("nnt");
for(columna=0 ; columna<M ; columna++){
A[fila][columna] = desde + rand() % (1 + hasta - desde);
printf("t%d", A[fila][columna]);
}
}
printf("nnMatriz Transpuesta...nn");
for(fila=0 ; fila<M ; fila++){
printf("nnt");
for(columna=0 ; columna<N ; columna++){
B[fila][columna] = A[columna][fila];
printf("t%d", B[fila][columna]);
}
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

33. /**********************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("nrIngrese # 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("nnt");
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("nnSumatoria de la Matriz Triangular Superior %dnn", S);
system("PAUSE");
}

34. /***************************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("nrIngrese # 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("nnt");
for(columna=0 ; columna<N ; columna++){
A[fila][columna] = desde + rand() % (1 + hasta - desde);
printf("t%d", A[fila][columna]);
}
}
S=0;

35. for(columna=0 ; columna<N ; columna++)
for(fila=columna ; fila<N ; fila++)
S+=A[fila][columna];
printf("nnSumatoria de la Matriz Triangular Inferior %dnn", 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("nrIngrese # 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("nnt");
for(columna=0 ; columna<N ; columna++){
A[fila][columna] = desde + rand() % (1 + hasta - desde);
printf("t%d", A[fila][columna]);
}

36. }
S=0;
for(columna=0 ; columna<N-1 ; columna++)
for(fila=columna+1 ; fila<N ; fila++)
S+=A[fila][columna];
printf("nnSumatoria de la No Matriz Triangular Superior %dnn", 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("nrIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin);
tiempo=time(NULL);
srand(tiempo);

37. desde=1; hasta=5;
for(fila=0 ; fila<N ; fila++){
printf("nnt");
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("nnSumatoria de la No diagonales %dnn", S);
system("PAUSE");
}
/***************************Fin del Programa****************************/

38. /**********************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("nrIngrese # 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("nnt");
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("nnDiagonales Intercambiadasnn");
for(fila=0 ; fila<N ; fila++){
printf("nnt");
for(columna=0 ; columna<N ; columna++)
printf("t%d", A[fila][columna]);
}
printf("nn");
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.

39. *********************************************************************/
#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("nrIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin);
printf("nrIngrese # 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("nnt");
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("nnColumnas Invertidasnn");
for(fila=0 ; fila<N ; fila++){
printf("nnt");
for(columna=0 ; columna<M ; columna++)
printf("t%d", A[fila][columna]);
}
printf("nn");
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.

40. *********************************************************************/
#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("nrIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin);
printf("nrIngrese # 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("nnt");
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("nnEl promedio de los pares es...%8.1lf",sp/double(cp));
printf("nEl promedio de los impares es...%8.1lfnn",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"

41. #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("nrIngrese N de filas de la matriz 1: "); scanf("%d", &N); fflush(stdin);
printf("nrIngrese M columnas de la matriz 1: "); scanf("%d", &M); fflush(stdin);
printf("nrIngrese Q columnas de la matriz 2: "); scanf("%d", &Q); fflush(stdin);
tiempo=time(NULL);
srand(tiempo);
desde=1; hasta=5;
printf("nn Matriz 1 N*Mnn");
for(filaA=0 ; filaA<N ; filaA++){
printf("nt");
for(columnaA=0 ; columnaA<M ; columnaA++){
A[filaA][columnaA] = desde + rand() % (1 + hasta - desde);
printf("t%d", A[filaA][columnaA]);
}
}
printf("nn Matriz 2 M*Qnn");
for(filaB=0 ; filaB<M ; filaB++){
printf("nt");
for(columnaB=0 ; columnaB<Q ; columnaB++){
B[filaB][columnaB] = desde + rand() % (1 + hasta - desde);
printf("t%d", B[filaB][columnaB]);
}
}
printf("nn Matriz Resultado 3 N*Qnn");
for(filaA=0 ; filaA<N ; filaA++){
printf("nt");
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("nn nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

42. /**********************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("nrIngrese 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("nn");
for(c=0;c<N;c++)
printf("t%d",A[fila][c]);
}
printf("nn nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

43. 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("nrIngrese cadena: "); gets(cadena); fflush(stdin);
for(L=0 ; cadena[L]!='0' ; L++);
printf("nnLa longitud es %dnn", 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("nrIngrese Cadena: "); gets(cadena); fflush(stdin);
printf("nrPosicion de Inicio a Extraer: "); scanf("%d", &inicio); fflush(stdin);
printf("nrNumero 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("nnLa cadena extraida es %snn", Resultado);

44. 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("nrIngrese Cadena: "); gets(cadena); fflush(stdin);
printf("nrNumero 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("nnLa cadena extraida es %snn", 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("nrIngrese Cadena: "); gets(cadena); fflush(stdin);
printf("nrNumero de caracteres a Extraer: "); scanf("%d", &nrocar);

45. fflush(stdin);
L=strlen(cadena);
c=0;
for(i=L-nrocar ; cadena[i]!='0' ; i++){
Resultado[c]=cadena[i];
c++;
}
Resultado[c]='0';
printf("nnLa cadena extraida es %snn", 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("nrIngrese Cadena 1: "); gets(cadena1); fflush(stdin);
printf("nrIngrese 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("nnLa cadena resultado es:nn%snn", Resultado);
system("PAUSE");
}

46. /***************************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("nrIngrese Cadena: "); gets(cadena1); fflush(stdin);
printf("nrIngrese 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("nnLa cadena son igualesnn");
else
printf("nnLa cadena son distintasnn");
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("nrIngrese caracter: "); caracter=getchar(); fflush(stdin);
printf("nrIngrese numero: "); scanf("%d",&N); fflush(stdin);

47. printf("nnCodigo Ascii de caracter: %d", int(caracter));
printf("nCaracter de Numero: %cnn", 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("nrIngrese 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("nnLa cadena mayuscula es: %s", Resultado1);
printf("nLa cadena minuscula es: %snn", Resultado2);
system("PAUSE");
}
/***************************Fin del Programa****************************/

48. /**********************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("nrIngrese Cadena: "); gets(cadena); fflush(stdin);
L=strlen(cadena);
for(i=0 ; i<L ; i++)
printf("nt%c", cadena[i]);
printf("nn");
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;

49. printf("nrIngrese Cadena: "); gets(cadena); fflush(stdin);
L=strlen(cadena);
for(i=0 ; i<L ; i++){
printf("nt");
for(j=0 ; j<=i ; j++)
printf("%c", cadena[j]);
}
printf("nn");
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("nrIngrese Cadena: "); gets(cadena); fflush(stdin);
L=strlen(cadena);
for(i=0 ; i<L ; i++){
printf("nt");
for(j=0 ; j<=i ; j++)
printf("%c", cadena[i]);
}
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

50. /**********************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("nrIngrese Cadena: "); gets(cadena); fflush(stdin);
L=strlen(cadena);
for(i=L-1 ; i>=0 ; i--){
printf("nt");
for(j=0 ; j<=i ; j++)
printf("%c", cadena[L-i-1]);
}
printf("nn");
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

51. 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("nrIngrese Cadena: "); gets(cadena); fflush(stdin);
printf("nEliminacion de 1er y ultimo caracter");
printf(" de cada palabra..nn%snn",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++)

52. cad[k-1]=cad[k];
j--;
i--;
}
}
return (cad);
}
//Procedimiento Principal
void main(){
const int LongitudMax = 100;
char cadena[LongitudMax];
printf("nrIngrese Cadena: "); gets(cadena); fflush(stdin);
printf("nFrase sin vocales..nn%snn", 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("nrIngrese Cadena: "); gets(cadena); fflush(stdin);
palindromo(cadena) ? printf("nnEs Palindromonn"): printf("nnNo es Palindromonn") ;
system("PAUSE");
}
/***************************Fin del Programa****************************/

53. /**********************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){

54. 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("nrIngrese Cadena:n"); gets(cadena); fflush(stdin);
reemplaza_espacios(cadena, espacio_reemplazo);
printf("nnCadena con espacios reemplazados:n%s", cadena);
can=elimina_espacios(cadena, espacio_reemplazo);
printf("nnCadena Procesada:n%s", cadena);
printf("nnEspacios Eliminados: %dnn", can);
system("PAUSE");
}
/***************************Fin del Programa****************************/

55. 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;

56. 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("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/

57. /**********************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("nrLa suma de los divisores de %ld es...%ld",n, sd_n);
sd_m = suma_divisores(m);
printf("nrLa 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);

58. printf("Ingrese 2do #..");scanf("%ld",&m); fflush(stdin);
if(amigo(n, m))
printf("nnrSon numeros amigos");
else
printf("nnrNo son numeros amigos");
printf("nn");
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;

59. 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("nn%d...", azar);
for(i=0 ; i<intentos ; i++){
printf("nnDigite # de 5 digitos..."); scanf("%ld",&n); fflush(stdin);
if(!(n>=10000 && n<=99999)){
printf("nnNumero no es de 5 cifrasnn");
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("nnUsted ha acertado t"Felicitaciones"");
break;
}else if(i<=intentos )
printf("nNo acerto tiene %d oportunidades",intentos -i -1);
}

60. if(n!=azar)
printf("nnNo acerto "QUE LASTIMA..." el # de la PC era...%ld", azar);
printf("nnContinua? S/N "); r=getchar(); fflush(stdin);
}while(r=='s'|| r=='S');
printf("nn");
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("nnLa nueva frase es..%s", frase);
printf("nn");
system("PAUSE");

61. }
/***************************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++)

62. 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("nnrNo hay cartas disponibles, se van a barajar cartas");
IniciarMazoCartas();
barajar();
cantidad_cartas=Cantidad_MazoCartas_Disponibles();
printf("nnrCartas 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{

63. printf("nnrCartas disponibles: %dnn", Cantidad_MazoCartas_Disponibles());
//Turno del retador
longitud_retador=acumulado_retador=0;
do{
Faltan_Cartas();
printf("nnrDesea 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("nnHa ganado el retador, ha acumulado");
printf("%dnn", acumulado_retador);
system("PAUSE");
goto final;
}else if(acumulado_retador>Tope){
printf("nnRetador ha perdido, obtuvo %d", acumulado_retador);
printf("y ha sobrepasado el tope %dnn", Tope);
system("PAUSE");
goto final;
}
}while(toupper(solicitud)!='N' );
printf("nn.........Ud. se ha detenido en %d...........nn", acumulado_retador);
printf("nn.........Ahora es turno del Banquero...........nnn");
//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("nnHa ganado el banquero, ha ");
printf("acumulado %dnn", acumulado_banquero);
system("PAUSE");
goto final;
}else if(acumulado_banquero>Tope){
printf("nnBanquero ha perdido obtuvo %d ", acumulado_banquero);
printf("y ha sobrepasado el tope %dnn", Tope);
system("PAUSE");

64. goto final;
}
}while(acumulado_banquero < acumulado_retador && acumulado_banquero < Tope );
if(acumulado_banquero < Tope)
if(acumulado_banquero>=acumulado_retador){
printf("nnHa ganado el banquero, ha acumulado ");
printf("%dnn", acumulado_banquero);
system("PAUSE");
goto final;
}else{
printf("nnHa ganado el retador, ha acumulado ");
printf("%dnn", acumulado_retador);
system("PAUSE");
goto final;
}
final:
printf("nnrJugar de nuevo? S/N:"); juego_nuevamente=getchar();
fflush(stdin);
}while(toupper(juego_nuevamente)!='N' );
printf("nn");
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("nrIngrese # de filas de la matriz: "); scanf("%d", &N); fflush(stdin);
printf("nrIngrese # de columnas de la matriz: "); scanf("%d", &M); fflush(stdin);
tiempo=time(NULL);
srand(tiempo);
desde=1;
hasta=1000;

65. for(fila=0;fila<N;fila++){
printf("nn");
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("nnVector con numeros amstrong...nn");
for(i=0;i<L;i++)
printf("t%d",V[i]);
printf("nn");
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

66. 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("nn");
for( fila=0 ; fila<N ; fila++){
for(columna=0 ; columna<N ; columna++){
data=ai_cubo[indice-1][fila][columna];
printf("t%d", data);
}
printf("%4cnn", char(65+fila));
}

67. 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("nrIngrese orden N de la matriz : "); scanf("%d", &N);
fflush(stdin);
printf("nrIngrese cantidad de arcos del resultado: "); scanf("%d", &E);
fflush(stdin);
tiempo=time(NULL);
srand(tiempo);
desde=0; hasta=1;
printf("nnPuntos de conexion de grafonn");
for(filaA=0 ; filaA<N ; filaA++)
printf("t%c", char(65+filaA));
printf("nn");
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("%4cnn", 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;

68. }
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("nnMatriz Resultadonn");
Mostrar_MatrizResultado(i, ML);
printf("nn");
system("PAUSE");
}
/***************************Fin del Programa****************************/