UNIVERSIDAD DE NARIÑO

FACULTAD DE INGENIERÍA
DEPARTAMENTO DE SISTEMAS
PROGRAMACIÓN DE COMPUTADORES

INTEGRANTES:

Yeily Yamileth Lopez Florez (220160112)

Santiago Felipe Obando Rosero (220160055)
Laura Victoria Hernandez Mozo (220160023)

Taller Fase I
Consiste en realizar la consulta acerca de cuáles son los tipos de
ordenamiento que se aplican para organizar los elementos de un
arreglo, con este material, seleccionar tres de ellos y realizar los
siguientes ejercicios.
Método burbuja:
Este método de ordenamiento funciona comparando cada
elemento del arreglo con el siguiente, intercambiando su posición
si no están correctamente ordenados, cuando se llega hasta el
final del arreglo vuelve y empieza desde el inicio del arreglo, para
este método se recorre un arreglo varias veces hasta que no sean
necesarios más cambios.
Método de inserción:
Este método consiste en que el ordenamiento empezara en la
posición 0 del arreglo y empezara a comprobar si el numero en la
posición antes de la que se evalúa es mayor, de ser así se hará el
cambio de posición, y así con todas las posiciones del arreglo, a
diferencia del anterior método en este el arreglo solo se recorre
una vez.
Método por selección:
El ordenamiento por selección funciona buscando el mínimo
elemento de todo el arreglo el cual será intercambiado por el
primer elemento del arreglo, luego de esto se buscará en el resto
del arreglo, el elemento mínimo y se intercambiará por la
segunda posición del arreglo y así sucesivamente hasta el final
del arreglo.
Taller Fase II
Ejercicio 1
Se desea conocer la potencia que consume las resistencias en un
circuito en paralelo como lo indica la figura.

Donde el voltaje de la batería es de 12V. Y la potencia de cada

resistencia se define como:

Siendo N el número que representa cada resistencia de la rama.

El programa debe realizar lo siguiente, 5 valores aleatorios para
cada una de las 3 resistencias en un rango de 100 a 1000 ohm,
recuerde que debe ser múltiplo de 10. En la salida por pantalla
se debe poder seleccionar: - Voltaje de la fuente - Valores de las
resistencias con sus respectivas potencias asociadas - Valor total
de la potencia del circuito que es igual a la suma de las potencias
en cada rama.

El programa debe además preguntar al usuario como desea

ordenar los datos, en forma ascendente o descendente según la
potencia 1, potencia 2, potencia 3 o potencia total y volver a
mostrar los datos al usuario. (Tener en cuenta la Fase I del taller)

DESARROLLO:
Análisis del problema:

Datos de entrada:
resp1: Dato numérico entero (double)
opc1: Dato numérico entero (float)
opc11: Carácter (char) opc22:
Carácter (char)
opc33: Carácter (char) opc44:
Carácter (char)

Datos de salida:
M1[i][j]: Dato numérico entero(double)

Procesos:
srand(time(NULL));
for(i=0; i<5; i++){ for( j=0; j<3; j++){
valores=(100 + rand()%(1000+3-100));
M1[i][j]=trunc(1.0 * trunc(1.0 * valores / 10) * 10.0);
}
}

//Potencias
for(i=0; i<5; i++){
for( j=3; j<6; j++){
M1[i][j]=144/(M1[i][j-3]);
}
}

