Evaluacion final - Escenario 8

Fecha de entrega
10 de mayo en 23:55
Puntos
100
Preguntas
20
Disponible
7 de mayo en 0:00 - 10 de mayo en 23:55
4 días
Límite de tiempo
90 minutos
Intentos permitidos
2

Instrucciones
 Volver a realizar el examen

Historial de intentos

Intento Hora Puntaje

MÁS RECIENTE Intento 1
49 minutos 95 de 100


Las respuestas correctas ya no están disponibles.

Puntaje para este intento:

95 de 100
Entregado el 8 de mayo en 20:54
Este intento tuvo una duración de 49 minutos.

Pregunta 1 5
/ 5 pts

Se desea implementar el sistema de visión de un robot clasificador de piezas. El robot ve a través de una
cámara que transforma la imagen de cada pieza en una matriz de 5 filas y 5 columnas. Cada celda de la
matriz contiene un 1 o un 0, de acuerdo a si el color en dicho píxel es negro o blanco, respectivamente.

Una pieza puede ser rotada 90, 180 o 270 grados. Además, puede volcarse. Como ejemplo de lo anterior, las
siguientes imágenes corresponden a un mismo tipo de pieza:

Su tarea es implementar un programa que reciba las matrices de dos imágenes e indique si las imágenes
corresponden a piezas del mismo tipo.
Como parte del programa que resuelve el problema enunciado, se debe implementar un método que tome
como entrada una matriz con una imagen y retorne una segunda matriz con la imagen rotada 90 grados en
sentido contrario a las manecillas del reloj.

El método que cumple este propósito es:

static byte[][] rotar_imagen(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[i][j] = img[4-j][i];

             return rotada;

 
       }

static byte[][] rotar_imagen(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[i][j] = img[i][4-j];

             return rotada;

 
       }
 static byte[][] rotar_imagen(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[4-j][i] = img[i][j];

             return rotada;

 
       }

Al usar la instrucción rotada[i][j] = img[j][i], se calcula la transpuesta de la matriz de entrada. La transpuesta

corresponde a la matriz rotada en sentido contrario a las manecillas del reloj, pero también reflejada invirtiendo el
orden de las filas.

rotada[i][j] = img[4-j][i] rota la matriz en el sentido de las manecillas del reloj.

rotada[i][j] = img[i][4-j] refleja la matriz invirtiendo el orden de las columnas.

rotada[4-j][i] = img[i][j] rota la matriz en el sentido contrario a las manecillas del reloj. Por tanto, ésta es la opción
correcta.

static byte[][] rotar_imagen(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[i][j] = img[j][i];

             return rotada;

 
       }
Pregunta 2 5
/ 5 pts

Se desea implementar el sistema de visión de un robot clasificador de piezas. El robot ve a través de una
cámara que transforma la imagen de cada pieza en una matriz de 5 filas y 5 columnas. Cada celda de la
matriz contiene un 1 o un 0, de acuerdo a si el color en dicho píxel es negro o blanco, respectivamente.

Una pieza puede ser rotada 90, 180 o 270 grados. Además, puede volcarse. Como ejemplo de lo anterior, las
siguientes imágenes corresponden a un mismo tipo de pieza:

Su tarea es implementar un programa que reciba las matrices de dos imágenes e indique si las imágenes
corresponden a piezas del mismo tipo.

Como parte del programa que resuelve el problema enunciado, se debe implementar un método que tome
como entrada una matriz con una imagen y retorne la imagen reflejada de manera que se invierte el orden
las columnas.

El método que cumple este propósito es:

 static byte[][] reflejar(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[4-j][i] = img[i][j];

             return rotada;

 
       }

static byte[][] reflejar(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[i][j] = img[i][4-j];

             return rotada;

 
       }

Al usar la instrucción rotada[i][j] = img[j][i], se calcula la transpuesta de la matriz de entrada. La transpuesta

corresponde a la matriz rotada en sentido contrario a las manecillas del reloj y reflejada invirtiendo el orden de las
filas.

rotada[4-j][i] = img[i][j] rota la matriz en el sentido contrario a las manecillas del reloj.

rotada[i][j] = img[4-j][i] rota la matriz en el sentido de las manecillas del reloj.

rotada[i][j] = img[i][4-j] refleja la matriz invirtiendo el orden de las columnas. Por tanto, ésta es la opción correcta.
 static byte[][] reflejar(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[i][j] = img[4-j][i];

             return rotada;

 
       }

static byte[][] reflejar(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[i][j] = img[j][i];

             return rotada;

 
       }

Pregunta 3 5
/ 5 pts

Se desea implementar el sistema de visión de un robot clasificador de piezas. El robot ve a través de una
cámara que transforma la imagen de cada pieza en una matriz de 5 filas y 5 columnas. Cada celda de la
matriz contiene un 1 o un 0, de acuerdo a si el color en dicho píxel es negro o blanco, respectivamente.

