Practica 7.Operador condicional anidado.

Objetivo: Comprender en que momentos se aplica el anidamiento de un operador

condicional.

Marco conceptual.

Véase Practica 4,5 y 6

Un operador se anida cuando es necesario, tener un criterio de acción después de un

criterio previo y esto nos da como consecuencia el anidamiento. Pudiendo tener tantos
criterios de consecuencia cuando sea necesario.

La sintaxis es:

(condicion1)?
((condicion2)?
((condicion3)?
(accionPositiva3):
(accionnegativa3))
:(AccionNegativa2))
:(accionNegativa1);

Lo importante a notar es que la terna no se rompe nunca y que ella puede estar en
cualquier sección es decir la positiva o la negativa.

Actividades.

Version 1:
Dertermina una solución de años bisiesto a partir de:

vano = año

p: vano Es divisible entre 4

~q: vano No es divisible entre 100
r: vano Es divisible entre 400

La fórmula lógica es [p y ~q] ó [r] es verdadera entonces el vano es bisiesto

// La biblioteca principal
#include<stdio.h>
// Declaraciones de la funciones
int p(int);
int q(int);
int r(int);

int esBisiesto(int);

// Declaración del procedimiento

void bisiesto();

// La función principal
int main(){
// Llamada al procedimiento principal
bisiesto();
// La salida del main
return 1;
}
// Cuerpos de la funciones
// 2004
int p(int pano){
// Variable de salida
int s;
// Checamos que sea divisible entre 4
// 501
// 4|2004=pano
// -2004
// 0
// 0 ==0
// 1
(pano%4==0)?
// s=1
(s=1):
(s=0);
// Devuelvo la respuesta
return s; // 1
}
// 2004
int q(int pano){
// Variable de salida
int s;
 // Checamos que sea divisible entre 100
// 20
// 100|2004=pano
// -2000
// 4
// 4 ==0
// 0
(pano%100==0)?
(s=1):
// s=0
(s=0);
// Devuelvo la respuesta
return s;//0
}
// 2004
int r(int pano){
// Variable de salida
int s;
// Checamos que sea divisible entre 400
// 5
// 400|2004=pano
// - 2000
// 4
// 4 ==0
// 0
(pano%400==0)?
(s=1):
//s=0
(s=0);
// Devuelvo la respuesta
return s; //0
}
// 2004
int esBisiesto(int pano){
// Para la salida de si es bisiesto
int s;
// Checamos de que sea bisiesto [p y ~q] ó [r]
// 2004 2004 2004
// 1 0 0
// 1 && 1
// 1 || 0
 // 1
((p(pano) && !q(pano)) || r(pano))?
// s=1
(s=1):
(s=0);
// Devolvemos la respuesta
return s; // 1
}

// Cuerpo del procedimiento