//Potencia Total
for(i=0; i<5; i++){
for(j=6; j<7; j++){
M1[i][j]=M1[i][j-3]+M1[i][j-2]+M1[i][j-1];
}
}
//Imprimir matriz con resistencias aleatorios para los procesos
for(i=0; i<5; i++){
for(j=0; j<7; j++){
cout<<fixed<<setprecision(3)<<M1[i][j]<<"
"; } cout<<endl; }
system("pause"); break;

//ordenar matriz segun potencia 1,2,3 o total

for(i=0;i<5;i++){
pos=i;

aux0=M1[i][0];
aux1=M1[i][1];
aux2=M1[i][2];
aux3=M1[i][3];
aux4=M1[i][4];
aux5=M1[i][5];
aux6=M1[i][6];

while((pos>0) && (M1[pos-

1][3]>(aux3))){
M1[pos][1]=M1[pos-1][1];
M1[pos][2]=M1[pos-1][2];
M1[pos][3]=M1[pos-1][3];
M1[pos][4]=M1[pos-1][4];

M1[pos][5]=M1[pos-1][5];
M1[pos][6]=M1[pos-1][6];
pos--;
}
M1[pos][0]=aux0;
M1[pos][1]=aux1;
M1[pos][2]=aux2; M1[pos]
[3]=aux3;
M1[pos][4]=aux4;
M1[pos][5]=aux5; M1[pos]
[6]=aux6;
}
Pseudocodigo
Código Fuente:
#include<iostream>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include<conio.h> #include<iomanip>
using namespace std;

int main(){

char opc11,opc22,opc33,opc44;

int pos,resp,opc1,resp11;
double valores=0,volt=12,com,decimal,resp1;
int
i,j;
double M1[5][7],pot,aux0,aux1,aux2,aux3,aux4,aux5,aux6;
//Creacion de la matriz

//Resistencias Aleatorias
srand(time(NULL));
for(i=0; i<5; i++){
for( j=0; j<3; j++){
valores=(100 + rand()%(1000+3-100));
M1[i][j]=trunc(1.0 * trunc(1.0 * valores / 10) * 10.0);
}
}

//Potencias
for(i=0; i<5; i++){
for( j=3; j<6; j++){ M1[i]
[j]=144/(M1[i][j-3]);
}
}

//Potencia Total
for(i=0; i<5; i++){
for(j=6; j<7; j++){
M1[i][j]=M1[i][j-3]+M1[i][j-2]+M1[i][j-1];
}
}

cout<<"***********************************************************
********************************************************************
*******************************************************"<<endl;

cout<<"***********************************************************
********************************************************************
*******************************************************"<<endl;
cout<<"
PROGRAMA QUE GENERA RESISTENCIAS ALEATORIAS
"<<endl;

//do-while para hacer que el usuario finalice el

programa cuando le de la opcion 4 do{
while(resp1 != 4){

cout<<"\n1) Voltaje"<<endl; cout<<"2) Resistencias

aleatorias con sus potencias"<<endl; cout<<"3) Organizar
valores con las potencias"<<endl; cout<<"4) Salir"<<endl;
cout<<"Opcion: ";

cin>>resp1;
com=trunc(resp1);
decimal=resp1-com;
while(decimal!=0 or resp1<0 )
{
cout<<"Dato no valido, vuelva a intentar:
";cin>>resp1;
com=trunc(resp1);
decimal= resp1-com;
}
resp11=resp1;

switch(resp11){

case 1:
system("cls");
cout<<"El voltaje que maneja el circuito es de 12
V"<<endl; system("pause"); break;

case 2:
system("cls"); cout<<" Resistencias aleatorias con
sus potencias:
"<<endl;
cout<<"Creando resistencias..."<<endl<<endl;

cout<<"Resistencia1 Resistencia2 Resistencia3

Potencia1 Potencia2 Potencia3
PotenciaTotal"; cout<<endl;
//2 punto: imprimiremos la matriz con sus valores
 //Imprimir matriz

for(i=0; i<5; i++){

for(j=0; j<7; j++){

cout<<fixed<<setprecision(3)<<M1[i][j]<<"
"; }
cout<<endl; }
system("pause"); break;

//ORGANIZACION DE LAS
POTENCIAS:
case 3:
system("cls");
cout<<"\n3) Organizar valores referente a las
potencias"<<endl;
cout<<"Escoja una
opcion:"<<endl;

cout<<"\n1.Potencia 1"<<endl;
cout<<"2.Potencia 2"<<endl;
cout<<"3.Potencia 3"<<endl;
cout<<"4.Potencia Total"<<endl;
cout<<"\nOpcion: ";
cin>>opc1;

switch(opc1){
case 1:
system("cls");
cout<<"\
nOrganizacion segun potencia
1:"<<endl;
cout<<"\n1)Ascendente"<<endl;
cout<<"2)Descendente"<<endl;
cout<<"Opcion: ";
cin>>opc11;
 if(opc11 !='1'&& opc11!='2'){
while(opc11!='1'&& opc11!='2'){
cout<<"Opcion
no valida,
intente de nuevo: "; cin>>opc11;
}
}

if(opc11=='1'){ cout<<"\
nTabla:"<<endl;
cout<<"\nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";

//Imprimir matriz
for(i=0; i<5; i++){
for(j=0; j<7; j++){
cout<<fixed<<setprecision(3)<<M1[i][j]<<"
";}
cout<<endl;}

//Ordenar segun potencia 1

for(i=0;i<5;i++){
pos=i;

aux0=M1[i][0];
aux1=M1[i][1];
aux2=M1[i][2];
aux3=M1[i][3];
aux4=M1[i][4];
aux5=M1[i][5];
aux6=M1[i][6];

while((pos>0) && (M1[pos-

1][3]>(aux3))){
M1[pos][1]=M1[pos-1][1];
M1[pos][2]=M1[pos-1][2];
 M1[pos][3]=M1[pos-1][3];
M1[pos][4]=M1[pos-1][4];
M1[pos][5]=M1[pos-1][5];
M1[pos][6]=M1[pos-1][6];
pos--;
}
M1[pos][0]=aux0;
M1[pos][1]=aux1;
M1[pos][2]=aux2;
M1[pos][3]=aux3;
M1[pos][4]=aux4;
M1[pos][5]=aux5;
M1[pos][6]=aux6;
}
 cout<<"\nOrganizacion
ascendente"<<endl;
//Imprimir Matriz ordenada ascendentemente segun la
potencia 1 cout<<"\nResistencia1 Resistencia2
Resistencia3 Potencia1 Potencia2 Potencia3
PotenciaTotal\n"; for(i=0;i<5;i++){ for(j=0;j<7;j++){
cout<<M1[i][j]<<" "; }
cout<<endl; }

}
else{
cout<<"\nTabla:";
cout<<"\nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";

//Imprimir matriz
for(i=0; i<5; i++){
for(j=0; j<7; j++){

cout<<fixed<<setprecision(3)<<M1[i][j]<<" "; }
cout<<endl; }

//Ordenar segun potencia 1 for(i=0;i<5;i++){

pos=i;

aux0=M1[i][0];
aux1=M1[i][1];
aux2=M1[i][2];
aux3=M1[i][3];
aux4=M1[i][4];
aux5=M1[i][5];
aux6=M1[i][6];

while((pos>0) && (M1[pos-

1][3]>(aux3))){
 M1[pos][1]=M1[pos-1][1];
M1[pos][2]=M1[pos-1][2];
M1[pos][3]=M1[pos-1][3];
M1[pos][4]=M1[pos-1][4];
M1[pos][5]=M1[pos-1][5];
M1[pos][6]=M1[pos-1][6];
pos--;
}
M1[pos][0]=aux0;
M1[pos][1]=aux1;
M1[pos][2]=aux2;
M1[pos][3]=aux3;
M1[pos][4]=aux4;
M1[pos][5]=aux5;
M1[pos][6]=aux6;
}

cout<<"\nOrganizacion descendentemente:"<<endl;
//Imprimir Matriz ordenada
descendentemente segun la potencia 1
cout<<"\nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";
for(i=5-1;i>=0;i--){ for(j=0;j<7;j++)
{
cout<<M1[i][j]<<" "; }
cout<<endl; }
cout<<endl;
}
system("pause");
break;

case 2:
system("cls");
cout<<"\nOrganizacion segun potencia
2:"<<endl;
 cout<<"\n1)Ascendente"<<endl;
cout<<"2)Descendente"<<endl;
cout<<"Opcion: "; cin>>opc22;

if(opc22 !='1'&& opc22!='2'){

while(opc22!='1'&& opc22!='2'){
cout<<"Opcion no valida,
intente de nuevo: "; cin>>opc22;
}
}

if(opc22=='1'){ cout<<"\
nTabla:"<<endl;
cout<<"\nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";

//Imprimir matriz
for(i=0; i<5; i++){
for(j=0; j<7; j++){
cout<<fixed<<setprecision(3)<<M1[i][j]<<"
";}
cout<<endl;}

//Ordenar segun potencia 2 for(i=0;i<5;i++){

pos=i;

aux0=M1[i][0];
aux1=M1[i][1];
aux2=M1[i][2];
aux3=M1[i][3];
aux4=M1[i][4];
aux5=M1[i][5];
aux6=M1[i][6];

while((pos>0) && (M1[pos-

1][4]>(aux4))){
 M1[pos][1]=M1[pos-1][1];
M1[pos][2]=M1[pos-1][2];
M1[pos][3]=M1[pos-1][3];
M1[pos][4]=M1[pos-1][4];
M1[pos][5]=M1[pos-1][5];
M1[pos][6]=M1[pos-1][6];
pos--;
}
M1[pos][0]=aux0;
M1[pos][1]=aux1;
M1[pos][2]=aux2;
M1[pos][3]=aux3;
M1[pos][4]=aux4;
 M1[pos][5]=aux5;
M1[pos][6]=aux6;
}

cout<<"\nOrganizacion ascendente"<<endl;
//Imprimir Matriz ordenada ascendentemente segun la
potencia 2 cout<<"\nResistencia1 Resistencia2
Resistencia3 Potencia1 Potencia2 Potencia3
PotenciaTotal\n"; for(i=0;i<5;i++){ for(j=0;j<7;j++)
{ cout<<M1[i][j]<<" "; }
cout<<endl; }

}
else{
cout<<"\nTabla:";
cout<<"\
nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";

//Imprimir matriz
for(i=0; i<5; i++){
for(j=0; j<7; j++){

cout<<fixed<<setprecision(3)<<M1[i][j]<<" "; }
cout<<endl; }

//Ordenar segun potencia 2 for(i=0;i<5;i++){

pos=i;

aux0=M1[i][0];
aux1=M1[i][1];
aux2=M1[i][2];
aux3=M1[i][3];
aux4=M1[i][4];
aux5=M1[i][5];
aux6=M1[i][6];
 while((pos>0) && (M1[pos-
1][4]>(aux4))){
M1[pos][1]=M1[pos-1][1];
M1[pos][2]=M1[pos-1][2];
M1[pos][3]=M1[pos-1][3];
M1[pos][4]=M1[pos-1][4];
M1[pos][5]=M1[pos-1][5];
M1[pos][6]=M1[pos-1][6];
pos--;
}
M1[pos][0]=aux0;
M1[pos][1]=aux1;
M1[pos][2]=aux2;
M1[pos][3]=aux3;
M1[pos][4]=aux4;
M1[pos][5]=aux5;
M1[pos][6]=aux6;
}

cout<<"\nOrganizacion descendentemente:"<<endl;
//Imprimir Matriz ordenada
descendentemente segun la potencia 2
cout<<"\nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";
for(i=5-1;i>=0;i--){ for(j=0;j<7;j++)
{
cout<<M1[i][j]<<" "; }
cout<<endl; }
cout<<endl;
}
system("pause");
break;

case 3:
system("cls"); cout<<"\nOrganizacion
segun potencia
3:"<<endl;
cout<<"\n1)Ascendente"<<endl;
cout<<"2)Descendente"<<endl;
cout<<"Opcion: "; cin>>opc33;
 if(opc33 !='1'&& opc33!='2'){
while(opc33!='1'&& opc33!='2'){
cout<<"Opcion
no valida,
intente de nuevo: "; cin>>opc33;
}
}

if(opc33=='1'){ cout<<"\
nTabla:"<<endl;
cout<<"\
nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";

//Imprimir matriz
for(i=0; i<5; i++){
for(j=0; j<7; j++){
cout<<fixed<<setprecision(3)<<M1[i][j]<<"
";}
cout<<endl;}

//Ordenar segun potencia 3 for(i=0;i<5;i++){

pos=i;

aux0=M1[i][0];
aux1=M1[i][1];
aux2=M1[i][2];
aux3=M1[i][3];
aux4=M1[i][4];
aux5=M1[i][5];
aux6=M1[i][6];

while((pos>0)
&& (M1[pos-
1][5]>(aux5))){
M1[pos]
[1]=M1[pos-1][1];
 M1[pos]
[2]=M1[pos-1][2];
M1[pos]
[3]=M1[pos-1][3];
M1[pos]
[4]=M1[pos-1][4];
M1[pos][5]=M1[pos-1][5];
M1[pos][6]=M1[pos-1][6];
pos--;
}
M1[pos][0]=aux0;
M1[pos][1]=aux1;
M1[pos][2]=aux2;
M1[pos][3]=aux3;
M1[pos][4]=aux4;
M1[pos][5]=aux5;
M1[pos][6]=aux6;
}

cout<<"\nOrganizacion
ascendente"<<endl;
//Imprimir Matriz ordenada ascendentemente segun la
potencia 3 cout<<"\nResistencia1 Resistencia2
Resistencia3 Potencia1 Potencia2 Potencia3
PotenciaTotal\n"; for(i=0;i<5;i++){ for(j=0;j<7;j++){
cout<<M1[i][j]<<" "; }
cout<<endl; }
}
else{
cout<<"\nTabla:";
cout<<"\nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";

//Imprimir matriz
for(i=0; i<5; i++){
for(j=0; j<7; j++){

cout<<fixed<<setprecision(3)<<M1[i][j]<<" "; }
cout<<endl; }

//Ordenar segun potencia 3 for(i=0;i<5;i++){

pos=i;

aux0=M1[i][0];
aux1=M1[i][1];
aux2=M1[i][2];
aux3=M1[i][3];
 aux4=M1[i][4];
aux5=M1[i][5];
aux6=M1[i][6];

while((pos>0)
&& (M1[pos-
1][5]>(aux5))){
M1[pos]
[1]=M1[pos-1][1];
M1[pos]
[2]=M1[pos-1][2];
M1[pos]
[3]=M1[pos-1][3];
M1[pos]
[4]=M1[pos-1][4];
M1[pos][5]=M1[pos-1][5];
M1[pos][6]=M1[pos-1][6];
pos--;
}
M1[pos][0]=aux0;
M1[pos][1]=aux1;
M1[pos][2]=aux2;
M1[pos][3]=aux3;
M1[pos][4]=aux4;
M1[pos][5]=aux5;
M1[pos][6]=aux6;
}

