Totalmente de acuerdo... no esta bien el algebra, ya que esta dividiendo al momento de que divide (a+b-c) / (a+b-c) queda 0/0 y por lo tanto es una indeterminacion... y es una indeterminacion porque 0/0 puede tener demasiados valores... puede ser 1, puede ser 0, puede ser infito...en si, puede ser cualquier numero....... pasa lo mismo con "infinito - infinito" es una indeterminacion que puede llegar a tender a distintos valores.... otro ejemplo es el 1^(infinito) ....otra indeterminacion... ya que 1^infinito no sabemos exactamente que valor tomara.....
lim x --> 0 ( 1 + x )^(1/x) = e

lim x ---> -5 [(x^2 -4x -5) / x-5 ] ... si nosotros sustituimos directo x = 5 ... termina por quedarnos... 0/0 ... es una indeterminacion... pero si nosotros lo factorizamos, nos queda (x-5)(x+1) / (x-5) al nosotros hacer el limite, decimos que x se esta acercando al 5,pero sin tocarlo.... y gracias a ello podemos cancelar el x-5 .... y por lo tanto te quedaria... x+1... si nosotros sustituimos ... el limite quedaria en 6.... y en este caso 0/0 tomo el valor de 6.... y asi como este caso, hay miles de casos en los que queda 0/0 y toma distintos valores ( ya sea, inifnito, 0, 1, -1, -infinito..etc) ... Pero jamas podemos dividir 0/0 asi como asi =SS es un error de algebra, ya que SIEMPRE que dividamos una ecuacion sobre algo, debemos tomar la restriccion de que el denominador sea distinto de 0

No funciona porque la condicion de numero == 0 && numero >100 nunca va a ser verdadera y por tanto solo entra una vez .... ¿Porque?... porque supongamos numero == 0 .... la primera condicion es verdadera, pero la segunda es falsa... por lo tanto  TRUE && FALSE = FALSE

Ahora supongamos numero > 100 .... la primera condicion es falsa, y la segunda verdadera... por lo tanto FALSE && TRUE = false... por lo tanto solo entrara una vez y parara el ciclo.....

Si quieres que solo se ingrese un numero  1 <= n < 100

entonces tu codigo tendria que ser

while( numero> 0 && numero < 100 ){
balbalñaba
}

Supongamos que numero es igual a 1

1>0 && 1 < 100 .... TRUE && TRUE = TRUE
 
ahora n = 99
99> 0 && 99 < 100 TRUE && TRUE = TRUE

ahora n = 100

100 > 0 && 100 < 100 TRUE && FALSE = FALSE

por lo tanto cume que  1<=n<100

No sé bien como este tu codigo, pero creo que deberias de usar un while en lugar de un do while..... tienes que notar que el while primero evalua y despues realiza... el do while, primero hace y despues evalua.. hay una gran diferencia...

Suerte (y)

Yo conozco una solución ...  seria un simple while, un arreglo y dos apuntadores y es bastante simple de entender.... El punto de este algoritmo es posicionarte en la ultima posicion de tu arreglo, e ir probando todas las combinaciones posibles... osea, estando en el ultimo elemento, probar con todas las combinaciones con ese numero, cuando hayas terminado con ese numero ahora probaras todas las combinaciones con el elemento n-2... despues de que probaste todas esas, probar con todas las combinaciones con n-3 y asi sucesivamente hasta que tu apuntador i se haga menor a 0.... el apuntador j es el auxiliar para ir probando todas las posibilidades.... por ejemplo, supongamos sumatoria = arreglo(i) + arreglo(j) donde j != i... si sumatoria > S  entonces sumatoria -= arreglo(j); j--; y entonces vuelve a entrar al ciclo......y denuevo sumatoria = arreglo(i) + arreglo(j)... y ahora supongamos que es menor... entonce j--; y volvemos a entrar... ahora supongamos que la sumatoria es igual a S.. entonces aumentamos contador de sumatorias, disminuimos i en una unidad y hacemos sumatoria = arreglo(i)... y volvemos a entrar

En resumen el apuntador i es el que te ayuda para saber el numero con el cual estas empezando, y j es con el que se va a ir sumando los numeros....

