Tarea – Generar Sucesores y Mostrar Puzle

Trabajo en Clases 25.05.2013

Enunciado del trabajo:

Con su grupo de trabajo, debe escribir el código java para los siguientes métodos:

generarSucesores(), Que recibe como parámetro el nodo actual del puzle y retorna la lista de nodos sucesores del nodo actual. (Ojo solo del actual)

mostrarPuzzle(), recibe el nodo actual y lo muestra en pantalla.

El programa Principal, debe permitir ingresar los datos del tablero (nodo actual), e imprimir  en tablero inicial y mostrar los sucesores generados. (los tableros generados)

Dado el enucniado anterior nuestro trabajo se concentro en modificar (limpiar) el código presentado en el trabajo correspondiente a la cátedra uno, con el fin que este solo permita:

1. Leer desde la pantalla la configuración del tablero
2. Generar los sucesores para la configuración de tablero ingresada 
3. Imprimir por pantalla la configuración ingresada
4. Imprimir por pantalla las configuraciones sucesoras correspondientes a la configuración de tablero ingresada

 Dado lo anterior, el código resultante fue el siguiente:

Clase Main

package tarea;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
 *
 * @author GrupoZ
 */
public class Main {

    private final static int TOTALPOSICIONES = 9;
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

        List<Integer> matriz = new ArrayList<Integer>();

        while(matriz.size()<9){
            System.out.println("Ingrese un número entero");
            try {
                matriz = Lectura.leerEntero(matriz);
            } catch (IOException ex) {
                System.out.println("Error Generando Matriz " + ex);
            }
            System.out.println("Largo de la Matriz " + matriz.size());
        }
        System.out.println("Matriz Lista");
        System.out.println("Esta es la matriz Inicial");
        ImprimeEstado(matriz);
        System.out.println("Sus siguientes estados son: ");
        generadorNuevosEstados(matriz);      
    }   
    public static void ImprimeEstado(List<Integer> matriz) {
        Integer[] matrizActual = matriz.toArray(new Integer[matriz.size()]);
        System.out.println(matrizActual[0] + " | " + matrizActual[1] + " | "
                        + matrizActual[2]);
        System.out.println("---------");
        System.out.println(matrizActual[3] + " | " + matrizActual[4] + " | "
                        + matrizActual[5]);
        System.out.println("---------");
        System.out.println(matrizActual[6] + " | " + matrizActual[7] + " | "
                        + matrizActual[8]);
        System.out.println(" ");
        System.out.println(" ");
    }
    public static void generadorNuevosEstados(List<Integer> matriz) {
       int vacio = getVacio(matriz);
        // mover izquierda el vacio
        if (vacio != 0 && vacio != 3 && vacio != 6) {
                intercambiaGuarda(vacio - 1, vacio, matriz);
        }

        // bajar vacio
        if (vacio != 6 && vacio != 7 && vacio != 8) {
                intercambiaGuarda(vacio + 3, vacio, matriz);
        }
        // subir vacio
        if (vacio != 0 && vacio != 1 && vacio != 2) {
                intercambiaGuarda(vacio - 3, vacio, matriz);
        }
        // cambiar vacio a derecha
        if (vacio != 2 && vacio != 5 && vacio != 8) {
                intercambiaGuarda(vacio + 1, vacio, matriz);
        }
    }
    private static int getVacio(List<Integer> matriz) {
        int vacioIndex = -1;
        Integer[] matrizActual = matriz.toArray(new Integer[matriz.size()]);
        for (int i = 0; i < TOTALPOSICIONES; i++) {
                if (matrizActual[i] == 0)
                        vacioIndex = i;
        }
        return vacioIndex;
    }
    private static void intercambiaGuarda(int d1, int d2, List<Integer> matriz) {
        Integer[] matrizActual = matriz.toArray(new Integer[matriz.size()]);
        Integer[] copia = copiaMatriz(matrizActual);
        Integer temp = copia[d1];
        copia[d1] = matrizActual[d2];
        copia[d2] = temp;

        ImprimeEstado(Arrays.asList(copia));     
    }
    private static Integer[] copiaMatriz(Integer[] state) {
        Integer[] ret = new Integer[TOTALPOSICIONES];
        for (int i = 0; i < TOTALPOSICIONES; i++) {
            ret[i] = state[i];
        }
        return ret;
}

}

Clase Lectura

package tarea;

import java.io.*;
import java.util.List;

public class Lectura {

    static BufferedReader ob=new BufferedReader(new InputStreamReader(System.in));
    static String entrada=null;

    public static List<Integer> leerEntero(List<Integer> matriz) throws IOException{

            entrada=ob.readLine();
            int num=0;
            try{
                num=Integer.parseInt(entrada);
                if (num < 9 && num > -1) {
                    if (matriz.isEmpty()) {
                        matriz.add(num);
                    }else{
                        if (matriz.indexOf(num) == -1) {
                            matriz.add(num);
                        }else {
                            System.out.println("El numero ya se encuentra en la lista");
                        }
                    }
                }
            }catch(NumberFormatException e){
                System.out.println("Valor ingresado no es entero");
            }
            return matriz;
    }
}


Dando como resultado lo siguiente:

De forma adicional el código presentado cuenta con las siguientes funcionalidades extras:

• Valida que los datos ingresados sean solo números
• Valida que los datos ingresados no se encuentren repetidos

Integrantes:

• Juan Carlos Delgado
• Marcelo Contreras
• Marco Infante (Ausente)
• Michael Bernales