cout<<"\nOrganizacion descendentemente:"<<endl;
//Imprimir
Matriz ordenada
descendentemente segun la potencia 3
cout<<"\
nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";
for(i=5-1;i>=0;i--){ for(j=0;j<7;j++)
{
cout<<M1[i][j]<<" "; }
cout<<endl; }
cout<<endl;
}
system("pause");
break;

case 4:
system("cls");
cout<<"\nOrganizacion segun potencia
total:"<<endl;
cout<<"\n1)Ascendente"<<endl;
cout<<"2)Descendente"<<endl;
cout<<"Opcion: "; cin>>opc44;

if(opc44 !='1'&& opc44!='2'){

while(opc44!='1'&& opc44!='2'){
cout<<"Opcion no valida,
intente de nuevo: "; cin>>opc44;
}
}

if(opc44=='1'){ cout<<"\
nTabla:"<<endl;
cout<<"\nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";

//Imprimir matriz
for(i=0; i<5; i++){
for(j=0; j<7; j++){
cout<<fixed<<setprecision(3)<<M1[i][j]<<"
";}
cout<<endl;}

//Ordenar segun potencia total for(i=0;i<5;i++){

pos=i;
 aux0=M1[i][0];
aux1=M1[i][1];
aux2=M1[i][2];
aux3=M1[i][3];
aux4=M1[i][4];
aux5=M1[i][5];
aux6=M1[i][6];

while((pos>0) && (M1[pos-

1][6]>(aux6))){
M1[pos][1]=M1[pos-1][1];
M1[pos][2]=M1[pos-1][2];
 M1[pos][3]=M1[pos-1][3];
M1[pos][4]=M1[pos-1][4];
M1[pos][5]=M1[pos-1][5];
M1[pos][6]=M1[pos-1][6];
pos--;
}
M1[pos][0]=aux0;
M1[pos][1]=aux1;
M1[pos][2]=aux2;
M1[pos][3]=aux3;
M1[pos][4]=aux4;
M1[pos][5]=aux5;
M1[pos][6]=aux6;
}

cout<<"\nOrganizacion
ascendente"<<endl;
//Imprimir Matriz ordenada ascendentemente segun la
potencia total cout<<"\nResistencia1 Resistencia2
Resistencia3 Potencia1 Potencia2 Potencia3
PotenciaTotal\n"; for(i=0;i<5;i++){ for(j=0;j<7;j++){
cout<<M1[i][j]<<" "; }
cout<<endl; }
}
else{
cout<<"\nTabla:";
cout<<"\nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";

//Imprimir matriz for(i=0;

i<5; i++){
for(j=0; j<7; j++){

cout<<fixed<<setprecision(3)<<M1[i][j]<<" "; }
cout<<endl; }
 //Ordenar segun potencia total for(i=0;i<5;i++)