Una pieza puede ser rotada 90, 180 o 270 grados. Además, puede volcarse. Como ejemplo de lo anterior, las
siguientes imágenes corresponden a un mismo tipo de pieza:
Su tarea es implementar un programa que reciba las matrices de dos imágenes e indique si las imágenes
corresponden a piezas del mismo tipo.

Antes de procesar una imagen, debe verificarse que ésta tenga el tamaño adecuado (5 filas y 5 columnas).
La expresión que permita hacer dicha verificación es:

 
img.length == 25

 
length == 5 && img[0].length == 5

Para obtener el número de filas de una matriz se usa su atributo length (img.-length). Por otra parte, para conocer el
número de columnas basta con consultar el número de elementos de cualquiera de las filas de la matriz
(matriz[0].length).

 
img.rows == 5 && img.cols == 5

 
img.length == 5

Pregunta 4 5
/ 5 pts

Se dice que Leonardo de Pisa, más conocido como Fibonacci, descubrió la sucesión que lleva su nombre
estudiando cómo crecía una población de conejos. El crecimiento de la población seguía las siguientes
reglas:
 La población inicia con una pareja de conejos jóvenes.
Una pareja de conejos jóvenes madura al cumplir un mes.
Una pareja de conejos concibe una nueva pareja de conejos jóvenes cada mes, iniciando un mes
después de su maduración.

Así, en los meses 1 y 2 se tendría únicamente una pareja. Para el mes 3, habría ya una nueva pareja, para
un total de 2. En el mes 4, la pareja ya madura tendría una nueva pareja, completando 3 parejas. En el mes
5, la primera pareja y su primera pareja cría engendrarían dos nuevas parejas, siendo la población total 5
parejas.

El número de parejas que conforman la población en el mes n puede calcularse mediante la ecuación de
recurrencia:

De los siguientes, un método que no evalúa correctamente la ecuación de recurrencia presentada es:

static long parejas(int n){

            return (n==1 || n==2)?1:parejas(n-1) + parejas(n-2);

 
       }

static long parejas(int n){

            if (n>2) return parejas(n-1) + parejas(n-2);

            return 1;

 
       }

static long parejas(int n){

            if (n==1 || n==2) return 1;

            return parejas(n-1) + parejas(n-2);

 
       }
 static long parejas(int n){

            if (n==1 || n==2) return 1;

            if (n>2) return parejas(n-1) + parejas(n-2);

 
       }

La implementación

