INTERSECCIÓN,UNIÓN Y DIFERENCIA DE CONJUNTO USANDO ARREGLO

package conjuntos;

/**
 *
 *
 */
public class Conjunto {
    public int []almacen;
public int limite, NumElem;
public Conjunto()
{
this.limite=10;
this.almacen=new int[this.limite];
for(this.NumElem=0;this.NumElem<this.limite;this.NumElem++)
this.almacen[this.NumElem]=(int) Math.random()*100;
}
public Conjunto(int li)
{
this.limite=li;
this.NumElem=0;
this.almacen=new int[this.limite];
}
public void setlimite(int li)
{
this.limite=li;
this.NumElem=0;
this.almacen=new int[this.limite];
}
public int getNumElem()
{
return(NumElem);
}
public void AgreElem(int E)
{
this.almacen[this.NumElem]=E;
this.NumElem++;
//System.out.println(" ");
}
public void VerElemConj()
{
for(int i=0;i<this.NumElem;i++)
System.out.println(this.almacen[i]);
}
public boolean BusElem(int E)
{
boolean existe=false;
int i=0;
while(!existe&&i<this.NumElem)
{
if(this.almacen[i]==E)
existe=true;
i++;
}
return(existe);
}
public Conjunto union(Conjunto c2)
{
Conjunto c3=new Conjunto();
c3.setlimite(this.getNumElem()+c2.getNumElem());
int i;
for(i=0;i<this.getNumElem();i++)
{
if(!c3.BusElem(this.almacen[i]))
c3.AgreElem(this.almacen[i]);
}
for(i=0;i<c2.getNumElem();i++)
{
if(!c3.BusElem(c2.almacen[i]))
c3.AgreElem(c2.almacen[i]);
}
return(c3);
}
public Conjunto InterConj(Conjunto c2)
{
Conjunto c3=new Conjunto();
if(this.getNumElem()<=c2.getNumElem())
c3.setlimite(this.getNumElem());
else
c3.setlimite(c2.getNumElem());
for(int i=0;i<this.getNumElem();i++)
{
for(int j=0;j<c2.getNumElem();j++)
{
if(this.almacen[i]==c2.almacen[j])
{
if(!c3.BusElem(this.almacen[i]))
{
c3.AgreElem(this.almacen[i]);
break;
}
}
}
}
return(c3);
}
public Conjunto DifConj(Conjunto c2)
{
Conjunto c3=new Conjunto();
c3.setlimite(this.getNumElem());
for(int i=0;i<this.getNumElem();i++)
{
if(!c2.BusElem(this.almacen[i]))
{
if(!c3.BusElem(this.almacen[i]))
c3.AgreElem(this.almacen[i]);
}
}
return(c3);
}
}

--------------------------------

package conjuntos;

import java.util.Scanner;

/**

 *

 * @author Usuario

 */

public class Vector {

    private int indVector ;

private int limVector ;

private int Vector[] ;

private Scanner sc = new Scanner(System.in);

    public Vector(){

    this.indVector=0;

    this.limVector=5;

    this.Vector = new int[this.limVector];

    }

    public Vector(int limite){

    this.indVector=0;

    this.limVector=limite;

    this.Vector = new int[this.limVector];

    }

    public void llenar_vector(int limite){

    this.limVector = limite;

    int dato = 0;

    System.out.println(" Ingrese datos al vector: ");

    for(int i=0;i<this.limVector;i++)

       {

        dato=sc.nextInt();

        this.Vector[i]=dato;

       }

    }

    public void mostrar_vector(){

    System.out.println(" Valores del Vector son:");

    for(int i=0;i<this.limVector;i++)

            {

             System.out.println(this.Vector[i]);

            }

    }

    public int[] getVector() {

    return Vector;

    }

}

----------------

package conjuntos;

import java.util.Scanner;

/**

 *

 * @author Usuario

 */

public class principalConjunto {

     public static void main(String []args)