Suerte, ojalá y te sirva de algo... te daria el pseudoCodigo completo, pero el punto es que tambien pienses en terminar y programar la solucion.... y esta solucion la puedes programar ya sea en c++ o en c, o en java.. o en el lenguaje que sea... va a ser bastante similar ya que utilizas solamente herramientas basicas

Aqui hay otra pagina que yo creo que tambien es demasiado buena Son problemas que algunos han aparecido en la IOI o en olimpiadas de informatica... en eliminatorias para la IOI....registrense yyy vean los problemas... los reto a resolver los que estan en la categoria de "monstruo sadico" esos son los mas dificiles de ahi..... en la mayoria, el tiempo limite es 1 segundo....

http://www.cmirg.com:8081/traingate/

Los problemas de la pagina de la ACM tambien son muy buenos... hace poquito estuve en un concurso de la ACM y la verdad es que si tienen una complejidad alta

Para crear un ajedrez con "inteligencia artificial" por supuesto que no lo lograras llevando 4 meses de programacion... ni si quiera con 1 año de programacion... necesitas varios años para que puedas crear un ajedrez... en primera porque necesitas primero reforzar la teoria, los conceptos y todo lo relacionado con el lenguaje que vas a utilizar, despues empezar a familiarizarte bien con el lenguaje y empezar a hacer ejercicios que reten a tu logica... y ya cuando seas capaz de resolver muchos ejercicios de logica con el lenguaje de programacion, y sepas varios algoritmos .. es cuando vas a poder crear un ajedrez.. porque? porque no se si hayas leido, pero para programar un ajedrez, el computador tiene que checar entre un monton de posibilidades de movimientos... y empiezas a crear un gran arbol en el que estan los movimientos posibles... pero no solo eso... tambien tienes que empezar a suponer y/o predecir las jugadas que el usuario hara en un momento dado.. para que de esa manera tu puedas generar la mejor jugada..... y para todo eso, existen un monton de algoritmos que tienes que estudiar.... y esos algoritmos no son faciles... ya tienen una complejidad un poco alta.....

Si tu quieres saber como enrealidad el computador decide la mejor jugada, necesitas varios algoritmos... si tu lo unico que quieres es generar un ajedrez chafa y no entender lo que hiciste, puedes tomar el codigo fuente de un ajedrez y apartir de ahi "hacer como que le modificas"... pero asi no entenderas en su totalidad lo que esta sucediendo.....

Te recomiendo que primero comienzes con familiarizarte con el lenguaje asi bien, estudiar un poco de teoria, como funciona... despues de eso meterte a la logica... la logica de programacion es de los puntos mas importantes.... ponte a estudiar matrices... recursion... y cuando hayas dominado en su totalidad eso, osea  que eres capas de resolver la mayoria de los problemas que requieren matrices y recursion... metete a lo que es un poco de grafos...busquedas... yy despues a la programacion dinamica.... y asi poco a poco iras entendiendo los algoritmos y asi aprenderas de mejor manera los algoritmos con los cuales los juegos funcionan...

Suerte

Links de interes:
http://es.wikipedia.org/wiki/Ajedrez_por_computadora
http://es.wikipedia.org/wiki/Minimax
http://es.wikipedia.org/wiki/Teor%C3%ADa_de_juegos
http://es.wikipedia.org/wiki/Poda_alfa-beta
http://es.wikipedia.org/wiki/Heur%C3%ADstica_(inform%C3%A1tica)

Hay un Problema que he pensado bastante pero no se me ha ocurrido una solucion viable. Este problema creo que si los hara pensar un rato

Es este Problema

http://www.cmirg.com:8081/traingate/visualiza.php?usuario=0043a7894053f75f&task=cuentas

 En un principio te dan numeros separados por espacios, los 1 significan cuentas de otros colores y los 0 cuentas negras. Tambien como dato te dan el numero de cuentas negras que vas a sacar de ese hilo. Lo que se tiene que hacer es encontrar el menor numero de cuentas que tienes que sacar para poder tener el numero de cuentas negras dadas por el usuario.

001001010101

Digamos que el usuario quiere sacar 4 cuentas negras... el numero minimo que debe de sacar es 1... ya que puedo tomar directamente las 2 del primer extremo, saco una cuenta de color y encuentro otras 2 cuentas negras libres.....