pos=i;

aux0=M1[i][0];
aux1=M1[i][1];
aux2=M1[i][2];
aux3=M1[i][3];
aux4=M1[i][4];
aux5=M1[i][5];
aux6=M1[i][6];

while((pos>0) && (M1[pos-

1][6]>(aux6))){
M1[pos][1]=M1[pos-1][1];
M1[pos][2]=M1[pos-1][2];
M1[pos][3]=M1[pos-1][3];
M1[pos][4]=M1[pos-1][4];
M1[pos][5]=M1[pos-1][5];
M1[pos][6]=M1[pos-1][6];
pos--;
}
M1[pos][0]=aux0;
M1[pos][1]=aux1;
M1[pos][2]=aux2;
M1[pos][3]=aux3;
M1[pos][4]=aux4;
M1[pos][5]=aux5;
M1[pos][6]=aux6;
}
{ cout<<"\nOrganizacion
descendentemente:"<<endl;
//Imprimir Matriz ordenada
descendentemente segun la potencia total
cout<<"\nResistencia1
Resistencia2 Resistencia3 Potencia1 Potencia2
Potencia3 PotenciaTotal\n";
for(i=5-1;i>=0;i--){ for(j=0;j<7;j++){
cout<<M1[i][j]<<" "; }
cout<<endl; }
cout<<endl;
}
system("pause");
break;

}
case 4: break;