static long parejas(int n){

if (n==1 || n==2) return 1;

if (n>2) return parejas(n-1) + parejas(n-2);

Generará un error de compilación ya que el compilador no sabrá que retornar cuando no se satisfaga
ninguna de las dos condiciones (note que el compilador no tiene por qué saber que n nunca será menor a
1).

Las implementaciones restantes son equivalentes y correctas.

Pregunta 5 5
/ 5 pts

Las calles de la ciudad de Bacatá forman una cuadrícula perfecta, como se muestra en la ilustración 1.
 Ilustración 1. Área de la ciudad de Bacatá entre las calles 1 a 6 y las carreras 1 a 6.

Las vías horizontales son llamadas calles y están enumeradas iniciando en 1. Las vías verticales son
llamadas carreras y están numeradas de igual forma.

El alcalde de Bacatá ha decidido modificar la forma en que las tarifas de los taxis son calculadas,
considerando la geometría de la ciudad.  Las nuevas tarifas se calcularán de acuerdo a la calle y carrera de
la intersección donde se toma el taxi, así como a la calle y carrera donde finaliza el viaje. Específicamente, el
costo de un viaje se calcula como

donde |x| representa el valor absoluto de x.

El alcalde le ha pedido personalmente a usted que construya la aplicación que calculará las nuevas tarifas y
reemplazará a los taxímetros actuales. La aplicación debe solicitar la información de los puntos de inicio y
finalización del viaje, e informar al usuario cuánto deberá pagar al llegar a su destino.

A continuación se propone una expresión para calcular el costo de un viaje:

100 * ((cll_destino - cll_origen)  + (car_destino - car_origen))

La expresión propuesta es:

 
Correcta. Dado que la calle y carrera de destino son siempre mayores que la calle y carrera de origen, no es
necesario el uso de valor absoluto.

 
Incorrecta porque se omite el cálculo de los valores absolutos.

La expresión es incorrecta debido a que omite la evaluación de los valores absolutos de las diferencias. Esto puede
ocasionar incluso que se obtenga un costo de viaje negativo, lo cual no tiene interpretación alguna.

Debido a que la ecuación original incluye el valor absoluto de cada diferencia, el orden de los puntos de origen y
destino no tiene efecto alguno sobre el resultado.

 En la ecuación presentada en el enunciado, el signo $ indica que el resultado está en unidades monetarias; sin
embargo, esto no debe ser tenido en cuenta en el programa.

 
Incorrecta porque se invierte el orden de los puntos origen y destino.

 
Incorrecta porque el valor de 100 no es precedido por el símbolo $.

Pregunta 6 5
/ 5 pts

 Se desea implementar el sistema de visión de un robot clasificador de piezas. El robot ve a través de una
cámara que transforma la imagen de cada pieza en una matriz de 5 filas y 5 columnas. Cada celda de la
matriz contiene un 1 o un 0, de acuerdo a si el color en dicho píxel es negro o blanco, respectivamente.
Una pieza puede ser rotada 90, 180 o 270 grados. Además, puede volcarse. Como ejemplo de lo anterior, las
siguientes imágenes corresponden a un mismo tipo de pieza:

Su tarea es implementar un programa que reciba las matrices de dos imágenes e indique si las imágenes
corresponden a piezas del mismo tipo.

Como parte del programa que resuelve el problema enunciado, se debe implementar un método que tome
como entradas dos matrices correspondientes a dos imágenes y retorne un valor booleano indicando si las
imágenes son idénticas (sin rotaciones ni reflejo).

Para esto, se tiene el siguiente código:

static boolean son_iguales(byte[][] img1, byte[][] img2){

            for (int i = 0; i < img1.length; i++)

                   if (<condicion>) return false;

            return true;<condicion>

       }

Para que el método funcione correctamente, <condicion> debe reemplazarse por:

 
img1 != img2

 
!Arrays.equals(img1[i], img2[i])

 Al comparar dos arreglos (o matrices) usando el operador != se está interrogando sobre si los arreglos (o matrices)
son el mismo, mas no sobre sus contenidos. Así, dos arreglos distintos pero de idéntico contenido darían como
resultado verdadero, lo cual es incorrecto.

El método Arrays.equals permite comparar dos arreglos por contenido. Para preguntar si sus contenidos son
diferentes basta negar el resultado de este método.

El método Arrays.not_equals no existe.

 
img1[i] != img2[i]

 
Arrays.not_equals(img1[i], img2[i])

Pregunta 7 5
/ 5 pts

David quiere desarrollar un programa de edición de código java que le permita hacer su código más legible y
calcule algunos datos interesantes. Dado que el procesamiento de información textual no es su fuerte, David
le ha pedido su ayuda para codificar algunas de las tareas básicas del editor.

David cree que si representa el texto como un arreglo de valores char en lugar de como un String, su programa
será más eficiente. La instrucción que le permite convertir el código representado como String en un arreglo
de chars es:

 
char[] cod_arr = (char[]) cod;

 
char[] cod_arr = cod;
  
char[] cod_arr = cod.toCharArray();

No es posible hacer una conversión directa de String a char[], por lo que las instrucciones

char[] cod_arr = cod;  y char[] cod_arr = (char[]) cod; generarán errores de compilación.

El método de la clase String que permite convertir una cadena a arreglo de chars es toCharArray.

 
char[] cod_arr = cod.toArray();

Pregunta 8 5
/ 5 pts

Se desea implementar el sistema de visión de un robot clasificador de piezas. El robot ve a través de una
cámara que transforma la imagen de cada pieza en una matriz de 5 filas y 5 columnas. Cada celda de la
matriz contiene un 1 o un 0, de acuerdo a si el color en dicho píxel es negro o blanco, respectivamente.

Una pieza puede ser rotada 90, 180 o 270 grados. Además, puede volcarse. Como ejemplo de lo anterior, las
siguientes imágenes corresponden a un mismo tipo de pieza:

Su tarea es implementar un programa que reciba las matrices de dos imágenes e indique si las imágenes
corresponden a piezas del mismo tipo.

El tipo de dato más apropiado para representar una imagen en el lenguaje java es:
  
int[][]

 
double[]

 
double[][]

 
byte[][]

La matriz que representa una imagen está compuesta únicamente de 1s y 0s, los cuales son valores enteros.
Además, cada dato hace uso solamente de un bit, por lo que debería usarse un tipo de dato lo más pequeño posible.
El tipo de dato entero más pequeño es byte. Dado que es una matriz, el tipo byte debe ir acompañado de dos parejas
de corchetes (byte[][]).

Pregunta 9 5
/ 5 pts

David quiere desarrollar un programa de edición de código java que le permita hacer su código más legible y
calcule algunos datos interesantes. Dado que el procesamiento de información textual no es su fuerte, David
le ha pedido su ayuda para codificar algunas de las tareas básicas del editor.

David ha notado que cuando se requiere imprimir el código sería de gran utilidad (por la cantidad de papel
gastado) eliminar la indentación: el margen izquierdo de las líneas. La instrucción que le permite tomar una
línea de código y eliminar su margen izquierdo es:

 
trim();

 
linea = linea.removeLeftMargin();
  
removeLeftMargin();

 
linea = linea.trim();

A pesar de que removeLeftMargin es un nombre razonable para el método, el método de la clase String tiene
nombre trim. Además, al ser las cadenas inmutables, éste método no modifica la cadena que le invoca sino
que retorna una segunda cadena con el contenido modificado. Por tanto, el valor de retorno del método
debe ser asignado nuevamente a la cadena que invoca.

De lo anterior se concluye que la respuesta correcta es

 linea = linea.trim();

Pregunta 10 5
/ 5 pts

Se desea implementar el sistema de visión de un robot clasificador de piezas. El robot ve a través de una
cámara que transforma la imagen de cada pieza en una matriz de 5 filas y 5 columnas. Cada celda de la
matriz contiene un 1 o un 0, de acuerdo a si el color en dicho píxel es negro o blanco, respectivamente.

Una pieza puede ser rotada 90, 180 o 270 grados. Además, puede volcarse. Como ejemplo de lo anterior, las
siguientes imágenes corresponden a un mismo tipo de pieza:
Su tarea es implementar un programa que reciba las matrices de dos imágenes e indique si las imágenes
corresponden a piezas del mismo tipo.

Antes de procesar una imagen, debe verificarse que ésta contenga únicamente los valores 0 y 1. Se desea
un método que retorne verdadero si la imagen es correcta o falso si contiene colores no aceptados (valores
diferentes a 0 ó 1).

El método que hace correctamente esta verificación es:

static boolean verificar_colores(byte[][] img){

                       for (int i = 0; i < 5; i++)

                                  for (int j = 0; j < 5; j++)

                                              if (img[i][j]==1 || img[i][j]==0) return true;

                       return false;

 
            }

static boolean verificar_colores(byte[][] img){

                       for (int i = 0; i < 5; i++)

                                  for (int j = 0; j < 5; j++)

                                              if (img[i][j]==1 && img[i][j]==0) return true;

                       return false;

 
           }

static boolean verificar_colores(byte[][] img){

                       for (int i = 0; i < 5; i++)

                                  for (int j = 0; j < 5; j++)

                                              if (img[i][j]!=1 || img[i][j]!=0) return false;

                       return true;

 
           }

static boolean verificar_colores(byte[][] img){

           for (int i = 0; i < 5; i++)

                                  for (int j = 0; j < 5; j++)

                                              if (img[i][j]!=1 && img[i][j]!=0) return false;

                       return true;

 
           }
 Debe verificarse para cada elemento de la matriz si es 1 o 0. En caso contrario, sabremos que la condición verificada
no se cumple. Solamente es posible afirmar que la condición se cumple cuando se ha recorrido en su totalidad la
matriz.

Las opciones if (img[i][j]==1 || img[i][j]==0) return true; y if (img[i][j]==1 && img[i][j]==0) return true; terminan el método
prematuramente sin verificar toda la matriz.

En  if (img[i][j]!=1 || img[i][j]!=0) return false;, la condición siempre se satisface ya que la posición no puede contener
simultáneamente un 1 y un 0. Esto hace que el método siempre retorne falso, independientemente del contenido de
la matriz.

La opción correcta es if (img[i][j]!=1 && img[i][j]!=0) return false;, ya que solamente afirma que la condición verificada
no es satisfecha cuando se encuentra una posición que no contiene un 1 y tampoco contiene un 0.

Pregunta 11 5
/ 5 pts

David quiere desarrollar un programa de edición de código java que le permita hacer su código más legible y
calcule algunos datos interesantes. Dado que el procesamiento de información textual no es su fuerte, David
le ha pedido su ayuda para codificar algunas de las tareas básicas del editor.

Una de las funcionalidades con que David desea que cuente su editor es la de calcular el número de líneas
de código en un archivo. El editor debe contar únicamente las líneas no vacías.

El siguiente método calcula el número de líneas de código en el texto representado por la cadena de entrada.

static int contar_lineas(String codigo){

codigo = codigo + "\n";

int contador=0;

for (int i = 0; i < codigo.length(); i++)

if (<condicion>)

                   contador = contador + 1;

return contador;

Para que el método sea correcto, <condicion> debe ser reemplazado por:
  
codigo.charAt(i)!='\n' && codigo.charAt(i-1)=='\n'

 
codigo.charAt(i)=='\n'

 
codigo.charAt(i)=='\n' && i>0 && codigo.charAt(i-1)!='\n'

El programa cuenta las ocurrencias del símbolo ‘\n’, lo cual es igual al número de líneas en el código. Se omite en la
cuenta los símbolos de nueva línea precedidos de símbolos idénticos, ya que estos corresponden a líneas vacías.

codigo.charAt(i)=='\n' no verifica que el símbolo de nueva línea no corresponda a una línea vacía.

codigo.charAt(i)=='\n' && codigo.charAt(i-1)!='\n' y codigo.charAt(i)!='\n' && codigo.charAt(i-1)=='\n' generan errores

en tiempo de ejecución cuando i = 0. 

codigo.charAt(i)=='\n' && i>0 && codigo.charAt(i-1)!='\n' verifica que el símbolo ‘\n’ no represente una línea vacía y
que i > 0 , evitando errores en tiempo de ejecución. Por tanto, ésta es la respuesta correcta.

 
codigo.charAt(i)=='\n' && codigo.charAt(i-1)!='\n'

Pregunta 12 5
/ 5 pts

David quiere desarrollar un programa de edición de código java que le permita hacer su código más legible y
calcule algunos datos interesantes. Dado que el procesamiento de información textual no es su fuerte, David
le ha pedido su ayuda para codificar algunas de las tareas básicas del editor.

Una de las funcionalidades con que David desea que cuente su editor es la de decidir si un nombre de
variable es válido o no. Recuerde que un nombre de variable válido puede contener únicamente letras,
dígitos, guiones bajos (_) y signos de dólar ($). Además, el primer símbolo del nombre no puede ser un
dígito.
La expresión que permite verificar si el primer símbolo del nombre es un dígito es:

 
length() > 0 && nombre.charAt(0)>=0 && nombre.charAt(0)<=9

 
nombre.length() > 0 && nombre.charAt(0)>=9 && nombre.charAt(0)<=0

 
length() > 0 && nombre.charAt(0)>=’9’ && nombre.charAt(0)<=’0’

 
length() > 0 && nombre.charAt(0)>=’0’ && nombre.charAt(0)<=’9’

Para verificar que un carácter corresponda a un dígito basta con preguntar si su código se encuentra entre el
código del carácter ‘0’ (48) y el código del carácter ‘9’ (57), inclusive.

Pregunta 13 5
/ 5 pts

David quiere desarrollar un programa de edición de código java que le permita hacer su código más legible y
calcule algunos datos interesantes. Dado que el procesamiento de información textual no es su fuerte, David
le ha pedido su ayuda para codificar algunas de las tareas básicas del editor.

Una de las funcionalidades con que David desea que cuente su editor es la de decidir si un nombre de
variable es válido o no. Recuerde que un nombre de variable válido puede contener únicamente letras,
dígitos, guiones bajos (_) y signos de dólar ($). Además, el primer símbolo del nombre no puede ser un
dígito.

La expresión que permite verificar si un símbolo c es una letra, un dígito, un guión bajo o un signo de dólar
es:
  
(c >= ’A’ && c <= ’Z’) || (c >= ’a’ && c <= ’z’) || (c >= ’0’ && c <= ’9’) || c == ’_’ || c == ’$’

Un carácter corresponde a una letra si su código se encuentra entre el código de ‘A’ y el código de ‘Z’, o entre el
código de ‘a’ y el código de ‘z’.

De igual forma, un carácter corresponde a un dígito si su código se encuentra entre el código de ‘0’ y el código de ‘9’.

Por tanto, la opción correcta es

(c >= ’A’ && c <= ’Z’) || (c >= ’a’ && c <= ’z’) || (c >= ’0’ && c <= ’9’) || c == ’_’ || c
== ’$’

 
((c >= ’A’ || c <= ’a’) && (c >= ’Z’ || c <= ’z’)) || (c >= ’0’ || c <= ’9’) || c == ’_’ || c == ’$’

 
(c >= ’A’ && c <= ’a’) || (c >= ’Z’ && c <= ’z’) || (c >= ’0’ && c <= ’9’) || c == ’_’ || c == ’$’

 
((c >= ’A’ || c <= ’Z’) && (c >= ’a’ || c <= ’z’)) || (c >= ’0’ || c <= ’9’) || c == ’_’ || c == ’$’

Pregunta 14 5
/ 5 pts

Para el desarrollo de programas en Java ¿Cuál es el propósito del comando o instrucción WHILE?

 
Inferenciales

 
bucles o ciclos

  
Condicionales

 
Declaración de variables.

Pregunta 15 5
/ 5 pts

Las calles de la ciudad de Bacatá forman una cuadrícula perfecta, como se muestra en la ilustración 1.

Ilustración 1. Área de la ciudad de Bacatá entre las calles 1 a 6 y las carreras 1 a 6.

Las vías horizontales son llamadas calles y están enumeradas iniciando en 1. Las vías verticales son
llamadas carreras y están numeradas de igual forma.

 
El alcalde de Bacatá ha decidido modificar la forma en que las tarifas de los taxis son calculadas,
considerando la geometría de la ciudad.  Las nuevas tarifas se calcularán de acuerdo a la calle y carrera de
la intersección donde se toma el taxi, así como a la calle y carrera donde finaliza el viaje. Específicamente, el
costo de un viaje se calcula como

donde |x| representa el valor absoluto de x.

El alcalde le ha pedido personalmente a usted que construya la aplicación que calculará las nuevas tarifas y
reemplazará a los taxímetros actuales. La aplicación debe solicitar la información de los puntos de inicio y
finalización del viaje, e informar al usuario cuánto deberá pagar al llegar a su destino.

El alcalde le ha pedido que su programa, además de resolver el problema ya planteado, permita mostrar en
pantalla el mapa de la ciudad. Dadas las limitaciones de los dispositivos donde se correrá la aplicación, el
mapa debe ser formado por símbolos imprimibles. Cada manzana de la ciudad será dibujada de la siguiente
forma:

Se requiere un método que muestre en pantalla una calle de seis manzanas:

           

El arreglo manzana contiene la representación gráfica de una manzana. De los siguientes, el método que
dibuja correctamente una calle de seis manzanas es:

static void pintar_calle(){

      String[] manzana = {"+---+\n", "|   |\n", "+---+\n"};

            String[] linea = {"", "", ""};

      for (int i = 0; i < linea.length; i++) {

                   for (int j = 0; j < 6; j++) {

                          linea[i] = linea[i] + "  " + manzana[i];

                   }    

                   System.out.println(linea[i]);

            }

 
}
 static void pintar_calle(){

            String[] manzana = {"+---+", "|   |", "+---+"};

      String[] linea = {"", "", ""};

      for (int i = 0; i < linea.length; i++) {

                   for (int j = 0; j < 6; j++) {

                          linea[i] = linea[i] + "  " + manzana[i];

                   }

            System.out.println(linea[i]);

      }

 
}

El método

static void pintar_calle(){

      String[] manzana = {"+---+", "|   |", "+---+"};

      for (int j = 0; j < 6; j++)

            for (int i = 0; i < 3; i++)

                  System.out.println(manzana[i]);

dibuja una manzana sobre la otra.

El método

static void pintar_calle(){

      String[] manzana = {"+---+\n", "|   |\n", "+---+\n"};

      String[] linea = {"", "", ""};

      for (int i = 0; i < linea.length; i++) {

            for (int j = 0; j < 6; j++) {

                  linea[i] = linea[i] + "  " + manzana[i];

            }    

            System.out.println(linea[i]);

      }

falla debido a los saltos de línea al final de cada cadena de la manzana.

El método

static void pintar_calle(){

      String[] manzana = {"+---+", "|   |", "+---+"};

      String[] linea = {"", "", ""};

      for (int i = 0; i < linea.length; i++)

            for (int j = 0; j < 6; j++)

                  linea[i] = linea[i] + "  " + manzana[i];

            System.out.println(linea[i]);

       }

no compila debido a la ausencia de llaves del ciclo for i.

El método

static void pintar_calle(){

    String[] manzana = {"+---+", "|   |", "+---+"};

    String[] linea = {"", "", ""};

    for (int i = 0; i < linea.length; i++) {

         for (int j = 0; j < 6; j++) {

                  linea[i] = linea[i] + "  " + manzana[i];

           }

           System.out.println(linea[i]);

    }

dibuja la cuadra correctamente.

static void pintar_calle(){

       String[] manzana = {"+---+", "|   |", "+---+"};

            String[] linea = {"", "", ""};

      for (int i = 0; i < linea.length; i++)

            for (int j = 0; j < 6; j++)

                          linea[i] = linea[i] + "  " + manzana[i];

                   System.out.println(linea[i]);

            }

 
}

static void pintar_calle(){

      String[] manzana = {"+---+", "|   |", "+---+"};

            for (int j = 0; j < 6; j++)

                   for (int i = 0; i < 3; i++)

                          System.out.println(manzana[i]);

 
}

Pregunta 16 5
/ 5 pts
Se dice que Leonardo de Pisa, más conocido como Fibonacci, descubrió la sucesión que lleva su nombre
estudiando cómo crecía una población de conejos. El crecimiento de la población seguía las siguientes
reglas:

La población inicia con una pareja de conejos jóvenes.

Una pareja de conejos jóvenes madura al cumplir un mes.
Una pareja de conejos concibe una nueva pareja de conejos jóvenes cada mes, iniciando un mes
después de su maduración.

Así, en los meses 1 y 2 se tendría únicamente una pareja. Para el mes 3, habría ya una nueva pareja, para
un total de 2. En el mes 4, la pareja ya madura tendría una nueva pareja, completando 3 parejas. En el mes
5, la primera pareja y su primera pareja cría engendrarían dos nuevas parejas, siendo la población total 5
parejas.

El número de parejas que conforman la población en el mes n puede calcularse mediante la ecuación de
recurrencia:

El número de parejas que forman la población después de 12 meses es:

 
233

 
12

 
89

 
144

parejas(12)  = parejas(11) + parejas(10)  

parejas(11)  = parejas(10) + parejas(9)  

parejas(10)  = parejas(9) + parejas(8)  

parejas(9)  = parejas(8) + parejas(7)  

parejas(8)  = parejas(7) + parejas(6)  

parejas(7)  = parejas(6) + parejas(5)  

parejas(6)  = parejas(5) + parejas(4)  

parejas(5)  = parejas(4) + parejas(3)  

parejas(4)  = parejas(3) + parejas(2)  

parejas(3)  = parejas(2) + parejas(1)  

parejas(2)  = 1

parejas(1)  = 1

entonces

parejas(3)  = 1 + 1 = 2

parejas(4)  = 2 + 1 = 3

parejas(5)  = 3 + 2 = 5

parejas(6)  = 5 + 3 = 8

parejas(7)  = 8 + 5 = 13

parejas(8)  = 13 + 8 = 21

parejas(9)  = 21 + 13 = 34

parejas(10)  = 34 + 21 = 55

parejas(11)  = 55 + 34 = 89

parejas(12)  = 89 + 55 = 144
Pregunta 17 5
/ 5 pts

Se desea implementar el sistema de visión de un robot clasificador de piezas. El robot ve a través de una
cámara que transforma la imagen de cada pieza en una matriz de 5 filas y 5 columnas. Cada celda de la
matriz contiene un 1 o un 0, de acuerdo a si el color en dicho píxel es negro o blanco, respectivamente.

Una pieza puede ser rotada 90, 180 o 270 grados. Además, puede volcarse. Como ejemplo de lo anterior, las
siguientes imágenes corresponden a un mismo tipo de pieza:

Su tarea es implementar un programa que reciba las matrices de dos imágenes e indique si las imágenes
corresponden a piezas del mismo tipo.

Como solución definitiva al problema enunciado, se propuso el siguiente método:

static boolean comparar_imagenes(byte[][] img1, byte[][] img2){

            for (int i = 0; i < 2; i++) {

                     for (int j = 0; j < 4; j++) {

                          if (son_iguales(img1, img2)) return true;

                          img2 = rotar_imagen(img2);

                   }

                   img2 = reflejar(img2);

            }

            return false;

      }

La función rotar_imagen retorna una copia de la imagen de entrada rotada 90 grados en sentido contrario
a las manecillas del reloj.
La función reflejar retorna una copia de la imagen de entrada invirtiendo el orden de sus columnas.
 La función son_iguales retorna un valor booleano indicando si las dos matrices son idénticas o no.

Sobre el método comparar_imágenes es posible afirmar que:

 
No resuelve el problema ya que solamente se refleja una de las imágenes, no las dos.

 
No resuelve el problema ya que solamente se rota una de las imágenes, no las dos.

 
Resuelve el problema de manera correcta.

El método toma como referencia la imagen img1 y modifica la imagen img2 intentando hacerlas idénticas. La rotación
de img2 ocurre 4 veces, probando todas las rotaciones posibles. Esto hace que sea indiferente si se rota en el
sentido de las manecillas del reloj o en sentido contrario. Adicionalmente, la imagen es reflejada y rotada 4 veces
nuevamente, por lo que todas las distintas versiones de una misma pieza son verificadas.

En conclusión, el método es correcto.

 
No resuelve el problema ya que rotar_imagen debería rotar la imagen en el sentido de las manecillas del reloj, y no
en sentido contrario.

Pregunta 18 5
/ 5 pts

Se dice que Leonardo de Pisa, más conocido como Fibonacci, descubrió la sucesión que lleva su nombre
estudiando cómo crecía una población de conejos. El crecimiento de la población seguía las siguientes
reglas:

La población inicia con una pareja de conejos jóvenes.

Una pareja de conejos jóvenes madura al cumplir un mes.
 Una pareja de conejos concibe una nueva pareja de conejos jóvenes cada mes, iniciando un mes
después de su maduración.

Así, en los meses 1 y 2 se tendría únicamente una pareja. Para el mes 3, habría ya una nueva pareja, para
un total de 2. En el mes 4, la pareja ya madura tendría una nueva pareja, completando 3 parejas. En el mes
5, la primera pareja y su primera pareja cría engendrarían dos nuevas parejas, siendo la población total 5
parejas.

El número de parejas que conforman la población en el mes n puede calcularse mediante la ecuación de
recurrencia:

El número de parejas que forman la población después de 20 meses es:

 
6765

 parejas(20)  = parejas(19) + parejas(18) 

parejas(19)  = parejas(18) + parejas(17) 

parejas(18)  = parejas(17) + parejas(16) 

parejas(17)  = parejas(16) + parejas(15) 

parejas(16)  = parejas(15) + parejas(14) 

parejas(15)  = parejas(14) + parejas(13) 

parejas(14)  = parejas(13) + parejas(12) 

parejas(13)  = parejas(12) + parejas(11) 

parejas(12)  = parejas(11) + parejas(10) 

parejas(11)  = parejas(10) + parejas(9) 

parejas(10)  = parejas(9) + parejas(8) 

parejas(9)  = parejas(8) + parejas(7) 

parejas(8)  = parejas(7) + parejas(6) 

parejas(7)  = parejas(6) + parejas(5) 

parejas(6)  = parejas(5) + parejas(4) 

parejas(5)  = parejas(4) + parejas(3) 

parejas(4)  = parejas(3) + parejas(2) 

parejas(3)  = parejas(2) + parejas(1) 

parejas(2)  = 1

parejas(1)  = 1

entonces

parejas(3)  = 1 + 1 = 2

parejas(4)  = 2 + 1 = 3

parejas(5)  = 3 + 2 = 5

parejas(6)  = 5 + 3 = 8

parejas(7)  = 8 + 5 = 13

parejas(8)  = 13 + 8 = 21

parejas(9)  = 21 + 13 = 34

parejas(10)  = 34 + 21 = 55

parejas(11)  = 55 + 34 = 89

parejas(12)  = 89 + 55 = 144

parejas(13)  = 144 + 89 = 233

parejas(14)  = 233 + 144 = 377

parejas(15)  = 377 + 233 = 610

parejas(16)  = 610 + 377 = 987

parejas(17)  = 987 + 610 = 1597

parejas(18)  = 1597 + 987 = 2584

parejas(19)  = 2584 + 1597 = 4181

parejas(20)  = 4181 + 2584 = 6765

 
10946

 
2584

 
4181

Incorrecto Pregunta 19 0
/ 5 pts

Se desea implementar el sistema de visión de un robot clasificador de piezas. El robot ve a través de una
cámara que transforma la imagen de cada pieza en una matriz de 5 filas y 5 columnas. Cada celda de la
matriz contiene un 1 o un 0, de acuerdo a si el color en dicho píxel es negro o blanco, respectivamente.

Una pieza puede ser rotada 90, 180 o 270 grados. Además, puede volcarse. Como ejemplo de lo anterior, las
siguientes imágenes corresponden a un mismo tipo de pieza:

Su tarea es implementar un programa que reciba las matrices de dos imágenes e indique si las imágenes
corresponden a piezas del mismo tipo.

Como parte del programa que resuelve el problema enunciado, se debe implementar un método que tome
como entrada una matriz con una imagen y retorne una segunda matriz con la imagen rotada 90 grados en el
sentido de las manecillas del reloj.

El método que cumple este propósito es:

 static byte[][] rotar_imagen(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[i][j] = img[j][i];

             return rotada;

 
       }

static byte[][] rotar_imagen(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[i][j] = img[i][4-j];

             return rotada;

 
       }

static byte[][] rotar_imagen(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[i][j] = img[4-j][i];

             return rotada;

 
       }
 static byte[][] rotar_imagen(byte[][] img) {

             byte[][] rotada = new byte[5][5];

             for (int i = 0; i < 5; i++)

                    for (int j = 0; j < 5; j++)

                           rotada[4-j][i] = img[i][j];

             return rotada;

 
       }

Pregunta 20 5
/ 5 pts

David quiere desarrollar un programa de edición de código java que le permita hacer su código más legible y
calcule algunos datos interesantes. Dado que el procesamiento de información textual no es su fuerte, David
le ha pedido su ayuda para codificar algunas de las tareas básicas del editor.

Una de las funcionalidades con que David desea que cuente su editor es la de eliminar líneas vacías del
código. El siguiente método recibe un código y retorna el código sin líneas vacías.

static String eliminar_lineas_vacias(String codigo){

      String nuevo_codigo = "";

      codigo = "\n" + codigo;

      for (int i = 1; i < codigo.length(); i++)

            if (<condicion>)

                   nuevo_codigo = nuevo_codigo + codigo.charAt(i);

      return nuevo_codigo;

Para que el método sea correcto, <condicion> debe ser reemplazado por:

 
charAt(i)!='\n'
 
charAt(i)!='\n' || codigo.charAt(i-1)!='\n'

El método recorre la cadena de entrada y copia a la cadena de salida todos los símbolos que no representen una
cadena vacía.

Una cadena vacía es representada por un símbolo ‘\n’ precedido de otro símbolo igual.

codigo.charAt(i)!='\n' omite todos los saltos de línea, aun cuando no representen líneas vacías.

codigo.charAt(i-1)=='\n' solamente copia el símbolo que inicia cada fila, no las filas completas.

codigo.charAt(i)=='\n' && codigo.charAt(i-1)=='\n' copia solamente líneas vacías, todo lo contrario a lo que esperamos
que haga el método.

codigo.charAt(i)!='\n' || codigo.charAt(i-1)!='\n' copia todos los símbolos exceptos los saltos de línea que representen
líneas vacías. Por tanto, ésta es la respuesta correcta.

 
charAt(i-1)=='\n'

 
charAt(i)=='\n' && codigo.charAt(i-1)=='\n'

Puntaje del examen:

95 de 100