Fundamentos de la programacion u2 ejercicios

958 views

Published on

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.

0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
958
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
81
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Fundamentos de la programacion u2 ejercicios

  1. 1. Capítulo 10EJERCICIOS DEAUTOEVALUACION 10.1 Arreglos Unidimensionales 10.2 Arreglos Bidimensionales 10.3 Cadenas 10.4 Ejercicios Varios
  2. 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 connumeros 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. 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 connumeros al azar. Muestre el Mayor y Menor elemento con susrespectivas 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. 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 connumeros 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. 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 cerofor(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 azarse desea llevar dicho contenido a otros 2 vectores uno con todos losmú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. 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. 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 connumeros al azar. Diga si el promedio de los numeros pares es mayoral 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. 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 connumeros 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. 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. 10. /**********************Inicio del Programa***************************Ejercicio 10: Se tiene un vector de N elementos de tipo entero connumeros al azar. Muestre la cantidad de digitos pares e impares queexiste 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****************************/
  11. 11. /**********************Inicio del Programa***************************Ejercicio 12: Se tiene un vector de N elementos de tipo entero connumeros 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");
  12. 12. }/***************************Fin del Programa****************************//**********************Inicio del Programa***************************Ejercicio 12: Se tiene un vector de N elementos de tipo entero connumeros al azar. Se pide realizar realizar la insercion ordenada deun 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;
  13. 13. 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 connumeros al azar. Se pide realizar realizar la eliminacion deelementos 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");
  14. 14. 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 connumeros al azar. Se pide realizar la eliminacion deelementos 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 visualizacionfor(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");//Eliminacionfor(i=0 ; i<N-1 ; i++)
  15. 15. 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****************************/
  16. 16. /**********************Inicio del Programa***************************Ejercicio 15: Se tiene un vector de N elementos de tipo entero connumeros al azar. Se pide realizar la eliminacion de elementospor 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***************************
  17. 17. Ejercicio 16: Se tiene un vector de N elementos de tipo entero connumeros 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 connumeros al azar. Se pide realizar la generacion de elementos sinrepeticion.*********************************************************************/#include <iostream>using namespace std;#include "stdlib.h"#include "time.h"
  18. 18. 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"
  19. 19. 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 connumeros al azar. Se pide realizar un programa para determinar siun 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);
  20. 20. 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, seencontraban en una incertidumbre porque no sabian quien era elencargado que tenia que ir a hablar con el director para pedir laautorizacion 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 alfabeticoa 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 teniaque avanzar incluyendose el mismo hacia el lado izquierdo el alumnoes deacartado pero antes de salir de su posicion tira los dados,el juego acaba cuando queda un solo alumno.*********************************************************************/#include <iostream>using namespace std;
  21. 21. #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****************************/
  22. 22. /**********************Inicio del Programa***************************Ejercicio 21: Mostrar la cantidad de veces que se repite los numerosentre (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***************************
  23. 23. Ejercicio 1: Se tiene una matriz de orden N*M de tipo entero, se pidegenerar 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****************************/
  24. 24. /**********************Inicio del Programa***************************Ejercicio 2: Se tiene una matriz de orden N*M de tipo entero con numerosal 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 connumeros al azar, se pide encontrar el mayor y menor elemento porfila y por columna.
  25. 25. *********************************************************************/#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****************************/
  26. 26. /**********************Inicio del Programa***************************Ejercicio 4: Se tiene una matriz de orden N*M de tipo entero connumeros 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 connumeros al azar, se pide encontrar la suma de los elementos dela periferie de la matriz.*********************************************************************/
  27. 27. #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 connumeros al azar, se pide encontrar la suma de los elementos queno pertenecen la periferie de la matriz.*********************************************************************/#include <iostream>using namespace std;#include "stdlib.h"#include "time.h"
  28. 28. 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 connumeros al azar, Mostrar la suma de los elementos de la diagonalprincipal 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);
  29. 29. 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****************************/
  30. 30. /**********************Inicio del Programa***************************Ejercicio 8: Se tiene una matriz de orden N*M de tipo entero connumeros al azar, se pide realizar el concepto de matriz transpuesta.*********************************************************************//*ANALISIS:Matriz transpuesta es transponer los elementos de las filas a lascolumnas 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****************************/
  31. 31. /**********************Inicio del Programa***************************Ejercicio 9: Se tiene una matriz cuadrada de orden N de tipo entero connumeros al azar, se pide realizar la suma de la matriz triangularsuperior.*********************************************************************//*ANALISIS:Matriz triangular superior son los elementos por encima de ladiagonal principal inclusive.Ejm:Matriz2 3 41 3 23 2 4Matriz 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");}
  32. 32. /***************************Fin del Programa****************************//**********************Inicio del Programa***************************Ejercicio 10: Se tiene una matriz cuadrada de orden N de tipo entero connumeros al azar, se pide realizar la suma de la matriz triangularinferior.*********************************************************************//*ANALISIS:Matriz triangular inferior son los elementos por debajo de ladiagonal principal inclusive.Ejm:Matriz2 3 41 3 23 2 4Matriz triangular inferior:21 33 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;
  33. 33. 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 connumeros al azar, se pide realizar la suma de los elementos que nopertencen a la matriz triangular superior.*********************************************************************//*ANALISIS:No Matriz triangular superior son los elementos por debajo de ladiagonal principal.Ejm:Matriz2 3 41 3 23 2 4No Matriz triangular superior:13 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]); }
  34. 34. }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 connumeros al azar, se pide realizar la suma de los elementos que nopertencen a las diagonales.*********************************************************************//*ANALISIS:No diagonales son los elementos que no se encuentran en la diagonalprincipal y la secundaria.Ejm:Matriz2 3 41 3 23 2 4No diagonales: 31 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);
  35. 35. 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****************************/
  36. 36. /**********************Inicio del Programa***************************Ejercicio 13: Se tiene una matriz cuadrada de orden N de tipo entero connumeros 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 connumeros al azar, se pide invertir el contenido de sus columnas.
  37. 37. *********************************************************************/#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 connumeros al azar, se pide mostrar el promedio de los elementos parese impares siempre y cuando la suma de sus indices sea par e imparrespectivamente.
  38. 38. *********************************************************************/#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*Qambos de tipo entero con numeros al azar, se pide realizar el conceptode Producto de Matrices.*********************************************************************/#include <iostream>using namespace std;#include "stdlib.h"
  39. 39. #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****************************/
  40. 40. /**********************Inicio del Programa***************************Ejercicio 17: Se tiene una matriz cuadrada de orden Ntipo 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****************************/
  41. 41. 10.3 Cadenas/**********************Inicio del Programa***************************Ejercicio 1: Ingrese una cadena de caracteres por teclado, desarrollela 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, desarrollela 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);
  42. 42. system("PAUSE");}/***************************Fin del Programa****************************//**********************Inicio del Programa***************************Ejercicio 3: Ingrese una cadena de caracteres por teclado, desarrollela 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, desarrollela 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);
  43. 43. 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, desarrollela 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");}
  44. 44. /***************************Fin del Programa****************************//**********************Inicio del Programa***************************Ejercicio 6: Ingrese una cadena de caracteres por teclado, desarrollela 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, desarrollela 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);
  45. 45. 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, desarrollela 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****************************/
  46. 46. /**********************Inicio del Programa***************************Ejercicio 9: Ingrese una cadena de caracteres por teclado, muestrelode la siguiente forma:Palabra=> WORDSalida: 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, muestrelode la siguiente forma:Palabra=> EXCELSalida: E EX EXC EXCE EXCEL*********************************************************************/#include <iostream>using namespace std;void main(){const int LongitudMax = 100;char cadena[LongitudMax];int i, j, L;
  47. 47. 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, muestrelode la siguiente forma:Palabra=> EXCELSalida: 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****************************/
  48. 48. /**********************Inicio del Programa***************************Ejercicio 12: Ingrese una cadena de caracteres por teclado, muestrelode la siguiente forma:Palabra=> HOLASalida: 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, realiceuna 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 palabrachar *elimina(char cad[]){int i,j,k;i=strlen(cad);//i-1 para que no considere al ultimo caracter DE LA ULTIMA PALABRAfor(j=0 ; j<i-1 ; j++) if(j==0){ //j==0 para que elimine al primer caracter
  49. 49. 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 Principalvoid 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, realiceuna funcion que elimine todas las vocales de la cadena.*********************************************************************/#include <iostream>using namespace std;//funcion para eliminar las vocaleschar *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++)
  50. 50. cad[k-1]=cad[k]; j--; i--; } } return (cad);}//Procedimiento Principalvoid 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, realiceuna funcion que diga si la palabra es palindromo o no.Recordar que una palabra es palindromo si se lee igual de izquierdaa 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****************************/
  51. 51. /**********************Inicio del Programa***************************Ejercicio 16: Ingrese una cadena de caracteres, realice una funcionque elimine los espacios, la funcion debe retornar la cantidad deespacios eliminados.Ejemplo:" Si tienes alguna duda sobre el uso de este programa, acude a la paginaoficial del programa, o pregunta en la lista de correo "Resultado"Si tienes alguna duda sobre el uso de este programa, acude a la paginaoficial del programa, o pregunta en la lista de correo"La funcion devolvera: 12*********************************************************************/#include <iostream>using namespace std;//Procedimiento para reemplazar espaciosvoid 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 espaciosint 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){
  52. 52. 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****************************/
  53. 53. 10.4 Ejercicios Varios/**********************Inicio del Programa***************************Ejercicio 1: SIMPLIFICADOR DE PALABRASElaborar un programa que simplifique una expresion formada con las letrasA, 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 BEl significado de esta tabla es la sgte:Si se ingresa :ABEl resultado es :C (ya que el producto<interseccion> de AB es C)Si se ingresa :AACBEl resultado es :CPues 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 primerafila y en la primera columna entonces el resultado esta en lainterseccion.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;
  54. 54. 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); }//Operacionfor(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****************************/
  55. 55. /**********************Inicio del Programa***************************Ejercicio 2: Dos numeros se dicen amigos cuando uno de ellos es iguala 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, permitadicernir si dos numeros (parametros) son amigos.b) Usar otra funcion para calcular la suma de los divisores de unnumero determinado.c) Hacer referencia a dichas funciones desde un programa o desde otrosubprograma*********************************************************************/#include <iostream>using namespace std;#include "stdlib.h"#include "time.h"//Funcion para extraer la suma de divisoreslong 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 amigosbool 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 Principalvoid main(){long n, m;printf("Ingrese 1er #..");scanf("%ld",&n); fflush(stdin);
  56. 56. 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 digitosque ha sido generado aleatoriamente por la computadora. El jugadortiene 6 oportunidades, y en cada una de ellas imprimira los siguientesmensajes:-Si algun digito se encuentra en el numero, y esta en posicion correctase debera imprimir y.-Si algun digito se encuentra en el numero, pero no esta en la posicioncorrecta, se debera imprimir una x.Ejemplo:Supongamos que el numero sea 28635 y el numero ingresado es 38165. Lacomputadora mostrara por pantalla xy1xySi al final de los seis intentos no se acierta con m se debera mostrarel 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;
  57. 57. 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);}
  58. 58. 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 MENSAJESElaborar un programa para codificar mensajes con la sgte clave:Se intercambia el caracter en blanco con el simbolo @, para las letras A-M conlas letras N-Z y las letras N-Z con A-M, los otros carceteres se dejan intactos.EjemploMensaje: HOLA COMO TE VACODIFICADO: 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");
  59. 59. }/***************************Fin del Programa****************************//**********************Inicio del Programa***************************Ejercicio 5: JUEGO 21Se tiene un juego de cartas en las cuales se han separado las cartascon letras (J=11, Q=12, K=13). Es decir solo se cuentan con 4 rangosde numeros (1-11) corazones, espadas, treboles, diamantes.El juego consiste en asignar a un banquero (PC) el que reparte lascartas 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 turnodel banquero.Gana el que acumula exactamente 21Gana el banquero si el retador acumulo igual al banqueroGana el que se aproxime mas a 21.Para que sea aleatorio y variados las cartas, al iniciar el juegose 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++)
  60. 60. 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{
  61. 61. printf("nnrCartas disponibles: %dnn", Cantidad_MazoCartas_Disponibles());//Turno del retadorlongitud_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 Banquerolongitud_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");
  62. 62. 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 pidellevar 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;
  63. 63. 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: GRAFOSSe tiene una matriz cuadrada de orden N de tipo entero que representaun 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 unpunto (a,b) pasando por E arcos.*********************************************************************//*ANALISIS
  64. 64. SE UTILIZA EL CONCEPTO DE PRODUCTO DE MATRICES.ML=A B C D0 0 1 1 A1 0 0 1 B0 1 0 0 C0 0 1 0 DSI E=2MLxML=0 0 1 1 0 0 1 11 0 0 1 X 1 0 0 10 1 0 0 0 1 0 00 0 1 0 0 0 1 0MLxML=A B C D0 1 1 0 A0 0 2 1 B1 0 0 1 C0 1 0 0 DExisten 1 forma de ir de A hacia B pasando por dos arcosExisten 2 forma de ir de C hacia B pasando por dos arcosExisten 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 GLOBALESconst int OrdenMax = 10;int N, E;//PROCEDIMIENTOSvoid 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)); }
  65. 65. 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 PRINCIPALvoid 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 cuadradofor(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;
  66. 66. }Asignar_Matriz(i, ML, B);if(E==2) goto final;//Al cubofor(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 > 3for(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****************************/

×