1 V

grapa
Prueba de Síntesis 2017/18-1

Asignatura Código Fecha Hora inicio
Prácticas de programación 75.555 13/01/2018 13:30
       Espacio para la etiqueta identificativa con el código

75.555 13 01 18 PV personal del estudiante.
Prueba
!!!
Esta prueba sólo la pueden realizar los
estudiantes que han aprobado la Evaluación
Continua
Este enunciado corresponde también a las siguientes asignaturas:
• 81.578 - Prácticas de programación
Ficha técnica de la prueba
• Comprueba que el código y el nombre de la asignatura corresponden a la asignatura de la

cual estás matriculado.
• Debes pegar una sola etiqueta de estudiante en el espacio de esta hoja destinado a ello.
• No se puede añadir hojas adicionales.
• No se puede realizar las pruebas a lápiz o rotulador.
• Tiempo total: 1 h.
• En el caso de que los estudiantes puedan consultar algún material durante la prueba, ¿cuál
o cuáles pueden consultar?:
• Valor de cada pregunta:
• En el caso de que haya preguntas tipo test: ¿descuentan las respuestas erróneas? NO
¿Cuánto?
• Indicaciones específicas para la realización de esta prueba:

Página 1 de 15
Enunciados
Página 2 de 15
Pregunta 1 [30%]
Continuando con el caso del hospital desarrollado en la PEC1, en este ejercicio se

trabajará con los siguientes tipos:
const
NUM_ROOMS : integer := 200;
end const
type
{ datos de la dosis de un medicamento }
tDose = record
idMed : integer; {el código del medicamento es un entero positivo
diferente de cero}
units : integer;
timesPerDay : integer;
end record
{ datos del tratamiento con medicamentos de un paciente ingresado en el

hospital }
tTreatment = list (tDose);
{ datos del ingreso de un paciente en el hospital }

tAdmission = record
idPat : integer;
room : integer;
date : tDate;
treatment : tTreatment;
end record
{ datos de los pacientes, ingresos actuales y medicamentos en el hospital }

tHospital = record
patients : pointer to tPatient;
numPat : integer;
admissions : vector[NUM_ROOMS] of tAdmission;
numAdm : integer;
pharmacy : pointer to tMedicine;
numMed : integer;
end record
end type
Observa que para almacenar las dosis de un tratamiento, se ha introducido una lista de la
que se desconoce la implementación interna. Esto quiere decir que sólo puedes utilizar las
operaciones del TAD lista para trabajar con ella.
Página 3 de 15
Dada la función:
function number_patients_taking_medicament (h:tHospital; idMed:integer): integer

que devuelve el número de pacientes ingresados que tienen que tomar alguna dosis del
medicamento con código idMed.
Se pide:
a) [10%] Indica las Pre-condiciones para esta función.

b) [20%] Implementa la función en lenguaje algorítmico aplicando la metodología de
diseño descendiente. También hay que implementar todas las funciones que
necesites crear en los diferentes niveles.
Solución:
a)
Pre: { idMed > 0 }
b)
Nivel 1:
function number_patients_taking_medicament (h:tHospital; idMed:integer): integer

var
count, j: integer;
end var
count := 0;
for j:=1 to h.numAdm do
if is_patient_taking_medicament (h.admissions[j], idMed) then
count := count + 1;
end if
end for
return count;
end function
Nivel 2:
function is_patient_taking_medicament ( adm: tAdmission; idMed: integer) : boolean

var
d : tDose;
found : boolean;
end var
found := FALSE;
Página 4 de 15
first(adm.treatment);
while not end(adm.treatment) and not found do
d := get(adm.treatment);
if d.idMed = idMed then
found := TRUE;
else
next(adm.treatment);
end if
end while
return found;
end function
Nivel 3
Las operaciones de la lista: first, end, get y next.
Página 5 de 15
Pregunta 2 [70%]
Dada la siguiente implementación de un método, donde el parámetro x es un número
entero que cumple x > 0
int guess (int x)

{
int res;
if (x < 2) (1)
res = x; (2)
else (3)
res = x%2 + 10*guess (x/2); (4)
return res; (5)
}
a) [10%] Explica que hace este método. Asumiendo que la variable res ya está definida,
muestra paso a paso el funcionamiento de la siguiente llamada:
res = guess (4);
Este método calcula el número equivalente a x (siendo x > 0) en el sistema binario y lo

retorna.
guess(4) = 100 , donde la secuencia de llamadas es la siguiente:
guess(4) = 0 + 10·guess(2) = 10·10 = 100