default:
cout<<"\nOpcion invalida, elija una opcion del 1 al 4 por
favor.\n";break;
}

}
}
while((resp1<=0)||(resp1>0)&&(resp1!=4));

cout<<"Gracias por utilizar el programa :D";

return 0;
}

Prueba de escritorio
Resp1 Validacion 1 2
Enteros R1 R2 R3 P1 P2 P3 PT
1.3 2 “12 620 840 190 0.232 0.171 0.758 1.162
volts” 630 190 230 0.229 0.758 0.626 1.613
430 600 500 0.335 0.240 0.288 0.863
910 300 500 0.158 0.480 0.288 0.926
220 500 780 0.655 0.288 0.185 1.127

3= Organizar segun: 2 4
R1 R2 R3 P1 P2 P3 PT
1: 2: 3: 4: 910 300 500 0.158 0.480 0.288 0.926
Pot1 Pot2 Pot PotT 630 190 230 0.229 0.750 0.626 1.613
Me- Me- Me- Me- 430 840 190 0.232 0.171 0.758 1.162 Fin
may may may may 910 600 500 0.335 0.240 0.288 0.863
May- May- May- May- 220 500 780 0.655 0.288 0.185 1.127
menor menor menor menor

Ejercicio 2
El valor de las resistencias viene dado por el código de colores de
sus bandas como se indica a continuación:

Elabore un programa que genere 20 resistencias con un código

de colores aleatorio para cada uno y muéstrelo al usuario con su
respectivo código. Además presente la opción de ordenar estos
valores de forma ascendente o descendente. (Tener en cuenta la
fase I del taller)
Tabla de valores de ejemplo
Tabla Ordenada descendentemente según valor

DESARROLLO:
Análisis del problema:

Datos de entrada:
opcion= dato de tipo real Datos
de salida: res_parcial= dato de
tipo decimal (double) res4=dato
de tipo entero (int) color1=dato
de tipo cadena (string)
color2=dato de tipo cadena
(string) color3=dato de tipo
cadena (string) color4=dato de
tipo cadena (string) Procesos:
Para i igual a 0 mientras sea menor a 20 aumentar i de uno en
uno
Num1 = (rand()%10) res1=
banda1[num1] color1=
bandacol1[num1] num2=
(rand()%10) res2=
banda2[num2] color2=
bandacol1[num2] num3=
(rand ()%12) res3=
banda3[num3] color3=
bandacol2[num3]
res_parcial= (res1+res2) *res3
num4= (rand ()%5) res4=
banda4[num4] color4=
bandacol3[num4] Algoritmo:
Código Fuente:
#include <iostream>
#include <stdio.h>
#include <conio.h>
#include <time.h>
#include <stdlib.h>
// Seccion de librerias
using namespace std;

