| EJERCICIOS PROPUESTOS EN LAS DIAPOSITIVAS. 01 - Número mayor 02 - Número positivo, negativo o cero 03 - Letra minúscula,mayúscula,dígito u operador aritmético 04 - Menú (I) 05 - Entender algoritmo (I) y (II) 06 - Suma de números positivos 07 - Divisores de un número mayor que cero 08 - Menú (II) |
| PRÁCTICA 3 ESTRUCTURAS DE CONTROL CONDICIONALES EJERCICIOS PROPUESTOS EN LAS PRÁCTICAS. 01 - Número mayor, menor y promedio 02 - Años bisiestos 03 - Capicúa 04 - Calculadora |
| PRÁCTICA 4 ESTRUCTURAS DE CONTROL ITERATIVAS. EJERCICIOS PROPUESTOS EN LAS PRÁCTICAS. 01 - Operaciones de números introducidos 02 - Fibonacci 03 - Pareja de valores (Fila,Columna) 04 - Dibujando triángulos |
Secuencia
| Asignación | = |
| Entrada | cin >> |
| Salida | cout << |
Selección
| Simples | if |
| Dobles | if - else |
| Múltiples | switch ó if-else anidados |
Iteración
| Repetir con condición inicial | while y for |
| Repetir con condición final | do-while |
IF-ELSE
|
IF-ELSE ANIDADO
|
SWITCH
|
| if (expresión lógica1){ sentencia1; }else{ sentencia2; } | if (expresión lógica1){ sentencia1; }else if(expresión lógica2){ sentencia2; }else if(expresión lógica3){ sentencia3; } | switch (expresión lógica1){ case valor1: sentencia1; break; case valor2: sentencia2; break; default: sentencia3; break; } |
WHILE
|
FOR
|
DO-WHILE
|
| while (expresión lógica1){ sentencias; } | for (inicio contador;expresión lógica1;incremento contador){ sentencias; } | do{ sentencias; }while (expresión lógica1); |
¿Diferencia entre while y do-while?
While
- Permite repetir cero o más veces
Do-while
- Permite repetir una o más veces
Equivalencias For y While (búcles inciales)
FOR
|
WHILE
|
| for (valor; condición; contador){ sentencias; } | valor; while (condición){ sentencias; contador; } |
Traza de un programa
- Es la secuencia de estados por los que pasa un programa, es decir, el valor que va tomando las variables a medida que se va ejecutando el programa.
- La traza se lleva a cabo mediante la ejecución manual de forma secuencial de las sentencias que compone el programa.
- Se utilizan principalmente para depurar un programa.
Ejemplo:
#include<iostream>
using namespace std;
main(){
int num;
int suma;
int i;
cout << "Introduce un número mayor que cero";
cin >> num;
//calcular
suma = 0;
for (i=1; i<num; i++){
if( (num%2) != 0)
suma = suma+1;
}
cout << "Resultado: " << suma << endl;
}
| num | suma | i | |
| cin | 5 | ||
| inicializa suma | 5 | 0 | |
| inicializa contador | 5 | 0 | 1 |
| 1ª iteración for | 5 | 1 | 1 |
| incremento contador | 5 | 1 | 2 |
| 2ª iteración for | 5 | 3 | 2 |
| incremento contador | 5 | 3 | 3 |
| 3ª iteración for | 5 | 6 | 3 |
| incremento contador | 5 | 6 | 4 |
| 4ª iteración for | 5 | 10 | 4 |
| incremento contador | 5 | 10 | 5 |
Os dejo mis soluciones sobre los ejercicios propuestos de este tema por si os veis muy perdidos.
Si encontráis algún fallo en el código comentadmelo por e-mail, tuenti o bien desde este blog.
También podéis participar en el foro del campus para que debatamos nuestras dudas.
Campus > Moodle > 2012-11 Programación 1 > Foro > Dudas
| EJERCICIOS PROPUESTOS EN LAS DIAPOSITIVAS. |
01)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
T3. ESTRUCTURAS DE CONTROL
**********************************************
Número mayor
**********************************************
Escribe un programa que lea dos números introducidos por teclado y muestre
un mensaje de texto en pantalla indicando cuál es el mayor.
*/
#include<iostream>
using namespace std;
int main(){
int n1,n2;
cout << "Introduce un número: ";
cin >> n1;
cout << "Introduce otro número: ";
cin >> n2;
if(n1>n2){
cout << "El mayor es: " << n1 << endl;
}else{
cout << "El mayor es: " << n2 << endl;
}
system("PAUSE");
}
02)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
T3. ESTRUCTURAS DE CONTROL
**********************************************
Número positivo, negativo o cero
**********************************************
**********************************************
Número positivo, negativo o cero
**********************************************
Escribe un programa que lea un número y muestre un mensaje en pantalla
indicando si es positivo, negativo o igual a cero.
*/
#include<iostream>using namespace std;
int main(){
int n1;
cout << "Introduce un número: ";
cin >> n1;
if(n1==0){
cout << "Es cero" << endl;
}else if(n1>0){
cout << "Es positivo" << endl;
}else if(n1<0){
cout << "Es negativo" << endl;
}
system("PAUSE");
}
03)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
T3. ESTRUCTURAS DE CONTROL
**********************************************
Letra minúscula,mayúscula,dígito u operador aritmético
**********************************************
**********************************************
Letra minúscula,mayúscula,dígito u operador aritmético
**********************************************
Escribe un programa que lea un carácter y visualice por pantalla un mensaje
indicando si es una letra minúscula, una letra mayúcula, un dígito o un
operador aritmético.
*/
#include<iostream>
using namespace std;
int main(){
char caracter;
cout << "Escribe: " << endl;
cin >> caracter;
if(caracter >= 'a' && caracter <= 'z'){
cout << "es minúscula" << endl;
}else if(caracter >= 'A' && caracter <= 'Z'){
cout << "es mayúscula" << endl;
}else if(caracter >= '0'){
cout << "es dígito" << endl;
}else if(caracter >= '+'){
cout << "es un operador aritmético" << endl;
}
system("PAUSE");
}
04)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
T3. ESTRUCTURAS DE CONTROL
**********************************************
Menú (I)
**********************************************
Escribe un programa que visualice tres opciones de un menú y permita
al usuario seleccionar una de ellas, después de lo cual deberá aparecer
un mensaje en la pantalla que muestre la opción seleccionada o bien un
mensaje de error si la opción es incorrecta.
*/
#include<iostream>
using namespace std;
int main(){
char opcion;
cout << "Menú\n 1- Kebap \n 2- Pizza \n 3- Hamburguesa" << endl;
cout << "Escoge una opción del menú: ";
cin >> opcion;
switch(opcion){
case '1':
cout << "Has elegido Kebap" << endl;
break;
case '2':
cout << "Has elegido Pizza" << endl;
break;
case '3':
cout << "Has elegido Hamburguesa" << endl;
break;
default:
cout << "La opción seleccionada es incorrecta" << endl;
break;
}
system("PAUSE");
}
05)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
T3. ESTRUCTURAS DE CONTROL
**********************************************
Entender algoritmo (I)
**********************************************
Después de ejecutar cada uno de los siguientes fragmentos de programa.
¿Cuál será el valor final de la variable x en cada uno de los casos?
(CASO A)
*/
#include<iostream>
using namespace std;
/*
"x=31"
"n=0"
*/
int main(){
int x,n,z,j;
x=0;
n=16;
while(n!=0){
x=x+n;
n=n/2;
cout << "X vale: " << x << " N vale: " << n << endl;
}
system("PAUSE");
}
05.2)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
T3. ESTRUCTURAS DE CONTROL
**********************************************
Entender algoritmo (II)
**********************************************
Después de ejecutar cada uno de los siguientes fragmentos de programa.
¿Cuál será el valor final de la variable x en cada uno de los casos?
(CASO B)
*/
#include<iostream>
using namespace std;
/*
-Se ejecutará la primer condición
-Se produce un búcle infinito
"j=0"
"x+j=0"
*/
int main(){
int z,x,j;
z=12;
x=0;
if((z%4)==0){
for(j=0;j<10;j+4){
x=x+j;
cout << "X vale: " << x << endl;
}
}else{
for(j=0;j<10;j+2){
x=x+j;
cout << "X vale: " << x << endl;
}
}
system("PAUSE");
}
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
T3. ESTRUCTURAS DE CONTROL
**********************************************
Suma de números positivos
**********************************************
Escribe un programa que lea números positivos y nos muestre el valor de
su suma y la cantidad de números leídos.
*/
#include<iostream>
using namespace std;
int main(){
int contador,numero,suma;
contador=1;
suma=0;
do{
cout << "Introduce un número: ";
cin >> numero;
if(numero>=0){
suma = numero + suma;
cout << "Números leídos: " << contador << endl;
cout << "Resultado: " << suma << endl;
}
contador++;
}while(contador<=5);
system("PAUSE");
}
07)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
T3. ESTRUCTURAS DE CONTROL
**********************************************
Divisores de un número mayor que cero
**********************************************
Escribe un programa que lea un número entero mayor que cero y muestre
por pantalla todos los divisores de dicho número.
*/
#include<iostream>
using namespace std;
int main(){
int numero,i;
cout << "Introduce un número: ";
cin >> numero;
if(numero>0){
for(i=0;i<numero;i++){
numero = numero/2;
cout << numero << endl;
}
}
system("PAUSE");
}
08)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
T3. ESTRUCTURAS DE CONTROL
**********************************************
Menú (II)
**********************************************
Modifica el programa del ejercicio 4 para añadir una cuarta opción que
sea SALIR. El programa debe mostrar el menú continuamente , después de
que el usuario elija opción, hasta que se elija la opción 4.
*/
#include<iostream>
using namespace std;
int main(){
char opcion;
cout << "Menú\n 1- Kebap \n 2- Pizza \n 3- Hamburguesa \n 4- SALIR" << endl;
do{
cout << "Escoge una opción del menú: ";
cin >> opcion;
switch(opcion){
case '1':
cout << "Has elegido Kebap" << endl;
break;
case '2':
cout << "Has elegido Pizza" << endl;
break;
case '3':
cout << "Has elegido Hamburguesa" << endl;
break;
case '4':
cout << "Fin del programa" << endl;
break;
default:
cout << "La opción seleccionada es incorrecta" << endl;
break;
}
}while(opcion!='4');
system("PAUSE");
}
| PRÁCTICA 3 ESTRUCTURAS DE CONTROL CONDICIONALES EJERCICIOS PROPUESTOS EN LAS PRÁCTICAS. |
01)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
PRÁCTICA 3. ESTRUCTURAS DE CONTROL CONDICIONALES
**********************************************
Número mayor, número menor y promedio
**********************************************
Implementa un algoritmo en C que lea tres números enteros y escriba un
mensaje indicando cuál es el mayor de los 3, cuál es el menor de los 3 y
cuál es el promedio, intentando que el número de condiciones a evaluar
sea el mínimo.
*/
#include<iostream>
using namespace std;
int main(){
int n1,n2,n3,promedio;
cout << "Introduce un número: ";
cin >> n1;
cout << "Introduce otro número: ";
cin >> n2;
cout << "Introduce una vez más otro número: ";
cin >> n3;
// Número mayor
if(n1>n2 && n1>n3){
cout << "Número mayor: " << n1 << endl;
}else if(n2>n1 && n2>n3){
cout << "Número mayor: " << n2 << endl;
}else if(n3>n1 && n3>n2){
cout << "Número mayor: " << n3 << endl;
}
// Número menor
if(n1<n2 && n1<n3){
cout << "Número menor: " << n1 << endl;
}else if(n2<n1 && n2<n3){
cout << "Número menor: " << n2 << endl;
}else if(n3<n1 && n3<n2){
cout << "Número menor: " << n3 << endl;
}
// Promedio
promedio=(n1+n2+n3)/3;
cout << "Promedio: " << promedio << endl;
system("PAUSE");
}
02)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
PRÁCTICA 3. ESTRUCTURAS DE CONTROL CONDICIONALES
**********************************************
Años bisiestos
**********************************************
Implementa un algoritmo que lea una fecha (por separado el día, el mes y
el año) y muestre un mensaje indicando si la fecha es correcta o no. Hay
que tener en cuenta que son bisiestos los años múltiplos de 4, excepto los
múltiplos de 100, y que sí son bisiestos los múltiplos de 400.
En el caso de que la fecha sea correcta, deberá mostrar el día siguiente.
*/
#include<iostream>
using namespace std;
int main(){
int dia,mes,anyo;
cout << "Día: ";
cin >> dia;
cout << "Mes: ";
cin >> mes;
cout << "Año: ";
cin >> anyo;
if((dia<=31) && (mes<=12)){
if((anyo%4==0)&&((anyo%100!=0)||(anyo%400==0))){
cout << "Es bisiesto" << endl;
cout << dia+1 << "/" << mes << "/" << anyo << endl;
}else{
cout << "No es bisiesto" << endl;
cout << dia+1 << "/" << mes << "/" << anyo << endl;
}
}else{
cout << "Fecha incorrecta" << endl;
}
system("PAUSE");
}
03)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
PRÁCTICA 3. ESTRUCTURAS DE CONTROL CONDICIONALES
**********************************************
Capicúa
**********************************************
Implementa un algoritmo en C que pida un número entre 0 y 9.999 y diga si
es capicúa.
PLANTEAMIENTO.
5665:
5665/1000 = 5 (resto=665)
665/100 = 6 (resto=65)
65/10 = 6 (resto=5)
5/1 = 5 (resto=0)
Con estas cuatro operaciones se obtiene cada uno de los caracteres del
número por separado.
Ya sólo queda comprobar que el primer dato coincida con el cuarto y
el segundo con el tercero.
*/
#include<iostream>
using namespace std;
int main(){
int n,n1,n2,n3,n4;
cout << "Introduce un número del 0 al 9999: ";
cin >> n;
//Resto de la división
n1 = n%1000;
n2 = n1%100;
n3 = n2%10;
n4 = n3%1;
//Cociente de la división
n = n/1000;
n1 = n1/100;
n2 = n2/10;
n3 = n3/1;
//Compruebo cada valor introducido
//cout << n << n1 << n2 << n3 << endl;
//Compruebo la inversa (copicúa)
if(n==n3 || (n==0 && n1==n3) ||
(n==0 && n1==0 && n2==n3) ||
(n==0 && n1==0 && n2==0 && n3==n3)){
cout << "Si es capicúa" << endl;
}else{
cout << "No es capicúa" << endl;
}
system("PAUSE");
}
04)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
PRÁCTICA 3. ESTRUCTURAS DE CONTROL CONDICIONALES
**********************************************
Calculadora
**********************************************
Implementa un algoritmo en C que realice las cuatro operaciones básicas de
una calculadora (suma,resta,multiplicación y división). El programa debe
leer los dos números y la operación. La operación se indicará con un
carácter: 's' para la suma, 'r' para la resta, 'm' para la multiplicación
y 'd' para la división.
*/
#include<iostream>
using namespace std;
int main(){
char operador;
int n1,n2;
cout << "1- Teclea 's' para sumar." << endl;
cout << "2- Teclea 'r' para restar." << endl;
cout << "3- Teclea 'm' para multiplicar." << endl;
cout << "4- Teclea 'd' para dividir." << endl;
cout << "¿Qué operación deseas hacer?";
cin >> operador;
cout << "Introduce un número: ";
cin >> n1;
cout << "Introduce otro número: ";
cin >> n2;
switch(operador){
case 's':
cout << "Resultado: " << n1+n2 << endl;
break;
case 'r':
cout << "Resultado: " << n1-n2 << endl;
break;
case 'm':
cout << "Resultado: " << n1*n2 << endl;
break;
case 'd':
cout << "Resultado: " << n1/n2 << endl;
break;
default:
cout << "Operación no válida" << endl;
break;
}
system("PAUSE");
}
| PRÁCTICA 4. ESTRUCTURAS DE CONTROL ITERATIVAS EJERCICIOS PROPUESTOS EN LAS PRÁCTICAS. |
01)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
PRÁCTICA 4. ESTRUCTURAS DE CONTROL ITERATIVAS
**********************************************
Operaciones de números introducidos
**********************************************
Implementa un programa que lea números que el usuario introduzca por
teclado. En primer lugar el programa preguntará cuántos números se
van a introducir. A continuación se introducirán los números. El
programa tiene que imprimir la suma de todos los números introducidos
e indicar cuál es el mayor y el menor de todos.
*/
#include<iostream>
using namespace std;
int main(){
int nVeces;
int contador;
int numero;
int suma;
int nMayor,nMenor;
//Acumuladores
suma=0;
nMayor=0;
nMenor=0;
//Contador
contador=1;
cout << "¿Cuántos números vas a introducir?" << endl;
cin >> nVeces;
do{
cout << "Introduce un número:" << endl;
cin >> numero;
suma=numero+suma;
if(numero>=nMayor){
nMayor=numero;
}
if(numero<=nMenor){
nMenor=numero;
}
contador++;
}while(contador<=nVeces);
cout << "La suma es: " << suma << endl;
cout << "El menor es: " << nMenor << endl;
cout << "El mayor es: " << nMayor << endl;
system("PAUSE");
}
02)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
PRÁCTICA 4. ESTRUCTURAS DE CONTROL ITERATIVAS
**********************************************
Fibonacci
**********************************************
Escribe un programa que pida un número n por teclado e imprima los valores
de la serie Fibonacci hasta ese número n.
EJEMPLO:
Introduce n:
7
0 1 1 2 3 5 8 13
Introduce n:
10
0 1 1 2 3 5 8 13 21 34 55
PLANTEAMIENTO:
"a" vale 0
"b" vale 1
"s" vale 0 <- variable acumuladora que irá sumando la secuencia (a+b)
Repetir "nVeces"
Si "s" es menor que 0
Muestra el valor de "s", es decir, 0
Suma s=a+b, es decir, s=0+1
Muestra el valor de "s" una vez más, es decir, el resultado de la primer suma, 1
Por lo que en esta primer condición se mostrará por pantalla los primeros dos dígitos, "0 1"
De lo contrario si "s" es mayor que 0
--------------------------------------------
s=a+b, es decir, s=0+1
Mostramos por pantalla el valor de s, 1
y aquí es donde empezaremos a alterar el orden de los valores para asignar la
secuencia fibonacci:
a que vale 0, tendrá el valor de "b", 1
b que vale 1, tendrá el valor de "s=a+b", 1
--------------------------------------------
se repetirá "nVeces" cambiando los valores de la suma de a y b
y asi es como se obtiene la secuencia Fibonacci
Fin Repetir
*/
#include<iostream>
using namespace std;
int main(){
int nVeces,i;
int a,b,s;
a=0;
b=1;
s=0;
cout << "Introduce n:" << endl;
cin >> nVeces;
//Sumando secuencias fibonacci
for(i=0;i<nVeces;i++){
if(s<=0){
cout << s << " ";
s=a+b;
cout << s << " ";
}else{
s=a+b;
cout << s << " ";
a=b;
b=s;
}
}
system("PAUSE");
}
03)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
PRÁCTICA 4. ESTRUCTURAS DE CONTROL ITERATIVAS
**********************************************
Pareja de valores (Fila,Columna)
**********************************************
Implementa un programa en C que pida por teclado un número n, que deberá
cumplir que sea mayor que 0 y menor o igual a 9. En caso de que la entrada
de dicho dato sea incorrecta, el programa deberá volver a solicitarlo
hasta que sea correcto.
Después se deberá imprimir por pantalla todas las posibles parejas de valores
(i,j), hasta n.
EJEMPLO
Introduce n (mayor que 0 y menor igual a 9):
10
el valor introduce es incorrecto.
Introduce n (mayor que 0 y menor igual a 9):
3
(1,1) (1,2) (1,3)
(2,1) (2,2) (2,3)
(3,1) (3,2) (3,3)
OBSERVACIONES
Para el comando "cout":
\t = Salto de tabulación
\n ó << endl; = Salto de línea
*/
#include<iostream>
using namespace std;
int main(){
int n;
int i,j;
do{
cout << "Introduce un número (mayor que 0 y menor igual a 9): ";
cin >> n;
// Parejas de valores de (i,j)
for(i=1;i<=n;i++){
for(j=1;j<=n;j++){
cout << "(" << i << "," << j << ")";
cout << "\t";
}
cout << endl;
}
if(!(n>0 && n<=9)){
cout << "El valor introducido es incorrecto" << endl;
}
}while(!(n>0 && n<=9));
system("PAUSE");
}
4)
/*
Tony Del Pino Gz
tonydelpinogz@gmail.com
PRÁCTICA 4. ESTRUCTURAS DE CONTROL ITERATIVAS
**********************************************
Dibujando triángulos
**********************************************
Implementa un programa que visualice en pantalla cada una de las siguientes
figuras, preguntando al usuario el número de filas n que deben tener las
figuras (En el ejemplo mostrado, n=6). Ten en cuenta que la solución que
propongas debe contener sentencias de salida por pantalla en las que se
impriman exclusivamente uno solo de los siguientes caracteres:
blanco ' '
aterísco '*'
y letra 'o'
1)
******
*ooo*
*oo*
*o*
**
*
2)
o****o
*****
****
***
**
o
3)
*
*o*
*o*o*
*o*o*o*
*o*o*o*o*
*o*o*o*o*o*
"Recomendación: Resuelve primero el ejercicio sin distinguir en las
figuras los caracteres '*' y 'o', es decir, dibuja sólo cada figura con el
caracter '*'. Después modifica tu solución inicial para incluir también
en las figuras el caracter 'o'.
*/
#include<iostream>
using namespace std;
int main(){
int n,i,j,espacios;
int blancos;
cout << "TRIÁNGULOS. ";
cout << "Rectángulos y equilátero" << endl;
cout << "Introduce número de filas:" << endl;
cin >> n;
//Triángulo rectángulo #01
for(i=0;i<=n;i++){
for(j=i;j<n;j++){
//Compruebo caracter
if(i>=1 && (j>i && j<n-1)) {
cout << "o";
}else{
cout << "*";
}
}
cout << endl;
}
//Triángulo rectángulo #02
for(i=0;i<=n;i++){
for(espacios=1;espacios<=i;espacios++){
cout << " ";
}
for(j=i;j<n;j++){
//Compruebo caracter
if((i==0 && (j==0 || j==n-1)) || i>=n-1){
cout << "o";
}else{
cout << "*";
}
}
cout << endl;
}
//Triángulo equilátero
for(i=1;i<=n;i++){
for(espacios=1;espacios<=n-i;espacios++){
cout << " ";
}
for(j=1;j<=2*i-1;j++){
//Compruebo caracter
if((i>=2 && i<=n) && j%2==0){
cout << "o";
}else{
cout << "*";
}
}
cout << endl;
}
/* Sólo con el carácter '*'
//Triángulo rectángulo #01
for(i=0;i<=n;i++){
for(j=i;j<n;j++){
cout << "*";
}
cout << endl;
}
//Triángulo rectángulo #02
for(i=0;i<=n;i++){
for(espacios=1;espacios<=i;espacios++){
cout << " ";
}
for(j=i;j<n;j++){
cout << "*";
}
cout << endl;
}
//Triángulo equilátero
for(i=1;i<=n;i++){
for(espacios=1;espacios<=n-i;espacios++){
cout << " ";
}
for(j=1;j<=2*i-1;j++){
cout << "*";
}
cout << endl;
}
*/
system("PAUSE");
}
No hay comentarios:
Publicar un comentario