    {

Conjunto c1,c2,c3;

int N1;

int N2;

        Scanner sc = new Scanner(System.in);

do

{

            System.out.print("Ingrese numero de elementos del conjunto A: ");

           // N1= sc.nextInt();

           N1=(int)Math.round(Math.random()*5)+1;

           System.out.println(N1);

            

}

while(N1<=0);

do

{

            System.out.print("Ingrese numero de elementos del conjunto B: ");

            //N2= sc.nextInt();

           N2=(int)Math.round(Math.random()*5)+1;

           System.out.println(N2);

}

while(N2<=0);

        System.out.println(" ");

        

        System.out.println("Ingrese elementos del conjunto A: ");

        c1=new Conjunto(N1);

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

            c1.AgreElem((int)Math.round(Math.random()*20)+1);

            c1.VerElemConj();

        System.out.println("Ingrese elementos del conjunto B: ");

c2=new Conjunto(N2);

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

            c2.AgreElem((int)Math.round(Math.random()*20)+1);

            c2.VerElemConj();

        c3=c1.union(c2);

        System.out.println("A Union B:");

        c3.VerElemConj();

        c3=c2.union(c1);    

        System.out.println("B Union A:");

        c3.VerElemConj();

        c3=c1.InterConj(c2);

        System.out.println("A Interseccion B:");

        c3.VerElemConj();

        c3=c2.InterConj(c1);

        System.out.println("B Interseccion A:");

        c3.VerElemConj();

        c3=c1.DifConj(c2);

        System.out.println("A Diferencia B:");

        c3.VerElemConj();

        c3=c2.DifConj(c1);

        System.out.println("B Diferencia A:");

        c3.VerElemConj();

    }   

}

Ejercicios propuestos de ARCHIVOS
Se pide crear una clase alumno la cual tendra como atributos curso que llevara, esto
sera almacenado en un txt. OJO  usar  FileReader y BufferedReader.

            

-------------------- creando la clase Alumnocurso ------------------------------
package Alumnocurso;

/**
 *
 *
 */
public class Alumnocurso {
    private String curso;
    private String alumno1;
    private String alumno2;
    private String alumno3;

    public Alumnocurso() {
    }
    public Alumnocurso(String curso, String alumno1, String alumno2,String alumno3) {
        this.curso = curso;
        this.alumno1 = alumno1;
        this.alumno2 = alumno2;
        this.alumno3 = alumno3;
    }
    public String getCurso() {
        return curso;
    }
    public void setCurso(String curso) {
        this.curso = curso;
    }
    public String getAlumno1() {
        return alumno1;
    }
    public void setAlumno1(String alumno1) {
        this.alumno1 = alumno1;
    }

    public String getAlumno2() {
        return alumno2;
    }
    public void setAlumno2(String alumno2) {
        this.alumno2 = alumno2;
    }
    public String getAlumno3() {
        return alumno3;
    }
    public void setAlumno3(String alumno3) {
        this.alumno3 = alumno3;
    }
    @Override
    public String toString() {
        return "Persona{" + "curso=" + curso + ", alumno1=" + alumno1 + ", alumno2=" + alumno2+ ", alumno3=" + alumno3 + '}';
    }
    public String formato(){
       
   
        return this.curso+","+this.alumno1+","+this.alumno2+","+this.alumno3;
    }
}

------------------------------ 

package Alumnocurso;

/**

 *

 * 

 */

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintWriter;

import java.util.Scanner;

import java.util.StringTokenizer;

public class ManejoAlumnocurso {

    Scanner leer = new Scanner(System.in);

    

    private Alumnocurso array[]; 

    private int indArray = 0;

    private File arch;

    public ManejoAlumnocurso() {

        arch = new File("D:// ALUMNOCURSO.txt");

        array= new Alumnocurso[5];

    }

    

    public void ingresarCurso(){

        if(indArray < 5){

        System.out.println("Ingresar el nombre del curso");

        String nombreCurso = leer.next();

        System.out.println("Ingresar el nombre del alumno n°1 del curso");

        String alumno1Curso = leer.next();

        System.out.println("Ingresar el nombre del alumno n°2 del curso");

        String alumno2Curso = leer.next();

        System.out.println("Ingresar el nombre del alumno n°3 del curso");

        String alumno3Curso = leer.next();

        

        

        array [indArray] = new Alumnocurso(nombreCurso,alumno1Curso,alumno2Curso,alumno3Curso);

        indArray++;

        System.out.println("********************************************************");

        

        }else{

            System.out.println("LLENO ");

        } 

            

    }

    

    public void mostrarPersona(){

        for (int i = 0; i < indArray; i++) {

           

            System.out.println(array[i].toString());    

 

        }

    }

    

     public void LeerArchivo() throws IOException{

        FileReader fr = null;

        BufferedReader br =  null;

        

        if(!arch.exists()){

            arch.createNewFile();

        }else{

            fr = new FileReader(arch);

            br = new BufferedReader(fr);

            String linea;

            while((linea = br.readLine())!=null){

               String cad[] = linea.split(",");

               array[indArray] = new Alumnocurso(cad[0],cad[1],cad[2],cad[3]);

               indArray++;

            }

        }

    }

     