Todo viene mejor explicado en el link anterior.

Mi idea de resolucion es primero tomar las cuentas de los extremos( siempre y cuando haya ).. despues, empezar a contar de un primer extremo hasta tener las cuentas negras deseadas... y obviamente llevar la cuenta de las cuentas de colores.... y hacer lo mismo con el otro extremo......y despues comparar quien tenga menos cuentas de colores... el problema es que no creo que esta solucion resuelva todos los casos posibles para ese problema.... ya que segun yo pueden existir una infinidad de casos en los que mi programa siguiendo mi "algoritmo", de una solucion erronea...

Asi que les queria pedir ayuda para ver si son tan amables de dar "ideas" para la resolucion del problema. Por cierto, el programa se hace en c++,c o pascal, pero no me quiero meter ahorita con el lenguaje, solo quiero terminar el algoritmo mas viable...

Otra solucion que se me ocurrio fue ir contando los 0's hasta encontrar un 1, apartir de ahi, ver cuantos 1's existen y despues contar cuantos ceros existen en ese lugar.... hacer lo mismo en el otro extremo y apartir de saber cuantos 1's existen y e numero de 0's , tomar la decision de hacia que extremo continuar. PEro igual veo varias deficiencias.

De antemano muchas gracias

Pues respondiendo a tu pregunta...
1ª Clase Cliente ( con JTextArea )
2ª Clase Servidor ( con quien quiero modificar el JTextArea )

Lo que podrias hacer es tener tu JTextArea como miembro estatico privado  de tu clase cliente, y con su respectivo metodo get..... en la clase Servidor pues llamas a tu clase cliente, y el metodo get que te regresa el textArea.... el problema de esto es que solo podrias tener un cliente ya que el jtextArea seria miembro de la clase y no de un objeto cliente.... por lo cual te recomiendo que tu crees una clase llamada "Lector"

Clase Servidor ----->

// En esta clase, al momento de crear el hilo de "Lector" tambien le deberas de pasar la referencia de tu jtextarea....
// asi, tu hilo se encargara de escribir el contenido que reciba al jtextarea
 
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
 
 
public class Servidor {
 public static void main(String[] args) throws IOException {
	// variables
	String  auxiliar;
 	int puertoServicio = 0;
        ServerSocket miServicio = null;
	Socket miCliente = null;
 
 
	// Creando objeto para escribrir flujo de entrada
        BufferedReader  teclado = new BufferedReader(new InputStreamReader(System.in));
 
	// pidiendo datos para la conexion
	System.out.println("Inserta el numero de puerto");
	try{
		 puertoServicio=Integer.parseInt(teclado.readLine());
		 System.out.println("Puerto establecido.\nEsperando peticiones");
	}
	catch(NumberFormatException e){
		 System.out.println("Error de datos del teclado");
		 System.exit(1);
	}
 
	// Creando socket, asignando puerto y aceptando solicitud de cliente.
        try {
            miServicio = new ServerSocket(puertoServicio);
	    miCliente = miServicio.accept();
        } catch (Exception e) {
            System.err.println("No se establecio el puerto "+puertoServicio);
            System.exit(1);
        }
 
	//Creando objeto para leer flujo de entrada desde el socket.
	BufferedReader entrada = new BufferedReader(new InputStreamReader(miCliente.getInputStream()));
	//DataInputStream entrada = new DataInputStream(miCliente.getInputStream());
 
	// Creando objeto para escribir flujo de salida hacia el socket.
	//DataOutputStream salida = new DataOutputStream(miCliente.getOutputStream());
        PrintWriter salida = new PrintWriter(miCliente.getOutputStream(), true);
       System.out.println("-----SERVIDOR-----\n\nCliente conectado. Iniciando comunicación...\n");
 
       // Creando un subproceso que se encargará de leer datos  de entrada del socket.(Hilo)
      Thread t = new Thread(new Lector(entrada));
             t.start();
 
	// Ciclo interativo de escritura sobre el socket(enviando lineas de texto).
        while (!((auxiliar=teclado.readLine()).equals("salir"))) {
            salida.println(auxiliar);
        }
 
	// Cerrando conexiones y flujos.
	teclado.close();
        salida.close();
        entrada.close();
        miCliente.close();
        miServicio.close();
    }
}

