to get the file

1. El siguiente algoritmo:
static int contarPila (Pila pila) throws PilaVacia {
int elem, resul;
if (! pila.pilaVacia ()) {
elem = pila.desapilar ();
resul = 1 + contarPila (pila);
}
else resul = 0;
return resul;
}
Seleccione una respuesta.
A. Producirá un error de compilación.
B. Suma correctamente pero pierde el contenido de la pila.
C. Suma correctamente y conserva el contenido de la pila, pues se ha pasado como argumento
por valor.
2 El siguiente método pretende mostrar los valores de una pila en pantalla:
static void escribirPila (Pila pila) throws PilaVacia {
int elem;
elem = pila.desapilar ();
escribirPila (pila);
System.out.println (elem);
pila.apilar (elem);
}
Dada una pila de enteros con los siguientes valores (desde la cima hasta el fondo):
5
7
34
2
1
Indique qué aparecerá en la pantalla.
A. 1, 2, 34, 7, 5,
B. 5, 7, 34, 2, 1,
C. Se producirá un error.
3. El método siguiente que pretende devolver el valor del fondo de una pila:
public static int desfondar (Pila p) throws PilaVacia {
int elem, dato = -9999;
if (! p.pilaVacia ()) {
elem = p.desapilar ();
if (! p.pilaVacia ()) {
dato = desfondar (p);
p.apilar (elem);
}
else dato = elem;
}
else System.out.println ("Error, pila vacia");
return dato;
}
Seleccione una respuesta.
A. Funciona correctamente en cualquier caso.
B. Aunque devuelve el valor del fondo aparece un mensaje de error correspondiente a la última
llamada (fase de transición).
C. El método siempre devolvería -9999 pues el valor de dato se inicializa en cada llamada lo que
no debe hacerse en un tratamiento recursivo
4. El siguiente algoritmo que pretende construir una pila (pila3) con los elementos comunes de dos
pilas (pila1 y pila2) ambas ordenadas ascendentemente desde la cima hacia el fondo:
static void mezclarP (Pila pila1, Pila pila2, Pila pila3, boolean apilar1, boolean apilar2, int e1, int e2)
throws PilaVacia {
boolean pend1,pend2;
pend1 = ! pila1.pilaVacia () || apilar1;
pend2 = ! pila2.pilaVacia () || apilar2;
if (pend1 && pend2) {
if (! apilar1)
e1 = pila1.desapilar ();
if (! apilar2)
e2 = pila2.desapilar ();
if (e1 < e2) {
mezclarP (pila1,pila2,pila3,false,true,e1,e2);
pila1.apilar (e1);
}
else if (e2 < e1) {
mezclarP (pila1,pila2,pila3,true,false,e1,e2);
pila2.apilar (e2);
}
else {
mezclarP (pila1,pila2,pila3,false,false,e1,e2);
pila1.apilar (e1);
pila2.apilar (e2);
pila3.apilar (e1);
}
}
}
Seleccione una respuesta.
A. Funciona correctamente.
B. Pierde un elemento de una de las pilas en caso de que los últimos elementos tratados sean
distintos.
C. Pierde un elemento de cada pila en el caso de que los últimos elementos tratados sean iguales.
5. Dado el siguiente código:
static boolean esta (Cola cola, int dato) throws ColaVacia {
int n, elem, i;
boolean resul;
resul = false;
n = cola.numElemCola ();
while ( (n > 0) && (!resul)) {
elem = cola.desencolar ();
cola.encolar (elem);
if (elem == dato)
resul = true;
n = n-1;
}
for (i = 1; i <= N; i++) {
elem = cola.desencolar ();
cola.encolar (elem);
}
return resul;
}
Si el estado inicial de la cola es el siguiente:
5
1
4
3
2
7
9
6
8
¿Cuántas instancias del método esta requerirán espacio en memoria al ejecutar, desde un programa
principal, la instrucción resul = esta (cola, 3), siendo resul una variable de tipo booleano?
A. 0.
B. 1.
C. 4.
6. Dado el siguiente código del método esta (se supone accesible el método de objeto invertirCola):
static boolean esta (Cola cola,int dato) throws ColaVacia {
cola.invertirCola ();
return est (cola, dato);
}
static boolean est (Cola cola, int dato) throws ColaVacia {
int elem;
boolean resul;
if (! cola.colaVacia ()) {
elem = cola.desencolar ();
if (elem == dato) {
resul = true;
cola.invertirCola ();
}
else resul = est (cola,dato);
cola.encolar (elem);
}
else resul = false;
return resul;
}
Si el estado inicial de la cola es el siguiente:
5
1
4
3
2
7
9
6
8
¿Cuántas instancias recursivas tendrán lugar al ejecutar, en un módulo de llamada, la instrucción resul
= esta (cola,26), siendo resul una variable de tipo booleano?
A. 0.
B. 9.
C. 10.
7. Dado el código siguiente:
static boolean esta (Cola cola,int dato) throws ColaVacia {
int elem;
boolean resul;
if (! cola.colaVacia ()) {
elem = cola.desencolar ();
if (elem == dato) {
resul = true;
cola.invertirCola ();
}
else resul = esta (cola,dato);
cola.encolar (elem);
}
else resul = false;
return resul;
}
La ejecución, en un módulo de llamada, de la instrucción resul = esta (cola,3), siendo resul una
variable de tipo booleano y con el estado inicial de la cola indicado en la figura siguiente, devuelve
true
5
1
4
3
2
7
9
6
8
¿Cuál sería el estado final de la cola?:
A. 5 1 4 3 2 7 9 6 8
B. 8 6 9 7 2 3 4 1 5
C. 3 8 6 9 7 2 4 1 5
8. El siguiente algoritmo recursivo, que recibe una pila y una cola, pretende devolver un valor en el
rango 0..2, con el siguiente significado:
0: El número de elementos de la pila y de la cola coinciden.
1: El número de elementos de la pila es mayor que el número de elementos de la cola.
2: El número de elementos de la cola es mayor que el número de elementos de la pila.
NOTA: Se supone que se tiene acceso al método de objeto invertirCola ().
static int comparar (Pila pila,Cola cola) throws PilaVacia, ColaVacia {
int elemP,elemC,resul;
if ( (! pila.pilaVacia ()) && (! cola.colaVacia ())) {
elemP = pila.desapilar ();
elemC = cola.desencolar ();
resul = comparar (pila,cola);
pila.apilar (elemP);
cola.encolar (elemC);
}
else if ( (pila.pilaVacia ()) && (! cola.colaVacia ())) {
resul = 2;
cola.invertirCola ();
}
else if ( (! pila.pilaVacia ()) && (cola.colaVacia ()))
resul=1;
else resul=0;
return resul;
}
static int compara (Pila pila,Cola cola) throws PilaVacia, ColaVacia {
int resul;
resul = comparar (pila,cola);
cola.invertirCola ();
return resul;
}
Seleccione una respuesta.
A. El algoritmo resuelve el problema planteado. El proceso (fase de ida) termina cuando se
recibe vacía alguna de las dos estructuras.
B. El algoritmo resuelve el problema planteado. Para finalizar el proceso (fase de ida) se requiere
haber procesado completamente ambas estructuras.
C. El algoritmo NO resuelve el problema planteado. Si bien proporciona un resultado correcto,
devuelve la cola con sus elementos en un orden diferente al inicial.
Soluciones:
Pregunta Respuesta Justificación
1
B
A lo largo de la fase de ida se vacía la pila y no se reconstruye en
la fase de vuelta
2
C
En el método falta la condición de fin de recursividad (no
comprobamos si la pila está vacía antes de desapilar), por lo que
al llegar al final de la pila, e intentar desapilar, se producirá un
error.
3
B
Su lógica no es del todo correcta: aunque, efectivamente, devuelve
el valor del fondo aparece un mensaje de error correspondiente a
la última llamada (fase de transición). El módulo recursivo tiene
terminación anticipada: no llega a realizarse una llamada recursiva
con la pila vacía y por tanto no aparece dicho mensaje. La
terminación pesimista solo contempla la situación de excepción de
realizar una llamada al módulo con la pila vacía por parte del
programa principal.
4
B
Falta la fase de transición para tratar los casos (apilar1 && !apilar2)
y (!apilar1 && apilar2). Perderíamos el elemento pendiente de
apilar (el mayor de los dos).
5
B
El tratamiento es iterativo. Se requiere una única instancia del
módulo llamado.
6
C
En la décima llamada se recibe la cola vacía y se produce la
terminación (pesimista) del proceso recursivo.
7
B
Se produce la terminación anticipada al desencolar el elemento
"3"; se invierte lo que queda (desde el 2 hasta el 8); se vuelve a
encolar el "3" y, en la fase de vuelta, se encolan los restantes.
8
A
La opción else constituye la fase de “transición” y contempla el
resto de las (3) situaciones posibles.