    public void EscribirArchivo() throws IOException{

        FileWriter fw = null;

        BufferedWriter bw = null;

        PrintWriter pw = null;

        if(!arch.exists()){

            arch.createNewFile();

        }

        

        try{

            fw = new FileWriter(arch);

            bw = new BufferedWriter(fw);

            pw = new PrintWriter(bw);

            

            for (int i = 0; i <indArray; i++) {

                 

                pw.println(array[i].formato());

                

           }

        }catch(Exception e){

            e.printStackTrace();

        }finally{

            try{

            pw.close();

            bw.close();

            fw.close();

            }catch(Exception ex){

                ex.printStackTrace();

            }

        } 

    }

}

-------------------------------

package Alumnocurso;

import java.io.IOException;

import java.util.Scanner;

/**

 *

 * 

 */

public class Principal {

    public static void main(String[] args) throws IOException {

        boolean band = true;

        

        Scanner sc = new Scanner(System.in);

        

        ManejoAlumnocurso mp = new ManejoAlumnocurso();

        mp.LeerArchivo();

        

        mp.ingresarCurso();

        mp.ingresarCurso();

        mp.mostrarPersona();

        mp.EscribirArchivo();

        

    }

}

Arreglos en java

ARREGLOS MULTIDIMENSIONALES REPRESENTADOS EN ARREGLOS UNIDIMENSIONALES

Las computadoras no pueden almacenar directamente un arreglo multidimensional, su representación en memoria debe ser lineal, donde a cada elemento le sigue un único elemento, mediante el bloque de posiciones sucesivas. 

Que queremos decir en las líneas anterior; es decir, por ejemplo tenemos un arreglo bidimensional A de m x n elementos, mediante un bloque de m X n posiciones sucesivas, es decir la distribución de los elementos de dicho arreglo se harán de forma lineal en la memoria de la computadora.

2.1 Ordenación de Elementos de un arreglo Bidimensional en arreglo Unidimensional.

La distribución de elementos se puede realizar de dos formas diferente, las https://youtu.be/U8X3TGeBh88cuales veremos a continuación.

 2.1.1 Ordenación por renglones (Renglón a renglón)

Esta ordenación consiste en ir tomando los valores del arreglo bidimensional, fila por fila y luego irlos insertando en cada casilla o posición del vector unidimensional.

Supongamos que tenemos el siguiente arreglo bidimensional:

Array Notas [5,4]

10	8	9	8
10	5	6	6
4	5	8	9
10	2	3	3
1	5	8	9

Fig. 2.1

La ordenación por reglón en un arreglo unidimensional nos quedaría:

10

8

9

8

10

5

6

6

4

5

8

9

10

2

3

3

1

5

8

9

Fig. 2.2

Una vez almacenados los valores de manera lineal se requiere de una fórmula que nos proporcione la posición en el arreglo unidimensional que le corresponde a cada elemento del arreglo bidimensional original.

La fórmula es:  

Formula 2.1

Dónde: 

LOC(A [i,j]): La posición del elemento a localizar

POSINI: La posición inicial del arreglo unidimensional a partir de la cual se empiezan almacenar los elementos.

n: el número de columnas que posee el arreglo bidimensional

i y j: Indican el renglón y columna , respectivamente , de la posición del elemento que se quiere ubicar.

Así, aplicando la fórmula 2.1 a nuestro arreglo de la figura 2.1, si deseamos localizar el elemento A [3,3], lo haríamos:

Supongamos que posini es = 1

A [3,3] = 1 + 4 * (3-1) + (3-1) = 1+4 * (2) + (2)

= 1 + 4(2) + 2 =  11

 LOC A [3,3] = 11.

2.1.2 Ordenación por Columnas (Columna por columna)

Esta ordenación consiste en ir tomando los valores del arreglo bidimensional, columna por columna y luego irlos insertando en cada casilla o posición del vector unidimensional.

Tomando de referencia el arreglo bidimensional de la Fig. 2.1, un arreglo unidimensional nos quedaría de la siguiente manera, si ingresamos los valores por columna.

10

10

4

10

1

8

5

5

2

5

9

6

8

3

8

8

6

9

3

9

Fig. 2.3

Al igual que la ordenación por renglones, necesitamos de una fórmula que nos proporcione la posición en el arreglo unidimensional que le corresponde a cada elemento del arreglo bidimensional original. Dicha fórmula es: 

 

Formula 2.2

Dónde:

LOC(A [i,j]): La posición del elemento a localizar

POSINI: La posición inicial del arreglo unidimensional a partir de la cual se empiezan almacenar los elementos.

m: el número de filas que posee el arreglo bidimensional

i y j: Indican el renglón y columna , respectivamente , de la posición del elemento que se quiere ubicar.

Ahora apliquemos la fórmula 2.2 para nuestro arreglo de la figura 2.1.

Localicemos la posición: A [4,2], POSINI= 1

A [4,2]=  1 +  5 * (2-1) + (4-2)

= 1 + 5(1) + 2 = 1 + 6 +2 = 9

LOC A [4,2] = 9