CI-1101 Examen #1


  Universidad de Costa Rica 

  Escuela de Ciencias de la 

  Computación e Informática

Profesor Adolfo Di Mare
CI-1101
II Semestre 2010

$[\/]$

CI-1101 Programación I

Examen #1 [solución]

Duración: Ciento veinte minutos. Lea bien el examen antes de hacerlo. El examen es a libro abierto. Cuenta la documentación. Cuenta la redacción y la ortografía. Puede hacer el examen con lápiz. Resuelva las tres preguntas. ¡No haga más de lo que se le pide!

1) [33 pts] La ventaja de las hileras Java es que funcionan como vectores porque tienen el método String.length() que sirve para determinar su longitud y el método String.charAt(i) que retorna una copia del i-ésimo caracter de la hilera. Por ejemplo, la cuarta letra de la hilera "abcde" es 'e' pues la numeración de las letras de la hilera comienza con el cero, como ocurre con los elementos de un vector.

{
    String r = "abcde";
    assertTrue( r.charAt(0) == 'a' );
    assertTrue( r.charAt(1) == 'b' );
    assertTrue( r.charAt(4) == 'e' );
    assertTrue( r.charAt(r.length()-1) == 'e' );
}
{
    assertFalse( hayLetrasDuplicadas( "abcdef" ) );
    assertFalse( hayLetrasDuplicadas( "aAbcdef" ) );

    assertTrue(  hayLetrasDuplicadas( "AbcdefA" ) );
    assertTrue(  hayLetrasDuplicadas( "abcDDef" ) );
}

1.a) [5 pts] Especifique el método estático hayLetrasDuplicadas() que sirve para determinar si una hilera Java tiene letras repetidas.

1.b) [18 pts] Implemente hayDuplicados( char V[] ) que determina si un vector de letras (char) tiene duplicados, como ocurre con los vectores que contienen los valores {'a','a','b'} y {'0','1','1','1','1'}.

1.c) [10 pts] Use su implementación de hayDuplicados() para obtener la implementación de hayLetrasDuplicadas() (que recibe una hilera, no un vector de letras).

2) [33 pts] El método estático sumaIzquierda(medio,V[]) sirve para obtener lo suma de los valores V[0]+V[1]+....+V[medio-1] mientras que sumaDerecha(medio,V[]) comienza en V[medio] y suma hasta el final del vector (V.length-1):

{
    int V[] = { 10,11,12, /* md==3 */ 33 };
    assertTrue( sumaIzquierda(3,V)==33 && 33==sumaDerecha(3,V) );
    assertTrue( 3==sumaCero(V) ); // 3 indica el índice V[3]
}
{
    int V[] = { 10,11,12,13, /* md==4 */ 13,12,11,10 };
    assertTrue( sumaIzquierda(4,V)==46 && 46==sumaDerecha(4,V) );
    assertTrue( 4==sumaCero(V) ); // 4 es la posición de corte V[4]
}
{
    int V[] = { 10,11,12,13,13, /* md==5 */ 13,13,13,20 };
    assertTrue( sumaIzquierda(5,V)==59 && 59==sumaDerecha(5,V) );
    assertTrue( 5==sumaCero(V) );
}
{
    int V[] = { 10,11,12,13,13, /*       */ 13,13,13,00 };
    assertTrue(  V.length == sumaCero(V) ); // retorna el índice V.length si no
    assertFalse( V.length != sumaCero(V) ); // hay 2 pedazos que sumen lo mismo
}

2.a) [5 pts] Especifique el método estático sumaCero() que sirva para saber si 2 subarreglos de un vector suman lo mismo.

2.b) [18 pts] Implemente sumaIzquierda(medio,V[]).

2.c) [8 pts] Use las rutinas sumaIzquierda(md,V[]) y sumaDerecha(md,V[]) para implementar sumaCero().

2.d) [0 pts] ¿Es posible implementar sumaCero() sin usar ciclos anidados?.

3) [33 pts]

[2(1)] [3(21)] [4(37)]

1 2 3

21 22 23 24 25 26

37 38 39 40 41 42 43 44 45 46

3.a) [7 pts] El método estático "Escalereado()" de la clase "Biblio" recibe dos números e imprime una escalera de varios peldaños a partir del segundo valor. Escriba la especificación completa de "Escalereado()".

3.b) [26 pts] Implemente "Escalereado()". En el ejemplo se muestra "Escalereado()" para los valores [2(1)], [3(21)] y [4(37)].

Soluciones

$[/\]$

`[2(1)]`	`[3(21)]`	`[4(37)]`
1 2 3	21 22 23 24 25 26	37 38 39 40 41 42 43 44 45 46