int main()
{
cout<<"PROGRAMA QUE GENERA 20 RESISTENCIAS
ALEATORIAS"<<endl;
cout<<"Presione una tecla para continuar..."; getch();
int banda1[10], banda2[10], banda4[5],i; int
num1,res1,num2,res2,num3,num4,res4,a,pos,b;
float opcion;
double banda3[12],res3,arreglo[1000],aux;
double res_parcial;
string bandacol1[10],
bandacol2[12],bandacol3[5],color1,color2,color3,color4;
std::cout;

banda1[0]= 0;
banda1[1]= 10;
banda1[2]= 20;
banda1[3]= 30;
banda1[4]= 40;
banda1[5]= 50;
banda1[6]= 60;
banda1[7]= 70;
banda1[8]= 80;
banda1[9]= 90;
banda2[0]= 0; banda2[1]=
1; banda2[2]= 2;
banda2[3]= 3; banda2[4]=
4; banda2[5]= 5;
banda2[6]= 6; banda2[7]=
7; banda2[8]= 8;
banda2[9]= 9; banda3[0]=
1; banda3[1]= 10;
banda3[2]= 100;
banda3[3]= 1000;
banda3[4]= 10000;
banda3[5]= 100000;
banda3[6]= 1000000;
banda3[7]= 10000000;
banda3[8]= 100000000;
banda3[9]= 1000000000;
banda3[10]= 0.1;
banda3[11]= 0.01;

banda4[0]= 1; banda4[1]=
2; banda4[2]= 5;
banda4[3]= 10;
banda4[4]= 20;
bandacol1[0]= "Negro";
bandacol1[1]= "Marron";
bandacol1[2]= "Rojo";
bandacol1[3]= "Naranja";
bandacol1[4]= "Amarillo";
bandacol1[5]= "Verde";
bandacol1[6]= "Azul";
bandacol1[7]= "Violeta";
bandacol1[8]= "Gris";
bandacol1[9]= "Blanco";
bandacol2[0]= "Negro";
bandacol2[1]= "Marron";
bandacol2[2]= "Rojo";
bandacol2[3]= "Naranja";
bandacol2[4]= "Amarillo";
bandacol2[5]= "Verde";
bandacol2[6]= "Azul";
bandacol2[7]= "Violeta";
bandacol2[8]= "Gris";
bandacol2[9]= "Blanco";
bandacol2[10]= "Dorado";
bandacol2[11]=
"Plateado"; bandacol3[0]=
"Marron"; bandacol3[1]=
"Rojo"; bandacol3[2]=
"Dorado"; bandacol3[3]=
"Plateado"; bandacol3[4]=
"Sin Banda";

srand(time(NULL));

for(i=0; i<20;i++){
 num1= (rand()%10);
res1= banda1[num1];
color1= bandacol1[num1];

num2= (rand()%10);
res2= banda2[num2];
color2= bandacol1[num2];

num3= (rand()%12);
res3= banda3[num3];
color3= bandacol2[num3];
res_parcial= (res1+res2)*res3;
num4= (rand()%5); res4=
banda4[num4]; color4=
bandacol3[num4];
cout<<std::fixed<<"\nResistencia "<<i+1<<": "<<res_parcial<<" +/-
"<<res4<<"%"<<endl<<" Codigo de colores: "<<color1<<" -
"<<color2<<" - "<<color3<<" - "<<color4<<"\n"; arreglo[i]=
res_parcial;
}
b=0;
for(a=0;a<20;a++){
pos = a;
aux = arreglo[a];
while((pos>0)&& (arreglo[pos-1]>aux)){
arreglo[pos] = arreglo[pos-1]; pos--;
}
arreglo[pos] = aux;
}
do{
cout<<"\nDigite la opcion de como desea organizar las
resistencias:"<<endl; cout<<"1. Ascendente"<<endl; cout<<"2.
Descendente"<<endl; cout<<"3. Salir"<<endl;
cout<<"Digite la opcion: ";cin>>opcion;

if(opcion==1){
cout<<"\nOrden ascendente\n";

for(a=0;a<20;a++){
cout<<"\n"<<"Resistencia "<<a+1<<": "<<arreglo[a]<<"\n";
}

}
else if(opcion==2){
cout<<"\nOrden descendente\n";
for(a=19;a>=0;a--){

cout<<"\n"<<"Resistencia "<<b+1<<":
"<<arreglo[a]<<"\n";

b++;

}
 else if(opcion==3){
cout<<"Gracias por utilizar este programa";
}
else{
cout<<"ERROR: Digite una opcion valida";
}
}while(opcion!=3);

return 0;
}

Prueba de escritorio:
Posicione código Valor Opción = 1 Opción
s del de =5
arreglo colores
de las

resistenc
ias
arreglo [0] Rojo - 24.000000 0.920000 ERROR
Amarillo - +/- 10% : Digite
Negro - una
Plateado opción
valida

arreglo [1] Naranja - 34.000000 24.000000

Amarillo - +/- 1%
Negro -
Marrón
arreglo [2] Naranja - 30000000000 34.000000
 Negro - .000000 +/-
Blanco - 1%
Marrón
arreglo [3] Marrón - 1400.000000 110.000000
Amarillo - +/- 2%
Rojo -
Rojo
arreglo [4] Verde - 56000.00000 1400.000000
Azul - 0 +/- 2%
Naranja -
Rojo
arreglo [5] Verde - 5200.000000 2000.000000
Rojo - +/- 10%
Rojo -
Plateado
arreglo [6] Naranja - 3100000.000 5200.000000
Marrón - 000 +/- 20%
Verde -
Sin
Banda
arreglo [7] Blanco - 0.920000 +/- 30000.00000
Rojo - 2% 0
Plateado
- Rojo
arreglo [8] Azul - 620000.0000 56000.00000
Rojo - 00 +/- 1% 0

Amarillo -
Marrón
arreglo [9] Blanco - 920000000.0 350000.0000
Rojo - 00000 +/- 2% 00
Violeta -
Rojo
arreglo Negro - 2000.000000 620000.0000
[10] Rojo - +/- 1% 00
Naranja -
 Marrón
arreglo Naranja - 30000.00000 3100000.000
[11] Negro - 0 +/- 1% 000
Naranja -
Marrón
arreglo Blanco - 9800000.000 9800000.000
[12] Gris - 000 +/- 1% 000
Verde -
Marrón
arreglo Naranja - 350000.0000
[13] Verde - 00 +/- 5% 32000000.00
Amarillo - 0000
Dorado
arreglo Gris - 86000000.00 86000000.00
[14] Azul - 0000 +/- 5% 0000
Azul -
Dorado
arreglo Naranja - 32000000.00 200000000.0
[15] Rojo - 0000 +/- 2% 00000
Azul -
Rojo
arreglo Gris - 860000000.0 860000000.0
[16] Azul - 00000 +/- 2% 00000
Violeta -
Rojo
arreglo Negro - 200000000.0 920000000.0
[17] Rojo - 00000 +/- 2% 00000
Gris -
Rojo
arreglo Marrón - 110.000000 30000000000
[18] Marrón - +/- 2% .000000
Marrón -
Rojo
arreglo Amarillo - 40000000000 40000000000
[19] Negro - .000000 +/- .000000
Blanco - 2%
 Rojo

Ejercicio 3.
Suponga un arreglo con N valores de potencias generadas
aleatoriamente y mostradas en pantalla con la unidad respectiva
de medida (W), N debe ser un número impar. Mostrar en pantalla
el valor de la potencia que ocupa el centro del arreglo.

DESARROLLO:
Análisis del problema:

Datos de entrada:
dimension= variable de tipo real resp1= variable de tipo entero
resp= variable de tipo carácter pot=variable de tipo real; se
guarda el numero aleatorio generado.
d= variable de tipo entero Posm=
variable de tipo entero i = contador
para leer/recorrer el vector Datos de
salida:
V[d]= variable de tipo entero, vector de potencias

Procesos:
Primero validamos la dimensión del vector, puesto que no puede
ser negativa, cero o número decimal, luego la dimension la
dividimos entre 2 le sumamos una unidad para conocer la
posición de la potencia central, por ende, ya podemos generar el
valor de la potencia central Seudocódigo:
Código Fuente:
#include <iostream>
#include <math.h>
#include <time.h>
#include <stdlib.h>

using namespace std;

int main(){
float
dimension; int
resp1; char resp;
float pot;
do{
resp=0;
srand(time(NULL));

cout<<"===========================================
=================="<<endl;
cout<<"Ingrese la dimension del vector (debe ser un numero
impar) : ";
do{
resp1=0;
cin>>dimension;
if(dimension>0){
if(dimension==trunc(dimension)){
int d;
 d=dimension;

if(d%2!=0){
int V[d];
int posm;
posm=(d/2)+1;
cout<<endl;

for(int i=1; i<=d; i++){

pot= rand();
V[i]=pot;
cout<<"* Potencia "<<i<<":
"<<V[i]<<" W"<<"\n";

if(d==1){
cout<<endl<<"Solo ha sido generado un
valor, no hay un valor central!"<<endl;
}else{
cout<<endl<<"-------------------------------
--------------------------"<<endl;
cout<<"*La potencia "<<posm<<" esta en el
centro de la lista, su valor es :"<<V[posm]<<" W";

}
 }else{
cout<<endl<<"La dimension debe
ser impar! "<<endl;
cout<<endl<<"Ingrese de nuevo la
dimension : ";
resp1=1;
}
}else{
cout<<endl<<"La dimension debe ser
un numero entero! "<<endl;
cout<<endl<<"Ingrese de nuevo la
dimension : ";
resp1=1;
}
}else{
cout<<endl<<"La dimension debe ser positiva!"<<endl;
cout<<endl<<"Ingrese de nuevo la dimension
: ";
resp1=1;
}

}while(resp1==1);

cout<<endl<<endl<<"--Desea ejecutar nuevamente el

programa? (s/n)--";
cin>>resp;
system("cls");
 }while(resp=='s');

return 0;
}

Prueba de escritorio:

Dimens Potencias Potencia Resultado esperado?

ión central
5 * Potencia *La potencia 3 Si
1: 12969 W está en el
centro de la
* Potencia
lista, su valor
2: 27565 W
es :26183 W
* Potencia
3: 26183 W
* Potencia
4: 6845 W
* Potencia
5: 4345 W
8 Mensaje de error:
La dimensión debe ser impar!

Ingrese de nuevo la dimensión :

-6 Mensaje de error:
 La dimensión debe ser positiva!

Ingrese de nuevo la dimensión:

5.8 Mensaje de error:

La dimensión debe ser un numero entero!

Ingrese de nuevo la dimensión:

3 * Potencia *La potencia 2 si
1: 13874 W está en el
centro de la
* Potencia
lista, su valor
2: 22985 W
es :22985 W
* Potencia
3:
26590 W

Ejercicio 4.
Realizar un programa que registre en 2 listas N números de
códigos de estudiantes, las personas se inscribirán en una o en
las dos listas, la primera lista va a pertenecer a los inscritos a la
materia de Circuitos 1 y la segunda a los inscritos a la materia de
Simulación y Medidas 2. Mostrar en pantalla: - El número de
inscritos a la primera y segunda lista. - Los datos de la primera o
segunda lista ordenados (tener en cuenta a fase I del taller) -
Mostrar una tercera lista en la que me aparezcan los códigos de
los estudiantes que se encuentran inscritos en las dos materias.

DESARROLLO:
Análisis del problema:
Datos de entrada:

Estudiantes: variable de tipo real (dimensión del vector de

estudiantes de la materia de circuitos)
Simulacion: variable de tipo real (dimensión del vector de
estudiantes de la materia de simulacion)
e,em,sim,s,j: variables de tipo entero (contadores para recorrer
los vectores) es,am: variables de tipo entero
pos,aux pos1,aux1:variables de tipo entero, auxiliares para
ordenar los vectores resp,cod,resp1,resp2,ban: variables de
tipo entero(banderas)

Datos de salida:
I[e]: vector de estudiantes de circuitos
S[s]: vector de estudiantes de simulacion
A[am]: vector de estudiantes que estan en ambas materiaas
Procesos:
Primero validamos la dimensión del vector de estudiantes, que
debe ser mayor de cero y un número entero, luego pedimos el
ingreso de los códigos de los estudiantes y estos los validamos,
deben ser un numero entero, positivo debe estar en un rango de
220000000 hasta 220999999; además no se deben repetir puesto
que un estudiante no puede estar 2 veces en la misma materia,
luego los ordenamos por el método de inserción por último
buscamos los comunes entre las 2 materias.
Seudocódigo:
Código Fuente:
#include <iostream>
#include <math.h>
#include <stdlib.h>
#include<iomanip> using namespace std;
int main(){ float
estudiantes,simulacion; int
es,e,em,am,pos,aux,sim,s,pos1,aux1,j;
int resp,cod,resp1,resp2,ban; cout<<endl;

cout<<"===========================================
======================================"<<endl;
cout << "*Ingrese la cantidad de estudiantes inscritos en la
materia de Circuitos I : " ; do{
cin >>estudiantes;//dimension del vector de estudiantes
de circuitos resp1=0; //bandera para volver a ingresar el
numero de estudiantes if(estudiantes>0)
{ if(estudiantes==trunc(estudiantes))
{ es=estudiantes; float I[es];
cout<<endl; cout<<"*Ingrese los
codigos de los estudiantes:
"<<endl<<endl;

for(e=0;e<es;e++){

do{
cod=0;
cout<<endl;

cout<<"Estudiante "<<e+1<<" : ";cin>>I[e];

if(I[e]==trunc(I[e])){

if(I[e]>=220000000 ){
if(I[e]<=220999999){
//verificamos que un estudiante
no esté 2 veces en la misma materia

for(j=0;j<es;j++){
 if(I[e]==I[j] && e!=j){ cout<<"El dato ya ha
sido ingresado, vuelva a ingresar un dato diferente : "<<endl;
cod=1;
}
}

}else{
cod=1;//bandera para volver a ingresar el codigo de los
estudiantes
cout<<endl<<"Vuelva a ingresar el codigo
:"<<endl;
}

}else{
cod=1;//bandera para volver a ingresar el codigo de los
estudiantes cout<<endl<<"Vuelva a
ingresar el codigo
:"<<endl;
}

}else{
cod=1;
cout<<endl<<"Vuelva a ingresar el codigo :"<<endl;
}

}while(cod==1);
}
//ordenamiento del vector
for(e=0;e<es;e++){
pos=e;
aux=I[e];
while (pos>0 && (I[pos-1]>aux)){
I[pos]=I[pos-1]; pos--;
}
 I[pos]=aux;
}
//MATERIA DE SIMULACION
do{

cout<<"===========================================
================================================="<<en
dl;
cout << "*Ingrese la cantidad de estudiantes inscritos
en la materia de Simulacion y medidas II : " ; cin
>>simulacion;//dimension

resp2=0;//bandera para verificar la dimension del

vector if(simulacion>0){
if(simulacion==trunc(simulacion)){
sim=simulacion;
float S[sim];
cout<<endl;
cout<<"*Ingrese los codigos de los estudiantes:
"<<endl<<endl;

for(s=0;s<sim;s++){
do{
cod=0;
cout<<endl;
cout<<"Estudiante "<<s+1<<" : ";cin>>S[s];
if(S[s]<220000000 || S[s]>220999999){
cod=1;
cout<<"Vuelva a ingresar el codigo :";
}
if(cod==0){ for(j=0;j<sim;j++){
if(S[s]==S[j] && s!=j){ cout<<"El dato ya ha sido
ingresado, vuelva a ingresar un dato diferente : "<<endl;
cod=1;
}
}
}
}while(cod==1);
}
//ordenamiento
for(s=0;s<sim;s++){
pos1=s;
aux1=S[s];
while (pos1>0 && (S[pos1-1]>aux1)){
S[pos1]=S[pos1-1]; pos1--;
}
S[pos1]=aux1;
}

//estudiantes inscritos
cout<<"*****************************************************"<<endl;
cout<<"Los estudiantes inscritos a Simulacion y medidas II
:"<<endl; for(s=0;s<sim;s++){
cout.precision(0);

cout<<fixed<<"* "<<S[s]<<endl;
}
cout<<"********************************************"<<endl;
cout<<"Los estudiantes inscritos a Circuitos I :"<<endl;
for(e=0;e<es;e++){ cout.precision(0);

cout<<fixed<<"* "<<I[e]<<endl;
}

//ESTUDIANTES QUE ESTAN EN AMBAS MATERIAS

am=0; //dimension del vector donde estan los

estudiantes de ambas materias int A[am];
for(e=0;e<es;e++){
for(s=0;s<sim;s++){
ban=0;
if(I[e]==S[s] && ban==0){
 A[am]=I[e];
am=am+1;
ban=1;
s=sim;
}
}
}

if(am>0){

cout<<"******************************************************"<<e
ndl;
cout<<"Los estudiantes marciculados en ambas
materias son : "<<endl;
for(em=0;em<am;em++){
cout.precision(0);

cout<<fixed<<"* "<<A[em]<<endl;
}
}else {

cout<<endl<<"NO HAY ESTUDIANTES INSCRITOS EN

AMBAS MATERIAS";
}

}else{
cout<<" Ingrese correctamente el numero de estudiantes :
";
resp2=1;
}
}else{
cout<<" Ingrese correctamente el numero de estudiantes :
";
resp2=1;
}
}while(resp2==1);

}else{ cout<<" Ingrese correctamente el numero

de estudiantes : "; resp1=1;
}
}else{
cout<<" Ingrese correctamente el numero de estudiantes :
";
resp1=1;
}

}while(resp1==1);