void bisiesto(){
// Para recibir el año
int vano;

// Para pedir
printf("Dame un año mayor a 1581:\n");
// Para recibir
scanf("%d",&vano);//1421,2004

// Analizamos el año
//1421>=1582,2004>=1582
// 0 , 1
(vano>=1582)?
// 1582
// 1
((esBisiesto(vano))?
// 2004
// 2004 es bisiesto
printf("%d es bisiesto",vano):
printf("%d NO es bisiesto",vano)
):
// 1421
// 1421 el año debe ser mayor a 1581
printf("%d el año debe ser mayor a 1581",vano);

2.-Version 2:
Determina una solución de años bisiesto a partir de:
vano = año
 p: vano Es divisible entre 4
~q: vano No es divisible entre 100
r: vano Es divisible entre 400

La fórmula lógica es p y [~q ó r] es verdadera entonces el vano es bisiesto

// La biblioteca principal
#include<stdio.h>

// Declaraciones de la funciones
int p(int);
int r(int);
int q(int);

int esBisiesto(int);

// Declaración del procedimiento

void bisiesto();

// La funcion principal
int main(){
// Llamada al procedimiento principal
bisiesto();
// La salida del main
return 1;
}
// Cuerpos de las funciones
// 2004
int p(int pano){
// 501
// 4|2004=pano
// -2004
// 0
// 0==0
// 1
return (pano%4==0)? 1 : 0;//1
}
// 2004
int r(int pano){
// 5
// 400|2004=pano
 // -2000
// 4
// 4==0
// 0
return (pano%400==0)? 1 : 0;//0
}
// 2004
int q(int pn){
// 20
// 100|2004=pano
// -2000
// 4
// 4==0
// 0
return (pn%100==0)? 1 : 0;//0
}
// 2004
int esBisiesto(int pano){
// Variable de salida
int s;

// Checamos que sea bisiesto p y [~q ó r]

// 2004 2004 2004
// 1 0 0
// 1 && ( 1 || 0 )
// 1 && 1
// 1
(p(pano) && (!q(pano) || r(pano)))?
// 1
(s=1):
(s=0);
// Salida de la función
return s;// 1
}

// Cuerpo del procedimiento

void bisiesto(){
// Para el año
int vano;

// Para pedir
 printf("dame un año mayor 1581:\n");
// Para recibe por teclado
scanf("%d",&vano);//2004

// Analizamos que cumpla las condiciones

//2004<=1581
// 0
(vano<=1581)?
printf("%d debe ser mayor a 1581",vano):
// 2004
// 1 ==0
// 0
((esBisiesto(vano)==0)?
printf("%d No es bisiesto",vano):
// 2004
// 2004 es bisiesto
printf("%d es bisiesto",vano)
);
}

3. Version 3:
Determina una solución de años bisiesto a partir del enunciado "Un año es bisiesto si es
divisible entre 4, excepto aquellos divisibles entre 100 pero no entre 400"

U = Conjunto de divisores
p = Conjunto de divisores entre 4
q = Conjunto de divisores entre 100
r = Conjunto de divisores entre 400

p
q

r
// La biblioteca principal
#include<stdio.h>

// Definimos las funciones

int p(int);
int q(int);
int r(int);

int esBisiesto();

// Definición del procedimiento

void bisiesto();

// La función principal
int main(){
// Llamada al cuerpo principal
bisiesto();
// Salida del main
return 1;
}

// Cuerpos las funciones

// 2004
int p(int pano){
// Hacemos la prueba de 4 y lo devolvemos para una condición
// 501
// 4|2004=pano
// -2004
// 0
// 0 ==0
// 1
return (pano%4==0);
}
// 2004
int q(int pano){
// Hacemos la prueba de 100 y lo devolvemos para una condición
// 20
// 100|2004=pano
// -2000
// 4
// 4 ==0
 // 0
return (pano%100==0);
}
// 2004
int r(int pano){
// Hacemos la prueba de 400 y lo devolvemos para una condición
// 4
// 400|2004=pano
// -2000
// 4
// 4 ==0
// 0
return (pano%400==0);
}
// 2004
int esBisiesto(int pano){
// Una variable para la salida
int s;

// Hacemos la prueba de 400

// 2004
// 0
(r(pano))?
(s=1): // si es
// Hacemos la prueba de 100
// 2004
// 0
((q(pano))?
(s=0): // no es
// Hacemos la prueba de 4
// 2004
// 1
((p(pano))?
// s=1
(s=1): // si es
(s=0)));
// Devolvemos la salida
return s;// 1
}

// Cuerpo del procedimiento

void bisiesto(){
// Para la recibir
int vano;

// Para mandar a pedir

printf("Dame un año mayor a 1581:\n");
// Para recibir por teclado
scanf("%d",&vano);// 2004

// Hacemos la prueba
//2004>=1582
// 1
(vano>=1582)?
// 2004
// 1
((esBisiesto(vano))?
// 2004
// 2004 es bisiesto
printf("%d es bisiesto",vano):
printf("%d No es bisiesto",vano)
):
printf("%d debe ser mayor 1581",vano);