Clase Lector ---->

// en esta clase, en el contructor tienes que recibir aparte del buffer, recibir un jtextarea...
// y en el metodo run, adjuntar el contenido que el buffer tenga
 
import java.io.BufferedReader;
import java.io.DataInputStream;
 
public final class Lector implements Runnable {
 
    DataInputStream entrada1;
    BufferedReader entrada;
    String cadena;
 
    public Lector(BufferedReader entrada){ /// AQUI TAMBIEN RECIBIR UNA REFERENCIA A UN TEXTAREA
        this.entrada=entrada;
    }
 
	@Override
    public void run() {
        try {
 
            while (!((cadena = entrada.readLine()).equals("salir"))) {
                System.out.println("Recibido: " + cadena); // EN LUGAR DE ESTO, SERIA AJDUNTAR CADENA AL JTEXTAREA
            }
 
        } catch (Exception ex) {
            System.out.println("CONEXIÓN FINALIZADA");
	   System.exit(0);
        }
    }
}

Clase Cliente  ----->

 
// En esta clase, al crear tu hilo "lector" de igual manera deberas enviar el jtextarea
// de esta clase, para que tu hilo "lector" se encarge de escribir los mensajes que reciba en tu jtextarea
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
 
public class Cliente {
    public static void main(String[] args) throws IOException {
	// declaracion de variables
        Socket miCliente = null;
        String ipServidor;
	String auxiliar;
        int puertoServidor = 0;
 
	// Creando objeto para  flujo de entrada de datos desde el teclado.
	BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));
 
	// pidiendo datos desde el teclado
	System.out.println("Inserta la IP del servidor o nombre del servidor");
	ipServidor=teclado.readLine();
 
	System.out.println("Insetra numero de puerto");
	try{
		puertoServidor = Integer.parseInt(teclado.readLine());
	}
	catch(NumberFormatException e){
		System.out.println("Error de datos de entrada");
		System.exit(1);
	}
 
	// Inicializando socket
	try {
            miCliente = new Socket(ipServidor,puertoServidor);
        } catch (IOException e) {
            System.err.println("No se pudo establecer la conexión");
            System.exit(1);
        }
	//Creando objeto para leer flujo de entrada desde el socket.
        BufferedReader entrada = new BufferedReader(new InputStreamReader(miCliente.getInputStream()));
	PrintWriter salida = new PrintWriter(miCliente.getOutputStream(), true);
 
	System.out.println("-----CLIENTE-----\n");
        System.out.println("Conexión establecida. Comenzando comunicación...\n");
 
	// Creando un subproceso que se encargará de leer datos de entrada del socket.
        Thread t=new Thread(new Lector(entrada));
	t.start();
 
	// Ciclo interactivo de escritura sobre el socket(enviando lineas de texto).
	while (!((auxiliar=teclado.readLine()).equals("salir"))) {
             salida.println(auxiliar);
        }
 
	// Cerrando todas las conexiones y flujos.
	salida.close();
	entrada.close();
	teclado.close();
	miCliente.close();
    }
}
 
 

Como te habras fijado, las anteriores clases son unicamente para un chat en linea de comandos... si lo quieres hacer con java swing... lo que podrias hacer es modificar la clase lector para que reciba una referencia a un textArea en el cual procedentemente Adjuntara el contenido que ha recibido... obviamente tendrias que modificar la clase Servidor y cliente para mandar la referencia de su respectivo JtextArea.... Fijate en los comentarios en mayuscula que estan en la clase lector.... con las 3 clases que te pase es muy sencillo pasarlo a interfaz grafica... tambien tendrias que modificar unas cuantas lineas de Cliente y servidor para saber cuando terminar la comunicacion, en las clases que te pase, se termina cuando alguno de los dos escribe "salir"


Suerte

