examen programacion i

EXAMEN PROGRAMACION I
FEBRERO 2007
Preguntas teórico prácticas
- Pregunta 1
a) Una variable de tipo boolean es aquélla que nos indica si algo es cierto o falso, por ejemplo una
expresión, una comparación, etc. El tipo de datos booleano (lógico) puede tomar uno entre dos valores
posibles, cierto o falso. En ANSI C no existe como tal el tipo boolean, C entiende como verdadero o falso
valores enteros, siendo 0 (falso) y cualquier valor distinto de cero cierto. Un ejemplo de declaración de
una variable booleana sería:
int valor = 0; // inicializada a falso
En este caso hemos declarado la variable valor como entera inicializada a cero (falso). Al evaluarla C
entiende que su valor es falso. Podemos evaluarla como si de una variable bolean se tratara:
if(valor) o if (!valor), devolviéndonos true o false en cada caso.
b)
void main()
{
int bultos, dia;
double peso, precio, resto;
printf(“Dame el numero de bulto:”);
scanf(“%d”, &bultos);
fflush(stdin);
printf(“Día de la semana:”);
scanf(“%d”, &día);
fflush(stdin);
printf(“Peso total de los bultos:”);
scanf(“%lf”, &peso);
fflush(stdin);
if( (dia = =7) || (bultos > 30) || (peso > 1000))
printf(“imposible hacer transporte”);
else
{
precio=bultos*30;
if(peso>300)
{
resto = peso – 300;
precio += (resto * 0.90);
}
if (dia= =6)
precio += 60;
printf(“coste total del transporte: %f”,precio);
}
}
- Pregunta 2
a) A la hora de pasar datos de una estructura a una función, se puede hacer de dos maneras, pasando
simplemente uno o más miembros (o submiembros) de la estructura o la estructura completa. En
cualquiera de los dos casos el paso de parámetros se realiza por valor no por referencia. Si queremos
pasar una estructura por referencia deberemos hacer uso de punteros.
b)
struct TipoPersona
{
char nombre[10], apellidos[20];
int edad;
flota peso;
};
struct TipoPersona LeerPersona()
{
struct TipoPersona p;
scanf(“%s”,p.nombre);
scanf(“%s”,p.apellidos);
scanf(“%d”,&p.edad);
scanf(“%f”,&p.peso);
return p;
}
void intercambiar (struct TipoPersona *p1, struct TipoPersona *p2)
{
struct TipoPersona aux;
aux = *p1;
*p1 = *p2;
*p2 = aux;
}
- Pregunta 3
a)
Un vector bidimensional es un vector cuyos elementos son a su vez vectores, es decir, un "vector de
vectores". Se le llama normalmente matriz.
Para hacer referencia a un elemento de un vector que, a su vez, es elemento de otro vector se utiliza el
doble índice X[i] [j] donde:
•
•
•
X es el nombre del vector bidimensional,
[i] hace referencia al vector elemento almacenado en la posición i,
[j] hace referencia al elemento almacenado en la posición j del vector X[i].
Para entenderlo de una manera más clara, los vectores bidimensionales se representan en forma de una
conjunto de filas y columnas denominado matriz. La declaración de vectores bidimensionales será:
tipo_dato nombre_vector[rango1] [rango2];
La declaración de argumentos formales en la cabecera de la función debe incluir especificaciones
explícitas de rango2, pudiendo dejar vacío rango1.
tipo_dato nombre_función (tipo_dato nombre_vector [ ] [rango2])
El paso de argumentos se realiza por referencia.
b)
void Traspuesta (int M[N][M], int T[M][N])
{
int i,j;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
T[j][i]=M[i][j];
}
Parte práctica
Problema de surtidores de gasolina.
Estructuras que tenemos que crear:
#define N 5
struct Tsurtidor
{
char tipo[10];
int ref;
flota cantidad, precio;
};
struct Tsurtidor Surtidores [N];
void Init (struct Tsurtidor Surtidores [N])
{
int i;
for (i=0; i<N; i++)
{
switch (i)
{
case 0: strcpy(Surtidores[i].tipo,”super”); break;
case 1: strcpy(Surtidores[i].tipo,”normal”); break;
case 2: strcpy(Surtidores[i].tipo,”sin plomo”); break;
case 3: strcpy(Surtidores[i].tipo,”gasoil”); break;
case 4: strcpy(Surtidores[i].tipo,”mezcla”); break;
default: break;
}
printf(“inicialización del surtidor: %s\n”, Surtidor[i].tipo);
printf(“Introduce Referencia:”);
sanf (“%d”,&Surtifores[i].ref);
fflush(stdin);
printf(“Cantidad Total:”);
sanf (“%f”,&Surtidores[i].cantidad);
fflush(stdin);
printf(“Precio por litro:”);
sanf (“%f”,&Surtidores[i].precio);
fflush(stdin);
}
}
void Repostar (struct Tsurtidor Surtidores [N]), int ref, float cantidad)
{
int i;
float total;
for (i=0; i<N; i++)
{
if(Surtidores[i].ref == ref)
if(Surtidores[i].cantidad – cantidad <0)
printf(“No hay suficiente combustible en el surtidor\n);
else
{
Surtidores[i].cantidad – = cantidad;
total = cantidad * Surtidores[i].precio;
pintf(“le hemos servido: %f, precio total:%f\n”,cantidad,
total);
}
}
}
void Listar (struct Tsurtidor Surtidores [N])
{
int i;
for (i=0; i<N; i++)
{
printf(“Datos del surtidor: %s\n”, Surtidores[i].tipo);
printf(“Referencia: %d”, Surtidores[i].ref);
printf(“Cantidad Total: %f”,Surtidores[i].cantidad);
printf(“Precio por litro: %f\n”,Surtidores[i].precio);
printf(“************************************”);
}
}
void ListarOrdenado (struct Tsurtidor Surtidores [N])
{
struct Tsurtidor aux;
int i, j, mayor;
for( i=0; i<N-1; i++)
{
mayor = i;
for( j=i+1; j<N; j++)
if(Surtidores[j] > mayor)
mayor = j;
if(menor != i)
{
aux = Surtidores[mayor];
Surtidores[mayor] = Surtidores[i];
Surtidores[i] = aux;
}
}
Listar(Suridores);
}
void main ( )
{
struct Tsurtidor
{
char tipo[10];
int ref;
flota cantidad, precio;
};
struct Tsurtidor Surtidores [N];
int op, salir=0;
float ref, cantidad;
do
{
printf(“ 1 - Repostar\n”);
printf(“ 2 - Listar datos de surtidores\n”);
printf(“ 3 - Listar surtidores ordenado por carburante\n”);
printf(“ 4 - Salir\n”);
scanf (“%d”,&op);
switch(op)
{
case 1: printf(“Referecnia del combustible a servir:”);
scanf(“%f”,&ref);
printf(“Litros:”);
scanf(“%f”,&cantidad);
Repostar(Surtidores,ref,cantidad);break;
case 2: Listar(Surtidores);break;
case 3: ListarOrdenado(Surtidores);break;
case 4: salir=1;break;
default: printf(“opcion incorrecta\n”);
}
}
while (!salir);
}