guess(2) = 0 + 10·guess(1) = 10
guess(1) = 1
b) [30%] Transforma este método recursivo en un método iterativo en lenguaje C.
int guess (int x)

{
int res;
res = 1;
while (x >= 2) {
res = x%2 + 10*res;
x = x/2;
}
return res;
}
Página 6 de 15
c) [30%] Analiza la complejidad de la función guess.
Para analizar la complejidad computacional de esta función, hay que observar que
a cada llamada recursiva el valor del parámetro x se reduce a la mitad.
El caso base (líneas 1 y 2) se limita a un condicional y una asignación. Al tratarse

de dos operaciones elementales se agrupa su coste en una única constante (k 1).
Para calcular el caso recursivo, partimos de una asignación y 3 cálculos (línea 4)

con costes constantes agrupados en k2, a los que tenemos que sumar el coste de
la llamada recursiva.
Así pues, podemos definir la función de tiempo de la siguiente manera:
T(x) = k1 , si x = 1
T(x) = k2 + T(x/2) , si x > 1
Se resuelve la recurrencia repitiendo la sustitución recursiva un total de i veces:
T(x) = k2 + T(x/2) =
= k2 + (k2 + T((x/2)/2) = 2·k2 + T(x/4) =
= 2·k2 + (k2 + T((x/2)/4) = 3·k2 + T(x/8) =
= ... =
= i·k2 + T(x/2i)
Calculamos el valor de la variable i que haga que se pueda usar la parte no

recurrente de la definición de T(x):
x/2i = 1
x = 2i
log(x) = i
Finalizamos el cálculo de T(x) con el valor calculado para la variable i :
T(x) = i·k2 + T(x/2i) = log2(x)·k2 + T(x/2log2(x)) = log2(x)·k2 + T(x/x) =

= log 2(x)·k2 + T(1) = log2(x)·k2 + k1
La conclusión es que la función tiene una complejidad logarítmica O(log(x)), donde

x es el parámetro de entrada.
Página 7 de 15
Página 8 de 15
Página 9 de 15
Página 10 de 15
Página 11 de 15
Página 12 de 15
Página 13 de 15
Página 14 de 15
Página 15 de 15

1 V

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

1 V

Încărcat de

Drepturi de autor:

Formate disponibile

grapa

Prueba de Síntesis 2017/18-1

       Espacio para la etiqueta identificativa con el código

Este enunciado corresponde también a las siguientes asignaturas:

• 81.578 - Prácticas de programación

Ficha técnica de la prueba

• Comprueba que el código y el nombre de la asignatura corresponden a la asignatura de la

• Indicaciones específicas para la realización de esta prueba:

Continuando con el caso del hospital desarrollado en la PEC1, en este ejercicio se

{ datos del tratamiento con medicamentos de un paciente ingresado en el

{ datos del ingreso de un paciente en el hospital }

{ datos de los pacientes, ingresos actuales y medicamentos en el hospital }

function number_patients_taking_medicament (h:tHospital; idMed:integer): integer

a) [10%] Indica las Pre-condiciones para esta función.

function number_patients_taking_medicament (h:tHospital; idMed:integer): integer

function is_patient_taking_medicament ( adm: tAdmission; idMed: integer) : boolean

int guess (int x)

res = guess (4);

Este método calcula el número equivalente a x (siendo x > 0) en el sistema binario y lo

guess(4) = 100 , donde la secuencia de llamadas es la siguiente:

guess(4) = 0 + 10·guess(2) = 10·10 = 100

b) [30%] Transforma este método recursivo en un método iterativo en lenguaje C.

int guess (int x)

c) [30%] Analiza la complejidad de la función guess.

El caso base (líneas 1 y 2) se limita a un condicional y una asignación. Al tratarse

Para calcular el caso recursivo, partimos de una asignación y 3 cálculos (línea 4)

Así pues, podemos definir la función de tiempo de la siguiente manera:

Se resuelve la recurrencia repitiendo la sustitución recursiva un total de i veces:

Calculamos el valor de la variable i que haga que se pueda usar la parte no

Finalizamos el cálculo de T(x) con el valor calculado para la variable i :

T(x) = i·k2 + T(x/2i) = log2(x)·k2 + T(x/2log2(x)) = log2(x)·k2 + T(x/x) =

La conclusión es que la función tiene una complejidad logarítmica O(log(x)), donde

S-ar putea să vă placă și