Yo lei ya el libro completo de "deitel", es muy bueno, pero tambien deberias de buscar  otras opciones para realizar ese tipo de animaciones... te recomiendo que en lugar de usar el timer, utilices un nuevo Thread que se encargue unicamente de mover a las naves... es decir, crear una clase interna privada en la clase panel, que implemente a runnable o bien a Thread, sobreescribir el metodo "run" y en ese metodo, empezar a modificar las coordenadas de las naves... al ser una clase  una clase interna no tendras problema con el acceso de los objetos de tu clase panel...... en tu clase panel tendras que crear un objeto de tu clase interna privada, y despues ejecutar su metodo run mediante start..... Esto todavia es mas eficiente, ya que vas "separando" el juego en pequeñas partes "independientes" ( notesen las comillas ).... debes de tomar en cuenta tambien, que al momento de que tu estas modificando las coordenadas y al momento de repintarlas... tienes que "dormir" ese hilo ciertos milisegundos ( si no lo haces, todo se movera demasiado rapido y no tendra el efecto deseado )

Ejemplo:
dentro de tu clase panel ---->

private class Movimiento extends Thread{
public void run(){
 
 /* Aqui es donde tienes que ir modificando las coordenadas */
/* Haces un Thread.sleep(tiempo); con sus respectivos try y catch */
/* repintas las naves, creo que seria con this.repaint(); */ 
}
}

en el contructor de tu clase panel ---->

Movimiento mov = new Movimiento();
mov.start();

Solo es como una ayuda, obviamente se tendran que hacer una que otra modificacion a tus clases

Lo que podrias hacer es crear un arreglo que contenga las letras que el usuario ya haya tecleado... y justo antes de que compruebe de si la letra esta contenida en la palabra, iterar atraves del arreglo, si la letra que tecleo es igual a alguna letra contenida en el arreglo, entonces no sumas aciertos y mandas un mensaje de que ya ha puesto esa letra... en caso contrario, continua normalmente, es decir comprobando si la letra esta contenida en la palabra y blblabla. el tamño ddel arreglo que contiene las letras ya tecladas puede ser de tamaño = 27.... u otra opcion es que en lugar de manejar el "juego" con arreglos, lo manejes con arraylist

 Suerte.