Prueba de escritorio:
Dime Códig Dime Codig Estud Estud Estud R.E
nsión os: nsion( os: iantes iantes iantes
(circu simul de de que
itos) ación) circui simul estan
tos(or acion( en

denad orden amba

os) ados) s
mater
ias
3 *2201 4 *2201 *2201 *2201 *2201 Si
60112 60069 60069 40412 60069
*2203 *2201 *2201 *2201 *2201
45782 67238 60112 60069 60112
*2201 *2201 *2203 *2201
60069 60112 45782 60112
 *2201 *2201
40412 67238

0 Mensaje de error:
Ingrese correctamente el número de estudiantes
-5 Mensaje de error:
Ingrese correctamente el número de estudiantes
3 *2201 6.3 Mensaje de error:
24562 Ingrese correctamente el número de
*2203 estudiantes
24522
*2201
43569
3 *2201 Mensaje de error:
24562 Vuelva a ingresar el codigo :
*2203
24522
*2234
84727
4 *2201 7 *2201 Mensaje de error:
24562 24562 Vuelva a ingresar el código
*2203 *2299
39753 99999
*2201
25767
*2203
33793
7 *2201 Mensaje de error:
24562 El dato ya ha sido ingresado, vuelva a ingresar
*2201 un dato diferente :
24562

3.5 Mensaje de error:

Ingrese correctamente el numero de estudiantes
5 *-8 Mensaje de error:
Vuelva a ingresar el código
3 *2203 2 *26.44 Mensaje de error:
54466 Vuelva a ingresar el código
*2205
53576
*2201
34655