Programacion de Computado

Evaluacion final - Escenario 8
Fecha de entrega 12 de mayo en 23:55 Puntos 100 Preguntas 20

Disponible 9 de mayo en 0:00 - 12 de mayo en 23:55 4 días Límite de tiempo 90 minutos
Intentos permitidos 2
Instrucciones
Historial de intentos
Intento Hora Puntaje

Intento Hora Puntaje
MANTENER Intento 2 38 minutos 95 de 100
MÁS RECIENTE Intento 2 38 minutos 95 de 100
Intento 1 56 minutos 85 de 100
 Las respuestas correctas estarán disponibles del 13 de mayo en 23:55 al 14 de mayo en 23:55.
Puntaje para este intento: 95 de 100

Entregado el 10 de mayo en 0:06
Este intento tuvo una duración de 38 minutos.
Incorrecto Pregunta 1 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 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:
Arrays.not_equals(img1[i], img2[i])
img1 != img2
img1[i] != img2[i]
!Arrays.equals(img1[i], img2[i])
Pregunta 2 5 / 5 pts

tipo de pieza:

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:
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 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.
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.

tipo de pieza:

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;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
rotada[i][j] = img[i][4-j];
return rotada;
}
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
rotada[4-j][i] = img[i][j];
return rotada;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
rotada[i][j] = img[4-j][i];
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.
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.toArray();
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.

tipo de pieza:

retorne una segunda matriz con la imagen rotada 90 grados en sentido contrario a
las manecillas del reloj.
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
return rotada;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
return rotada;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
return rotada;
}
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
return rotada;

manecillas del reloj, pero también reflejada invirtiendo el orden de las filas.
rotada[i][j] = img[i][4-j] refleja la matriz invirtiendo el orden de las columnas.
Por tanto, ésta es la opción correcta.

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' && 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)!='\n' && codigo.charAt(i-1)=='\n'
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:
89
12
144
parejas(12) = parejas(11) + parejas(10)
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
233

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:
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();
linea = linea.removeLeftMargin();
trim();
removeLeftMargin();
tipo de pieza:


retorne la imagen reflejada de manera que se invierte el orden las columnas.
static byte[][] reflejar(byte[][] img) {
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
return rotada;
}
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
return rotada;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
return rotada;

manecillas del reloj y reflejada invirtiendo el orden de las filas.
rotada[i][j] = img[i][4-j] refleja la matriz invirtiendo el orden de las columnas. Por tanto,
ésta es la opción correcta.
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
return rotada;
}

tipo de pieza:

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

tipo de pieza:

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 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.
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;
}

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;

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;
}

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-1)=='\n'
charAt(i)=='\n' && codigo.charAt(i-1)=='\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)!='\n'


parejas.

El número de parejas que forman la población después de 20 meses es:
10946
6765
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
4181
2584
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]);
}
}

String[] manzana = {"+---+", "| |", "+---+"};
String[] linea = {"", "", ""};
for (int i = 0; i < linea.length; i++)
for (int j = 0; j < 6; j++)
}
}

String[] manzana = {"+---+", "| |", "+---+"};
for (int j = 0; j < 6; j++)
for (int i = 0; i < 3; i++)
System.out.println(manzana[i]);
}
String[] manzana = {"+---+", "| |", "+---+"};
String[] linea = {"", "", ""};
for (int j = 0; j < 6; j++) {
}
}
}
El método

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

String[] manzana = {"+---+\n", "| |\n", "+---+\n"};
String[] linea = {"", "", ""};
for (int j = 0; j < 6; j++) {
}
}
}
falla debido a los saltos de línea al final de cada cadena de la manzana.
El método

String[] manzana = {"+---+", "| |", "+---+"};
String[] linea = {"", "", ""};
for (int i = 0; i < linea.length; i++)
for (int j = 0; j < 6; j++)
}
}
no compila debido a la ausencia de llaves del ciclo for i.

El método

String[] manzana = {"+---+", "| |", "+---+"};
String[] linea = {"", "", ""};
for (int j = 0; j < 6; j++) {
}
}
}
dibuja la cuadra correctamente.

tipo de pieza:

El tipo de dato más apropiado para representar una imagen en el lenguaje java
es:
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[][]).
double[]
int[][]

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 == ’$’
(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 == ’$’

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’

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.
nombre.length() > 0 && nombre.charAt(0)>=9 && nombre.charAt(0)<=0
length() > 0 && nombre.charAt(0)>=0 && nombre.charAt(0)<=9
length() > 0 && nombre.charAt(0)>=’9’ && nombre.charAt(0)<=’0’


parejas.

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

recurrencia presentada es:
static long parejas(int n){
if (n>2) return parejas(n-1) + parejas(n-2);
return 1;
}

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

if (n==1 || n==2) return 1;
}
La implementación

if (n==1 || n==2) return 1;
}
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.

if (n==1 || n==2) return 1;
return parejas(n-1) + parejas(n-2);
}

David ha notado que cuando se requiere imprimir el código sería de gran utilidad
(por la cantidad de papel gastado) eliminar las líneas que contienen únicamente
comentarios. La expresión que le permite determinar si una línea de código
consiste únicamente de un comentario es:
hasPrefix(“//”);
startsWith(“//”);
A pesar de ser todos los propuestos nombres razonables para el método

deseado, dicho método en la clase String es llamado startsWith.
linea.prefix(“//”);
beginsWith(“//”);
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 el valor de 100 no es precedido por el símbolo $.
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.
Puntaje del examen: 95 de 100

Programacion de Computado

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Programacion de Computado

Cargado por

Copyright:

Formatos disponibles

Evaluacion final - Escenario 8

Fecha de entrega 12 de mayo en 23:55 Puntos 100 Preguntas 20

Intento Hora Puntaje

MÁS RECIENTE Intento 2 38 minutos 95 de 100

Intento 1 56 minutos 85 de 100

Puntaje para este intento: 95 de 100

Incorrecto Pregunta 1 0 / 5 pts

Se desea implementar el sistema de visión de un robot clasificador de piezas. El

Su tarea es implementar un programa que reciba las matrices de dos imágenes e

Como parte del programa que resuelve el problema enunciado, se debe

Para esto, se tiene el siguiente código:

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

Se desea implementar el sistema de visión de un robot clasificador de piezas. El

Su tarea es implementar un programa que reciba las matrices de dos imágenes e

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

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

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

Resuelve el problema de manera correcta.

El método toma como referencia la imagen img1 y modifica la imagen img2

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

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

No resuelve el problema ya que rotar_imagen debería rotar la imagen en el sentido

Se desea implementar el sistema de visión de un robot clasificador de piezas. El

Como parte del programa que resuelve el problema enunciado, se debe

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++)

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++)

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

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

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

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++)

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

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.

David quiere desarrollar un programa de edición de código java que le permita

char[] cod_arr = cod;

char[] cod_arr = cod.toArray();

char[] cod_arr = cod.toCharArray();

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

El método de la clase String que permite convertir una cadena a arreglo de

Se desea implementar el sistema de visión de un robot clasificador de piezas. El

Su tarea es implementar un programa que reciba las matrices de dos imágenes e

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++)

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++)

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

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

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