Aqui hay 4 clases, una clase se llama StudentsRegister, la cual implementa a la interfaz Serializable, tiene 3 variables de instancia con sus respectivos metodos get y set.... esa clase la he revisado, y esta perfectamente echa.
La siguiente clase se llama DesSer, la cual ayuda a serializar y deserializar en el archivo... tiene un metodo que se llama setList.. la cual llama al metodo writeObject(); para escribir la lista que se recibe  en el archivo.. ademas tiene un metodo llamado getList, la cual regresa un ArrayList<StudentsRegister> ( este metodo desserializa el archivo, y utiliza al metodo readObject
..
despues esta la clase ABC.. esta clase esta incompleta, no puedo completarla ya que tengo un problema con las altas ( agregar alumnos a un arrayList y escribirlo en un archivo )
La clase ABC tiene al metodo addStudents... primero pido cuantos alumnos se van a agregar, y despues , estos datos se utilizan para inicializar cada miembro del  array register, al momento de inicializarlos los agrega al arrayList..... al momento de que se introdujeron todos los datos de los estudiantes, se llama al metodo setList de la clase DesSer para escribir esta lista en el archivo.... este proceso esta bien.. o por lo menos no he notado ningun error... incluso en el metodo setList puse un println para poner si se han guardado los datos... y si aparece...

despues esta la clase TestABC... el cual contiene el metodo principal.. creamos un objeto ABC... y llamamos al metodo addStudents y al metodo showStudents.... TOODO sucede correctamente, me pide el numero de los alumnos, yo introdusco los datos de los alumnos, y los escribe en el archivo... sin embargo, el problema radica al volver a ejecutar TestABC, por segunda vez introdusco  alumnos nuevos ..  dice que los escribio, despues me muestra los alumnos pero SOLO me muestra a los alumnos que acababa de agregar y NO los que ya habia agregado en la primera ejecucion.. trate de solucionarlo modificando al metodo getList.. pero sigue sobreescribiendolos...

Alguien podria decirme porque sucede esto? y como podria solucionarlo?? osea, que al momento de que llame al metodo showStudents, me muestre a todos los alumnos( objetos ) que ya he agregada anteriormente

De antemano, Gracias

package abc;
 
import java.io.IOException;
 
/**
 *
 * @author Kenkox
 */
public class TestABC {
   public static void main( String args[] ) throws IOException{
      ABC proyect = new ABC();
      proyect.addStudents();
      proyect.showStudents();
 
   }
}
 

package abc;
/**
 *
 * @author Kenkox
 */
import java.io.IOException;
import java.util.*;
public class ABC {
 
    /**
     * @param args the command line arguments
     */
 
	private static List<StudentsRegister> studentList = new ArrayList<>();
	private static StudentsRegister register[];
    private DesSer working = new DesSer();
	private Scanner keyboard = new Scanner( System.in );
	private String firstName;
	private String surname;
	private double mark;
	private int option;
 
	public void addStudents(){
			System.out.println("Insert the number of Students to add ");
			final int TOTAL_STUDENTS = keyboard.nextInt();
			register = new StudentsRegister[TOTAL_STUDENTS];
			for( int i=0; i < register.length; i++ ){
				System.out.printf("%s\n%s", "write the name, surname and the mark of the student.", ":? " );
				firstName = keyboard.next();
				surname = keyboard.next();
				mark = keyboard.nextDouble();
				register[i] = new StudentsRegister(firstName, surname, mark );
                studentList.add(register[i]);
			}
            working.setList( studentList );		
	}
 
	public void consultar(){
 
	}
 
	public void eliminarAlumnos(){
 
	}
 
	public void modificarAlumnos(){
 
	}
	public void showStudents() throws IOException{
			updateList();
			System.out.printf("%-10s%-15s%-15s%11s\n ","Num. List", "Name", "Surname", "Mark");
			for( int i= 0; i < studentList.size(); i++ )
				System.out.printf("%-10d%s\n",i + 1, studentList.get(i));		
	}
	public void updateList() throws IOException{
			studentList = ( ArrayList<StudentsRegister> ) working.getList();
	}
 
}
 

package abc;
/**
 *
 * @author Kenkox
 */
import java.io.Serializable;
public class StudentsRegister implements Serializable{
    	private String name;
	private String surname;
	private double mark;
	public StudentsRegister(){
		this( "", "", 0.0 );
	}
	public StudentsRegister( String name, String sur, double mk ){
		setName( name );
		setSurname( sur );
		setMark( mk );
	}
	public void setName( String nm){
		name = nm;
	}
	public String getName(){
		return name;
	}
	public void setSurname( String sur){
		surname = sur;
	}
	public String getSurname(){
		return surname;
	}
	public void setMark( double mk ){
		mark  = mk;
	}
	public double getMark(){
		return mark;
	}
 
	public String toString(){
		return String.format("%-15s%-15s%11.2f\n ", getName(),
				getSurname(), getMark());
	}
}
 

package abc;
 
 
/**
 *
 * @author Kenkox
 */
import java.io.*;
import java.util.*;
public class DesSer {
 
	private ObjectOutputStream output;
	private ObjectInputStream input;
	private String fileName = "StudentsRegister.ser";
    private	List<StudentsRegister> temporalList = new ArrayList<>();
    private List<StudentsRegister> temporalList2 = new ArrayList<>();
 
 
	public void openFileSerialize(){
		try{
			output = new ObjectOutputStream( new FileOutputStream( fileName ));
 
		}
 
		catch( Exception e ){
			System.out.printf("there was an error opening the File: \" %s \" \n ", fileName );			
		}
	}
 
	public void openFileDeserialize(){
		try{
			input = new ObjectInputStream( new FileInputStream( fileName ) );
		}
		catch( Exception e ){
			System.out.printf("there was en error using the File: \" %s \" \n ", fileName );
		}
	}
 
	public void setList( Collection<StudentsRegister> registerList ){
		try{
			openFileSerialize();
			output.writeObject( registerList );
            System.out.println("Datos Guardados");
		}
 
		catch( Exception e){
			System.err.println("Can't write or close the File");
			System.exit( 1 );
		}
	}
 
	public Collection<StudentsRegister> getList() throws IOException{
		try{
			openFileDeserialize();
            while(true){
              temporalList = ( ArrayList<StudentsRegister> ) input.readObject();
              temporalList2.addAll(temporalList);
            }
		}
        catch(EOFException endOfFileException){
         input.close();
         return temporalList2;
        }
		catch( IOException | ClassNotFoundException e ){
			System.out.println("there was an error reading the file");
			System.exit( 1 );
		}
      return null;
 
	}
}