ejercicios práctico 1
DESCRIPTION
ProgramacionTRANSCRIPT
// DESCRIPCION: Ej:1// Primer ejercicio introductorio. Realiza la suma 7 + 3 y muestra el// resultado por pantalla.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA: FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//======================// Inicio del algoritmo//======================
cout << 7+3; // Muestra el resultado de evaluar 7 + 3.
return 0; // Retorno de la función.}//--- FIN --------------------------------------------------------------/ DESCRIPCION: Ej. 2//Declara dos constantes, las suma y muestra el resultado por pantalla.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const int A=7;const int B=3;
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA: FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//======================// Inicio del algoritmo//======================cout << A+B; // Muestra el resultado de evaluar 7 + 3.
return 0; // Retorno de la función.}
1
///// FIN /////////////////////////////////////////////////////////////// DESCRIPCION: Ej 3// Declara dos constantes, las suma y muestra el resultado por pantalla// con un cartel aclaratorio.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const int A=7;const int B=3;
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//======================// Inicio del algoritmo//======================cout << "7 + 3 = " << A+B << endl; // Muestra elresultadode evaluar // 7 + 3.return 0; // Retorno de la funcion.
}
///// FIN //////////////////////////////////////////////////////////////
/ DESCRIPCION: Ej 4// Declara dos constantes, las suma, guarda el resultado en una variable// y lo muestra por pantalla con un cartel aclaratorio.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const int A=7;const int B=3;
2
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//---------------------------------------------// Declaracion de variables locales al main()//---------------------------------------------int resultado;
//======================// Inicio del algoritmo//======================
//-----------------------// Calculo del resultado
//-----------------------
resultado = A+B; // Asignacion de la suma a la variable "resultado".
cout << "7 + 3 = " << resultado; // Muestra la variable "resultado".
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 5// Declara dos variables, le asigna valor por programa, calcula la suma,// guarda el resultado en otra variable y lo muestra por pantalla con un// cartel aclaratorio.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//-----------------------------------------// Declaracion de variavles locales main()//-----------------------------------------int A;int B;int resultado;
3
//======================// Inicio del algoritmo//======================A=7; // Asigna el valor 7 a la variable A.B=3; // Asigna el valor 3 a la variable B.resultado = A+B; //Asigna la suma de A y B a la variable "resultado".
cout << "7 + 3 = " << resultado << endl; // Muestra la variable // "resultado".
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 6// Declara dos variables, pide al usuario que les asigne valores,// calcula la suma, guarda el resultado en otra variable y lo muestra// por pantalla con un cartel aclaratorio.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA: FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//-----------------------------------------// Declaración de variables locales main ()//-----------------------------------------int A;int B;int resultado;
//======================// Inicio del algoritmo//======================
//--------------------------// Lectura de la variable A//--------------------------cout << "Ingrese el valor de A: ";cin >> A;
4
//--------------------------// Lectura de la variable B//--------------------------cout << "Ingrese el valor de B: ";cin >> B;
//----------------------- // Calculo del resultado //-----------------------
resultado = A+B; //Asigna la suma de A y B a la variable "resultado".
//---------------------------------- // Puesta del resultado en pantalla //----------------------------------
cout << A << "+" << B << "=" << resultado << endl;
return 0; // Retorno de la funcion.}//--- FIN --------------------------------------------------------------
/ DESCRIPCION: Ej 7Muestra un cartel por pantalla.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA: FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//======================// Inicio del algoritmo//======================cout << "Hola Mundo" << endl; // Muestra un cartel por pantalla.
return 0; // Retorno de la función.}
///// FIN //////////////////////////////////////////////////////////////
/ DESCRIPCION: Ej 8// Muestra un cartel, asignado a una constante, por pantalla.//======================================================================#include <iostream>
5
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char CARTEL[]="HOLA MUNDO";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//======================// Inicio del algoritmo//======================cout << CARTEL << endl; // Muestra la constante por pntalla.
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 9// Declara una variable de tipo cadena, le pide al usuario que le asigne// un texto y lo muestra por pantalla.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE1[]="Por favor ingrese su nombre: ";const char MENSAJE2[]="Bienvenido ";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA: FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------char Nombre[80];
//======================
6
// Inicio del algoritmo//======================
//--------------------// Ingreso del nombre//--------------------cout << MENSAJE1;cin.getline(Nombre,80);
//----------------------// Saludo de bienvenida//----------------------cout << MENSAJE2 << Nombre << endl;
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 10// Declara una variable de tipo cadena, le pide al usuario que le asigne// un texto y lo muestra por pantalla.//======================================================================#include <iostream>
using namespace std;//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE1[]="Por favor ingrese su nombre: ";const char MENSAJE2[]="Bienvenido ";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------char Nombre[80];
//======================// Inicio del algoritmo//======================//--------------------// Ingreso del nombre
7
//--------------------puts(MENSAJE1); // Muestra el primer mensaje.gets(Nombre); // Lee el nombre.
//----------------------// Saludo de bienvenida//----------------------puts(MENSAJE2);puts(Nombre);
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 11// Pide el ingreso de dos numeros e informa si su suma es menor a 11.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE1[]="Por favor ingrese un n£mero: ";const char MENSAJE2[]="Por favor ingrese otro: ";const char MENSAJE3[]="INGRESO CORRECTO.";const char MENSAJE4[]="ERROR!... Suma fuera de rango";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------int N1; // Primer numero.int N2; // Segundo numero
//======================// Inicio del algoritmo//======================//-----------------------// Ingreso de lo numeros//-----------------------
8
puts(MENSAJE1); // Muestra el primer mensaje.cin >> N1; // Ingresa el primer numero por teclado.
puts(MENSAJE2); // Muestra el segundo mensaje.cin >> N2; // Ingresa el segundo numero por teclado.
//----------------------// Calculo y evaluacion//----------------------if(N1+N2 < 11){ // La suma esta dentro del rango.
puts(MENSAJE3);}else{ // La suma esta fuera de rango.
puts(MENSAJE4);}
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 12// Pide el ingreso de tres numeros e informa cual es el mayor.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE1[]="Por favor ingrese un n£mero: ";const char MENSAJE2[]="Por favor ingrese otro: ";const char MENSAJE3[]="EL MAYOR ES: ";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------int N1; // Primer numero.
9
int N2; // Segundo numero.int N3; // Tercer numero.
//======================// Inicio del algoritmo//======================//-----------------------// Ingreso de lo numeros//-----------------------cout << MENSAJE1; // Muestra el primer mensaje.cin >> N1; // Lee el primer numero por teclado.
cout << MENSAJE2; // Muestra el segundo mensaje.cin >> N2; // Lee el segundo numero por teclado.
cout << MENSAJE2; // Muestra el tercer mensaje.cin>> N3; // Lee el tercer numero por teclado.
//----------------------// Calculo y evaluacion//----------------------cout << MENSAJE3;
if(N1>N2){
if(N1>N3){
cout << N1 << endl;}else{
cout << N3 << endl;}
}else{
if(N2>N3){
cout << N2 << endl;}else{
cout << N3 << endl;}
}
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
10
// DESCRIPCION: Ej 13// Pide el ingreso de tres numeros e informa cual es el mayor. Realiza// las comparaciones utilizando el operador && (AND).//// Restricciones: si hay dos mayores, mostrar el primero de ellos.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE1[]="Por favor ingrese un n£mero: ";const char MENSAJE2[]="Por favor ingrese otro: ";const char MENSAJE3[]="EL MAYOR ES: ";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------int N1; // Primer numero.int N2; // Segundo numero.int N3; // Tercer numero.
//======================// Inicio del algoritmo//======================//-----------------------// Ingreso de lo numeros//-----------------------cout << MENSAJE1; // Muestra el primer mensaje.cin >> N1; // Lee el primer numero por teclado.
cout << MENSAJE1; // Muestra el segundo mensaje.cin >> N2; // Lee el segundo numero por teclado.
cout << MENSAJE1; // Muestra el tercer mensaje.cin >> N3; // Lee el tercer numero por teclado.
//----------------------//// Calculo y evaluacion ////----------------------//
11
cout << MENSAJE3;
if(N1>=N2 && N1>=N3){
cout << N1 << endl;}else{
if(N2>=N1 && N2>=N3){
cout << N2 << endl;}else{
cout << N3 << endl;}
}
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 14// Pide el ingreso de un numero e informa si esta fuera del rango 10..30//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE1[]="Por favor ingrese un n£mero: ";const char MENSAJE2[]="CORRECTO!... Esta fuera del rango.";const char MENSAJE3[]="ERROR!... Esta dentro del rango.";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(void){
//----------------------------------// Declaracion de variables locales//----------------------------------int N1; // numero a verificar.
//======================
12
// Inicio del algoritmo//======================//--------------------// Ingreso del numero//--------------------cout << MENSAJE1; // Muestra el primer mensaje.cin >> N1; // Lee el numero por teclado.
//----------------------// Calculo y evaluacion//----------------------
if(N1<10){ // El numero esta fuera de rango porque es menor a 10.
cout << MENSAJE2 << endl;}else{
if(N1>30){ // El numero esta fuera de rando porque es mayor a 30.
puts(MENSAJE2);}else{ // El numero esta dentro del rango 10..30.
puts(MENSAJE3);}
}
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 15// Pide el ingreso de un numero e informa si esta fuera del rango 10..30.// Utiliza el operador || (OR).//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE1[]="Por favor ingrese un n£mero: ";
13
const char MENSAJE2[]="CORRECTO!... Esta fuera del rango.";const char MENSAJE3[]="ERROR!... Esta dentro del rango.";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------int N1; // Numero a verificar.
//======================// Inicio del algoritmo//======================//--------------------// Ingreso del numero//--------------------cout << MENSAJE1; // Muestra el primer mensaje.cin >> N1; // Lee el numero a testear por teclado.
//----------------------// Calculo y evaluacion//----------------------
if(N1<10 || N1>30){ // El numero esta fuera de rango porque es menor a 10 o mayor a 30.
puts(MENSAJE2);}else{ // El numero esta dentro del rango.
puts(MENSAJE3);}
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 16// Pide el ingreso de un numero de 1 a 7 e informa a que dia de la// semana corresponde.//// Restricciones: El numero debe ser validado para que se encuentre// dentro del rango 1..7
14
//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE1[]="Por favor ingrese un numero entero de 1 a 7: ";const char MENSAJE2[]="El numero ingresado corresponde al dia ";const char MENSAJE3[]="El numero ingresado no corresponde a un dia.";const char DIA1[]="LUNES.";const char DIA2[]="MARTES.";const char DIA3[]="MIERCOLES.";const char DIA4[]="JUEVES.";const char DIA5[]="VIERNES.";const char DIA6[]="SABADO.";const char DIA7[]="DOMINGO.";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------int N1; // Numero a verificar.
//======================// Inicio del algoritmo//======================//--------------------// Ingreso del numero//--------------------cout << MENSAJE1; // Muestra el primer mensaje.cin >> N1; // Lee el numero por teclado.
//-----------------------// Determinacion del dia//-----------------------switch(N1){
case 1: cout << MENSAJE2;cout << DIA1 << endl;break;
case 2: cout << MENSAJE2;cout << DIA2 << endl;
15
break;case 3: cout << MENSAJE2;
cout << DIA3 << endl;break;
case 4: cout << MENSAJE2;cout << DIA4 << endl;break;
case 5: cout << MENSAJE2;cout << DIA5 << endl;break;
case 6: cout << MENSAJE2;cout << DIA6 << endl;break;
case 7: cout << MENSAJE2;cout << DIA7 << endl;break;
default: cout << MENSAJE3 << endl;}
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
/ DESCRIPCION: Ej 17// Muestra los numeres impares entre 1 y 20.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------int i; // contador de vueltas del ciclo for
//======================// Inicio del algoritmo//======================//-------------------// Ciclo de muestreo//-------------------
16
for(i=1;i<=20;i+=2){
cout << i << endl;}
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
/ DESCRIPCION: Ej 18// Pide el ingreso de diez pares de numeros enteros positivos y muestra// mayor de cada par.//// Hipotesis: se supone que todos los numeros ingresados son enteros// positivos, no hace falta validarlos.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE1[]="Por favor ingrese un numero entero positivo: ";const char MENSAJE2[]="por favor ingrese otro: ";const char MENSAJE3[]="El mayor del par ";const char MENSAJE4[]=" es ";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------int i, // Contador de vueltas del ciclo for N1, // Primer numero de cada par. N2; // Segundo numero de cada par.
//======================// Inicio del algoritmo//======================//------------------------------------------//// Ciclo de ingreso, comparacion y muestreo ////------------------------------------------//
17
for(i=1;i<=10;i++){
cout << MENSAJE1; // Mensaje que pide el primer numero de cada par.cin >>N1; // Lee el primer numero de cada par por teclado.
cout << MENSAJE2; // Mensaje que pide el segundo numero de cada par.
cin >> N2; // Lee el segundo numero de cada par por teclado.
// Bcout << MENSAJE3 << i << MENSAJE4;
if(N1>N2) // Busqueda del mayor{
cout << N1 << endl;}else{
cout << N2 << endl;}
}
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 19// Se pide al operador que informe cuantos pares va a ingresar, luego se// le pide que comience a ingresar pares de numereos enteros positivos.// El programa muestra el numero mayor de cada par ingresado.//// Restriccion: Si son iguales debe mostrarse el segundo ingreso del par.//// Hipotesis: se supone que todos los numeros ya estan validados.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE0[]="Por favor indique la cantidad de pares que va a ingresar: ";const char MENSAJE1[]="Por favor ingrese un n£mero entero positivo: ";const char MENSAJE2[]="por favor ingrese otro: ";const char MENSAJE3[]="El mayor es: ";
18
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc,char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------int i, // Contador de vueltas del ciclo for. Cantidad, // Cantidad de pares que deben ingresarse. N1, // Primer numero de cada par. N2; // Segundo numero de cada par.
//======================// Inicio del algoritmo//======================//---------------------------------------// Determinacion de la cantidad de pares//---------------------------------------cout << MENSAJE0; // Mensaje para pedir la cantidad de pares a // ingresar.cin >> Cantidad; // Ingreso de la cantidad por teclado.
//------------------------------------------// Ciclo de ingreso, comparacion y muestreo//------------------------------------------for(i=1;i<=Cantidad;i++){
cout << MENSAJE1; // Pedido del primer numero del par.cin >> N1; // Lectura del primer numero por teclado.
cout << MENSAJE2; // Pedido del segundo numero del par.cin >> N2; // Lectura del segundo numero por teclado.
//----------------------------------------------// Puesta en pantalla del mayor numero del par.//----------------------------------------------cout << MENSAJE3;
if(N1>N2) // Busqueda del mayor{
cout << N1 << endl;}else{
cout << N2 << endl;}
}
19
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 20// Pide el ingreso de numeros enteros positivos hasta que se ingrese un// negativo o cero. Luego informa la cantidad de numeros ingresados.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE0[]="Por favor ingrese n£meros positivos.";const char MENSAJE1[]="(Fin de ingresos un n£mero negativo o 0)";const char MENSAJE2[]="por favor ingrese otro: ";const char MENSAJE3[]="La cantidad de numeros ingresados es: ";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------int Cantidad=0; // Contador de numeros ingresados. Ya esta inicialiado
// en 0;int N1; // Numero a ingresar.
//======================// Inicio del algoritmo//======================//---------------------------// Ingresar el primer numero//---------------------------cout << MENSAJE0 << endl << MENSAJE1; // Pedido del primer numero.cin >> N1; // Lectura del primer numero.
//----------------------------// Ciclo de ingreso, y conteo//----------------------------while(N1>0){
Cantidad++; // Suma 1 a la cantidad de numeros ingresados.
20
//----------------------// Ingresar otro numero//----------------------cout << MENSAJE2; // Pedido de otro numero.cin >> N1; // Ingreso de otro numero.
}
//---------------------------------- // Puesta en pantalla del resultado. //----------------------------------
cout << endl << MENSAJE3 << Cantidad << endl;
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
/ DESCRIPCION: Ej 21// Pide el ingreso de numeros enteros positivos hasta que se ingrese un// negativo o cero. Luego informa la cantidad de numeros ingresados y la// sumatoria de estos.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE0[]="Por favor ingrese n£meros positivos.";const char MENSAJE1[]="(Fin de ingresos un n£mero negativo o 0)";const char MENSAJE2[]="por favor ingrese otro: ";const char MENSAJE3[]="La cantidad de n£meros ingresados es: ";const char MENSAJE4[]="Las suma de los n£meros ingresados es: ";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------------// Declaracion de variables locales//----------------------------------
21
int Cantidad=0; // Contador de numeros ingresado, inicializado en 0.int Suma=0; // Acumulador de valores ingrsados, inicializado en 0.int N1; // Numero ingresado.
//======================// Inicio del algoritmo//======================//---------------------------// Ingresar el primer numero//---------------------------cout << MENSAJE0 << endl << MENSAJE1; // Pedido del primer numero.cin >> N1; // Lectura del primer numero.
//----------------------------// Ciclo de ingreso, y conteo//----------------------------while(N1>0){
Cantidad++; // Suma 1 a la cantidad de numeros ingresados.Suma+=N1; // Suma el numero ingresado a la suma total.
//----------------------// Ingresar otro numero//----------------------cout << MENSAJE2; // Pedido de los otros numeros.cin >>N1; // Lectura de los otros numeros.
}
//--------------------------------------// Puesta en pantalla de los resultados.//--------------------------------------cout << endl << MENSAJE3 << Cantidad;cout << endl << MENSAJE4 << Suma << endl;
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 22// Pide el ingreso de numeros enteros positivos hasta que se ingrese un// negativo o cero. Luego informa la cantidad de numeros ingresados, la// suma y su promedio.//======================================================================#include <iostream>
using namespace std;
22
//----------------------------------------------------------------------// DECLARACION DE CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE0[]="Por favor ingrese numeros positivos.";const char MENSAJE1[]="(Fin de ingresos un numero negativo o 0)";const char MENSAJE2[]="por favor ingrese otro: ";const char MENSAJE3[]="La cantidad de numeros ingresados es: ";const char MENSAJE4[]="Las suma de los numeros ingresados es: ";const char MENSAJE5[]="El promedio es: ";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){ freopen("CON","w",stdout); freopen("CON","w",stderr);
//----------------------------------// Declaracion de variables locales//----------------------------------int Cantidad=0; // Contador de numeros ingresados, inicializado en 0.int Suma=0; // Suma de los valores ingresados, inicializada en 0.int N1; // Numero ingresado.float Promedio; // Promedio de valores ingresados.
//======================// Inicio del algoritmo//======================//---------------------------// Ingresar el primer numero//---------------------------cout << MENSAJE0 << endl << MENSAJE1; // Pedido del primer numero.cin >> N1; // Leer el primer numero por // teclado.
//----------------------------// Ciclo de ingreso, y conteo//----------------------------while(N1>0){
Cantidad++; // Suma 1 a la cantidad de numeros ingresados.Suma+=N1; // Suma el numero ingresado a la suma total.
//----------------------// Ingresar otro numero//----------------------cout << MENSAJE2; // Pedido de otro numero.cin >> N1; // Lectura de otro numero por teclado.
}
23
//----------------------// Calculo del promedio//----------------------if(Cantidad>0){
Promedio=(float)Suma/Cantidad; }
else{
Promedio=0;}
//---------------------------------- // Puesta en pantalla del resultado. //----------------------------------
cout << endl << MENSAJE3 << Cantidad << endl << MENSAJE4 << Suma << endl << MENSAJE5 << Promedio << endl;
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////// DESCRIPCION: Ej 23// Pide el ingreso de una cadena, la copia en otra y muestra la copia.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARAR CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE0[]="Por favor ingrese su nombre.";const char MENSAJE1[]="La copia de lo ingresado es: ";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------// Declarar variables locales//----------------------------char Nombre[80]; // Cadena a ingresar.char CopiaDeNombre[80]; // Cadena copia.
24
//======================// Inicio del algoritmo//======================//--------------------// Ingresar el Nombre//--------------------cout << MENSAJE0; // Pide el nombre.cin.getline(Nombre,80); // Lee el nombre por teclado.
//-------------------// Realizar la copia//-------------------strcpy(CopiaDeNombre,Nombre);
//------------------// Mostrar la copia//------------------cout << MENSAJE1 << endl << CopiaDeNombre << endl;
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 24// Pide el ingreso de una cadena, e informa la cantidad de caracteres// que la integran.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARAR CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE0[]="Por favor ingrese una cadena: ";const char MENSAJE1[]="La cantidad de caracteres de su cadena es: ";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------// Declarar variables locales//----------------------------char CadenaDeUsuario[256]; // Cadena a ingresar.
25
unsigned short int Cantidad; // Variable para almacenar la cantidad
// de caracteres de la cadena.
//======================// Inicio del algoritmo//======================//--------------------// Ingresar la cadena//--------------------cout <<MENSAJE0; // Pide la cadena.cin.getline(CadenaDeUsuario,256); // Lee la cadena por teclado.
//-----------------// Medir la cadena//-----------------Cantidad = strlen(CadenaDeUsuario);
//----------------------------------------------------------// Mostrar la cantidad de caracteres que integran la cadena//----------------------------------------------------------cout << MENSAJE1 << Cantidad << endl;
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
/ DESCRIPCION: Ej 25// Pide el ingreso de una clave de un maximo de 10 caracteres, y guarda// en una variable, de tipo "bool" (logica), "true" (VERDADERO) o// "false" (FALSO) segun sea su validez.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARAR CONSTANTES GLOBALES//----------------------------------------------------------------------const char MSJ0[] ="Por favor ingrese la clave (maximo 10 caracteres): ";const char MSJ1[] = "CLAVE CORRECTA";const char MSJ2[] = "CLAVE INCORRECTA";const char CLAVE[]= "decrepito";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------
26
int main(int argc, char* argv[]){
//----------------------------// Declarar variables locales//----------------------------char clave[11]; // Clave ingresada por el usuario.bool acceso; // Variable logica para la respuesta.
//======================// Inicio del algoritmo//======================//-------------------// Ingresar la clave//-------------------cout << MSJ0; // Pedido de ingreso de clave.cin.getline(clave,10); // Lectura de la clave por teclado.
//-----------------// Comparar claves//-----------------if(strcmp(clave,CLAVE)){
// Dio un valor distinto de 0 (cero) --> NO SON IGUALESacceso = false;
}else{
// Dio 0 (cero) --> SON IGUALESacceso = true;
}
//----------------------// Mostrar el resultado//----------------------
if(acceso){
cout << endl << MSJ1 << endl;}
else { cout << endl << MSJ2 << endl; }
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
// DESCRIPCION: Ej 26// Pide el ingreso del nombre del usuario, le concatena un saludo,y
27
// muestra la concatenacion.//======================================================================#include <iostream>
using namespace std;
//----------------------------------------------------------------------// DECLARAR CONSTANTES GLOBALES//----------------------------------------------------------------------const char MENSAJE0[]="Por favor ingrese su nombre: ";const char MENSAJE1[]="Bienvenido ";
//----------------------------------------------------------------------// CUERPO PRINCIPAL DEL PROGRAMA:FUNCION "main".//----------------------------------------------------------------------int main(int argc, char* argv[]){
//----------------------------// Declarar variables locales//----------------------------char Nombre[80]; // Nombre ingresado por el usuario.char Saludo[256]; // Cadena a concatenar.
//======================// Inicio del algoritmo//======================//--------------------// Ingresar el nombre//--------------------cout << MENSAJE0; // Pide el ingreso del nombre.cin.getline(Nombre,80); // Lee el nombre por teclado.
//------------------------// Armar la concatenacion//------------------------strcpy(Saludo, MENSAJE1); // Copia el MENSAJE1 en Saludo.strcat(Saludo,Nombre); // Concatena el Nombre al Saludo.
//-------------------// Mostrar el saludo//-------------------cout << endl << Saludo << endl;
return 0; // Retorno de la funcion.}
///// FIN //////////////////////////////////////////////////////////////
28