Temas:

• Arreglos con valores enteros: asociar un entero a un entero y obtener el valor asociado a un entero.
• Arreglos con valores no enteros: con reales o strings.

Motivación:

Se ha hecho una elección en la que participaron 8 candidatos. Cada candidato se identifica por un número entre 0 y 7. El resultado de la elección se encuentra en un archivo ``votos.txt'' que contiene una línea por cada sufragante. Esta línea indica el número del candidato que prefiere ese sufragante. Por ejemplo el contenido del archivo podría ser:

    3
    7
    1
    3
    1

Construir un programa que haga el recuento de los votos. El resultado de este programa debe ser:

    Candidato 0: x votos
    Candidato 1: y votos
    ...
    Candidato 7: z votos

• Definir 8 variables, una por candidato, con valor inicial 0. Leer cada línea presente en el archivo e incrementar la variable correspondiente según el valor presente en esa línea. Para saber qué variable hay que incrementar se usan 8 instrucciones if.

  Problema: Se repite muchas veces el código. ¿Y si fueran 100 candidatos?

• Usar el patrón de conteo para hacer que la variable i tome valores de 0 a 7. Por cada valor de i, leer completamente el archivo y contar cuantos votos tiene el candidato i e imprimir el total.

  Problema: Leer un archivo en disco toma tiempo. Leerlo 8 veces toma bastante tiempo, sobretodo cuando hay muchos votantes.

• Usar un arreglo con 8 contadores, uno por candidato, con valor inicial 0.

  Problema: ¿Qué es un arreglo?

Un arreglo es un objeto que permite asociar valores a números enteros. Para entender este concepto, es conveniente visualizar un arreglo como una tabla con dos columnas:

La columna de la izquierda contiene los índices y la columna de la derecha el valor asociado a cada índice. El ejemplo de más arriba podría ser la cantidad de votos captados por cada candidato. El número del candidato corresponde al índice y la cantidad de votos es el valor asociado.

Los arreglos son objetos que realizan principales dos operaciones: (i) obtener el valor asociado a un índice, y (ii) cambiar el valor asociado a un índice. Con estas operaciones es sencillo resolver el problema del recuento de los votos:

  TextReader lect= new TextReader("votos.txt");

  Array tab= new Array(8); // Crea un arreglo asociativo

  // Crear las filas del arreglo asociativo
  // El valor inicial asociado a cada candidato es 0
  int cand= 0;
  while (cand<=7) {
    tab.put(cand, 0); // Asocia 0 al candidato cand
    cand= cand+1;
  }

  // Leer los votos
  while(true) {
    int candVoto= lect.readInt();
    if (lect.eofReached())
      break;
    // Obtenemos el numero de votos del candidato
    int anterior= tab.getInt(candVoto); 
    int nuevo= anterior+1;
    tab.put(candVoto, nuevo); // Cambiar el valor asociado
  }

  cand= 0;
  while (cand<=7) {
    println("Candidato "+cand+": "+tab.getInt(cand));
    cand= cand+1;
  }

  lect.close();

Observaciones:

• Array tab=new Array(8): Crea un arreglo asociativo con 8 índices numerados del 0 al 7. Todos los valores asociados parten en 0.

• tab.put(k,v): Asocia el valor v al índice k en el arreglo tab.

• tab.getInt(k): Obtiene el valor asociado al índice k en el arreglo tab. El arreglo tab debe haber sido creado con al menos k+1 índices y el valor asociado debe ser un entero.

• Las tres instrucciones que hacen el recuento se pueden cambiar por una sola:

      tab.put(candVoto, tab.getInt(candVoto)+1);
  

• Un arreglo no es simétrico entre índices y valores. Esto significa que dado un valor, no existe ninguna operación que permita conocer a cuál índice se encuentra asociado.

Arreglos con valores no enteros

El valor asociado a un índice puede ser un valor real. Por ejemplo, podemos asociar a cada candidato su estatura:

    Array tabEst= new Array(10);
    tabEst.put(0, 1.70);
    tabEst.put(1, 1.85);
    ...
    println("La estatura del candidato 3 es "+
            tabEst.getDouble(3));

    Array tabNombres= new Array(10);
    tabNombres.put(0, "Ronald Reagan");
    tabNombres.put(1, "Margaret Tatcher");
    ...
    println("El candidato 5 es "+tabNombres.getString(5));

Ejercicio 1: (propuesto)

El archivo ``est.txt'' contiene los nombres de cada candidato en el siguiente formato:

    2 Margaret Tatcher
    7 Boris Yeltsin
    ...
    0 Ronald Reagan

    Número de candidato ? 7
    Su nombre es Boris Yeltsin
    Número de candidato ? 0
    Su nombre es Ronald Reagan
    Número de candidato ? x
    Su nombre es ...
    ...
    Número de candidato ? -1
    fin

Resumen:

Los valores en un arreglo pueden ser cualesquiera entre enteros, reales, strings o booleanos. ¡Pero cuidado! Al obtener su valor, el tipo del valor asociado debe coincidir con el tipo pedido. Es decir, previamente se debe haber invocado tab.put(k, v) en donde v era del tipo pedido.

Por otra parte, en un arreglo construido con Array, los índices siempre deben ser de tipo entero (La clase StringMap es un arreglo que acepta índices de tipo String).

Ejercicio 2:

Escribir un programa que lea las líneas del archivo ``datos.txt'' y las muestre en la consola en orden inverso. Por ejemplo, si el contenido de ``datos.txt'' es:

    Un arreglo asociativo o mapa es un
    objeto que permite asociar valores
    a números enteros o strings.

    a números enteros o strings.
    objeto que permite asociar valores
    Un arreglo asociativo o mapa es un

La idea es construir un arreglo que asocie cada línea con su número de línea en el archivo (comenzando de 0). El problema es que al crear el arreglo se necesita saber a priori cuantas líneas tiene el archivo, lo que no es posible determinar sin leer completamente una vez el archivo.

Supuesto razonable: el archivo no tiene más de 1000 líneas (en realidad este supuesto no es tan razonable, pero típicamente en los controles se le dice explícitamente cuál es el tamaño máximo del archivo).

    Array tab= new Array(1000);
    TextReader lect= new TextReader("datos.txt");
    int i= 0;
    while (true) {
      String lin= lect.readLine();
      if (lect.eofReached())
        break;
      tab.put(i, lin);
      i= i+1;
    }
    lect.close();
    // i es el número de líneas del archivo
    i= i-1;
    while (i>=0) {
      println(tab.getString(i));
      i= i-1;
    }

Observaciones:

• Se construye un arreglo en donde se asocia al índice i, la i-ésima línea en el archivo.

• Al final del primer ciclo, i es el número de líneas en el archivo.

• Se usa un patrón de conteo en reversa para mostrar primero la línea i-1, luego la línea i-2, la línea i-3, etc.

Patrones de recorrido de arreglos

• Patrón de recorrido de arreglos:

      k= 0;
      while (k<=límite superior) {
        ... tab.getTipo(k) ...
        k= k+1;
      }
  

  en donde tab es un arreglo cualquiera y k es una variable entera.

• Patrón de recorrido de arreglos en reversa:

      k= nro de elementos - 1;
      while (k >= 0) {
        ... tab.getTipo(k) ...
        k= k-1;
      }
  

Ejercicio 3

El archivo ``notas.txt'' contiene las notas de un control en un curso de estadísticas. El formato del archivo es el siguiente:

    Gloria Hernandez    6.0
    Juan Perez          5.5
    Jose Urrutia        5.8
    etc.

Solución:

• Construir dos arreglos. Uno para los nombres de los alumnos y otro para sus notas. Estos arreglos contendrán tantas filas como líneas contenga el archivo de notas:

  Arreglo de nombres de alumno

  Llave	Valor
  (línea)	(nombre)
  0	Gloria Hernandez
  1	Juan Perez
  2	Jose Urrutia
  ...	...

  Arreglo de notas

  Llave	Valor
  (línea)	(nombre)
  0	6.0
  1	5.5
  2	5.8
  ...	...

  La idea fundamental es que se puede conocer el nombre y la nota del alumno contenido en la i-ésima línea del archivo, utilizando el i como llave en el arreglo de nombres y en el arreglo de notas respectivamente.

• Leer el archivo de notas inicializando ambos arreglos. Se usa el patrón de conteo para determinar el número de línea que le corresponde a cada alumno (el índice).

• Al leer la i-ésima línea, establecer la asociación i->nombre del alumno en el arreglo de alumnos y la asociación i->nota del alumno en el arreglos de notas.

• A medida que se leen las notas, usar el patrón de acumulación para determina la nota máxima.

• Usar patrón de recorrido de arreglos para determinar en qué líneas apareció la nota máxima.

    // Creación de arreglos
    Array tabNombres= new Array(1000);
    Array tabNotas= new Array(1000);
    // Inicialización de los arreglos y cálculo
    // de la mejor nota
    TextReader lect= new TextReader("notas.txt");
    int i= 0;
    double maxNota= 0.0;
    while (true) {
      String lin= lect.readLine();
      if (lect.eofReached()) // Patrón de lectura de datos
        break;
      String nom= trim(substring(lin, 0, 20));
      double nota= parseDouble(trim(substring(lin, 20, 3)));
      // Patrón de inicialización de arreglos
      tabNombres.put(i, nom);
      tabNotas.put(i, nota);
      if (nota>maxNota)
        maxNota= nota;
      i= i+1; // Patrón de conteo para el nro. de línea
    }
    lect.close();
    // i es el número de líneas leídas
    // Determinar nombres de los que obtuvieron la mejor nota.
    int j=0;
    while (j<i) {
      if (tabNotas.getDouble(j)==maxNota)
        println(tabNombres.getString(j));
      j= j+1;
    }

Ejercicio 4: (propuesto)

Modifique el programa anterior de modo que muestre en pantalla junto a los nombres de las personas que obtuvieron la mejor nota, los nombres de las personas que obtuvieron la segunda mejor nota. En pantalla se debe mostrar el siguiente resultado:

    La mejor nota fue un 6.5
    Los alumnos fueron:
    Mariano Benitez
    Adriana Gonzalez

    La segunda mejor nota fue un 6.2
    Los alumnos fueron:
    Andres Concha

Escriba un programa que lea el archivo de notas y muestre en pantalla la siguiente información:

    Nota  Nro. de alumnos
    6.5   2
    6.2   1
    5.9   4
    ...
    2.6   1

Hint: cree un arreglo con 70 elementos. Utilice como índice la nota multiplicada por 10 y truncada a número entero (con trunc).