PRIMEROS PROGRAMAS EN JAVA - ARREGLOS USANDO MTODOS

Tabla de contenido
Programa que dado un vector con n datos de tipo real, informa la cantidad de elementos que exceden el
promedio ................................................................................................................................................................ 2
Programa para leer un arreglo de n amigos y crear otro arreglo pero en orden inverso, al final debe imprimir
los dos arreglos- Jugutier ..................................................................................................................................... 2
Programa que lee n enteros, y luego imprime un vector con los pares, luego imprime los impares y finalmente
concatena los dos vectores. ................................................................................................................................... 8
Programa para leer n enteros, que posteriormente elimina un elemento de una posicin- Jugutier. .....................13
Clase Arrays .........................................................................................................................................................17
Dados dos conjuntos realizar las operaciones de unin e interseccin .................................................................18
Fusionar dos arreglos, el arreglo 1 se recorre de izquierda a derecha y el arreglo 2 de derecha a izquierda ........23
Eliminar elementos repetidos de un arreglo ..........................................................................................................26

1
 Programa para leer un arreglo de n amigos y crear otro arreglo pero en orden inverso, al final
debe imprimir los dos arreglos- Jugutier

import javax.swing.JOptionPane;

/**
* Programa para leer un arreglo de n amigos y crear otro arreglo pero en
* orden inverso, al final debe imprimir los dos arreglos
*
* @author Jugutier
*/
public class Ejemplo03 {

/**
* @param args the command line arguments
*/
public static void main ( String[] args ) {
int n;
String[] amigos, amigosOrdenInverso;

n = leerEntero( "Cantidad de amigos: " );

amigos = leerTextos ( "Nombre del amigo: ", n );

amigosOrdenInverso = invertirArreglo( amigos );

imprimirMensaje ( "Los amigos: "+imprimirVector(amigos) +

"\nEl arreglo en orden inverso:
"+imprimirVector(amigosOrdenInverso));

/**
* Mtodo que recibe un arreglo de cadenas y retorna otro arreglo con los
* textos en orden inverso
*
* @param cadenas Arreglo con los textos
* @return Otro arreglo con los textos en orden inverso.
*/
public static String[] invertirArreglo ( String[] cadenas )
{
String[] salida;
int i;

salida = new String [ cadenas.length ];

for ( i = 0 ; i < cadenas.length ; i++ )

{
salida [ i ] = cadenas[ cadenas.length - 1 - i ];
}

return salida;
}

2
/**
* Mtodo para leer un nmero entero
*
* @param pregunta Texto con un pregunta para el usuario
* @return Nmero entero como respuesta a la pregunta
*/
public static int leerEntero ( String pregunta )
{
return Integer.parseInt( JOptionPane.showInputDialog( pregunta ) );
}

/**
* Mtodo para leer un texto (cadena)
*
* @param pregunta Texto con un pregunta para el usuario
* @return Texto dado como respuesta a la pregunta
*/
public static String leerTexto ( String pregunta )
{
return JOptionPane.showInputDialog( pregunta );
}

/**
* Mtodo para imprimir un texto en una ventana.
*
* @param texto Texto que se desea imprimir
*/
public static void imprimirMensaje( String texto )
{
JOptionPane.showMessageDialog( null, texto );
}

/**
* Mtodo para leer varios textos y retornarlos en un arreglo
*
* @param pregunta Texto usado como pregunta la usuario
* @param cantidad Cantidad de textos a ingresar como respuesta
* @return Arreglo con los textos ingresados como respuesta
*/
public static String[] leerTextos ( String pregunta, int cantidad )
{
int i;
String cadenas[];

cadenas = new String [ cantidad ];

for ( i = 0 ; i < cantidad ; i++ )

{
cadenas [ i ] = leerTexto( pregunta +
"( " + (i+1) + " de " + cantidad + " )" );
}

return cadenas;
}

3
 /**
* Mtodo que imprime varios textos dados en un arreglo
*
* @param cadenas Arreglo con los textos a imprimir
*/
public static String imprimirVector ( String[] cadenas )
{
String salida;
int i;

salida = "[ ";

for ( i = 0 ; i < cadenas.length ; i++ )
{
salida += cadenas[ i ] + " ";
}
salida+=" ]";
return ( salida );
}
}

Ejecucin

4
 Programa que dado un vector con n datos de tipo real, informa la cantidad de elementos que
exceden el promedio

import javax.swing.JOptionPane;

/**
* Programa que dado un vector con n elementos,
* informe la cantidad de elementos que exceden el promedio.
*
* @author Sonia
*/
public class Ejemplo45 {

/**
* @param args the command line arguments
*/
public static void main( String[] args ) {
int cantidad;
double datos[];
double promedio;
int resultado;

cantidad = leerEntero ( "Ingrese la cantidad de elementos" );

datos = leerDoubleA ( "Ingrese un real ", cantidad );
promedio = calcularPromedio ( datos );
resultado=obtenerCantidadExcedePromedio(datos, promedio);
imprimirTexto( "El promedio es: " + promedio +"\nLa cantidad de elementos "
+ "que exceden el promedio es: "+resultado);
}

/**
* Mtodo que calcula el promedio de un arreglo
*
* @param datos Arreglo de nmeros
* @return El promedio de los nmeros contenidos en el arreglo
*/
public static double calcularPromedio ( double datos[] )
{
double promedio;
promedio = 0;

for ( int i = 0 ; i < datos.length ; i++ )

{
promedio = promedio + datos [ i ];
}

promedio /= datos.length ;

return promedio;
}

public static int obtenerCantidadExcedePromedio(double datos[], double promedio)

{
int contador;
contador = 0;

for ( int i = 0 ; i < datos.length ; i++ )

5
 {
if(datos[i]>promedio)
{
contador++;
}
}

return contador;
}

/**
* Mtodo para leer un nmero entero
*
* @param pregunta Texto con un pregunta para el usuario
* @return Nmero entero como respuesta a la pregunta
*/
public static int leerEntero ( String pregunta )
{
return Integer.parseInt( JOptionPane.showInputDialog( pregunta ) );
}

/**
* Mtodo para imprimir un texto en una ventana.
*
* @param texto Texto que se desea imprimir
*/
public static void imprimirTexto( String texto )
{
JOptionPane.showMessageDialog( null, texto );
}

/**
* Mtodo para leer nmero reales de tipo double
*
* @param pregunta Es texto usado como pregunta para el usuario
* @return Valor dado por el usuario como respuesta a la pregunta
*/
public static double leerDouble ( String pregunta )
{
return Double.parseDouble( JOptionPane.showInputDialog( pregunta ) );
}

/**
* Mtodo para leer varios enteros y retornarlos en un arreglo
*
* @param pregunta Texto usado como pregunta al usuario
* @param cantidad Cantidad de textos a ingresar como respuesta
* @return Arreglo con los textos ingresados como respuesta
*/
public static double[] leerDoubleA ( String pregunta, int cantidad )
{
int i;
double reales[];

reales = new double [ cantidad ];

for ( i = 0 ; i < cantidad ; i++ )

6
 {
reales [ i ] = leerDouble( pregunta +
"( " + (i+1) + " de " + cantidad + " )" );
}

return reales;
}

Ejecucin

7
Programa que lee n enteros, y luego imprime un vector con los pares, luego imprime los impares y finalmente
concatena los dos vectores.

import javax.swing.JOptionPane;

/**
* Programa que dado un vector lo separa en dos vectores (pares e impares) y luego los concatena
*
* @author Sonia
*/

public class Ejemplo04 {

/**
* @param args the command line arguments
*/
public static void main( String[] args ) {
int cantidad, enteros[], pares[], impares[], resultado[];

String informacin = "";

cantidad = leerEntero( "Cantidad de nmeros a leer" );

enteros = leerVectorEnteros( "Ingrese un entero ", cantidad );

//si se ingresa 0 se obtienen los pares, 1 los impares

pares = obtenerElementos ( enteros, 0 );
impares = obtenerElementos ( enteros, 1 );
resultado = concatenar (pares, impares);

informacion+= "Original: \n" + devolverStringArreglo( enteros );

informacion+= "\nPares: \n" + devolverStringArreglo( pares );
informacion+= "\nImpares: \n" + devolverStringArreglo( impares );
informacion+= "\nResultante: \n"+ devolverStringArreglo( resultado);
imprimirMensaje(informacion);

/**
* Mtodo para obtener slo los nmeros pares o impares de un arreglo de enteros, dependiendo
* de la variable opcion
*
* @param datos Arreglo con los datos
* @return Una parte del arreglo original que contiene los pares (opcion==0) o los
impares (opcion==1)
*/
public static int[] obtenerElementos ( int[] datos, int opcion )
{
int elementos[], i, j, cantidad;

j = 0;

cantidad = obtenerCantidad ( datos, opcion );

elementos = new int [ cantidad ];

8
 for ( i = 0 ; i < datos.length ; i++ )
{
//Si la opcion es cero el dato debe ser par

if ( datos[ i ] % 2 == 0 &&opcion==0 )
{
elementos [ j ] = datos [ i ];
j++;
}
else
//Si la opcion es uno el dato debe ser impar
if (datos[ i ] % 2 != 0 &&opcion==1)
{
elementos [ j ] = datos [ i ];
j++;
}
}

return elementos;
}

/**
* Concatena dos arreglos, es decir, une dos arreglos
* @param arreglo1 El primer arreglo
* @param arreglo2 El segundo arreglo
* @return El resultado de la concatenacion
*/

public static int[] concatenar (int[] arreglo1, int[] arreglo2)

{
int arregloResultante[] = new int[arreglo1.length+arreglo2.length];

int j = 0;

for(int i=0; i<arreglo1.length+arreglo2.length; i++)

{
if(i<arreglo1.length)
{
arregloResultante[i]=arreglo1[i];
}
else
{
arregloResultante[i]=arreglo2[j];
j++;
}

}
return arregloResultante;
}

/**
* Mtodo que cuenta la cantidad de pares o impares que hay en un arreglo de enteros
*
* @param enteros Arreglo de nmeros enteros
* @return La cantidad de nmeros pares en el arreglo
*/
public static int obtenerCantidad ( int[] enteros, int opcion )
{
int cantidad=0;

9
 for (int i = 0 ; i < enteros.length ; i++ )
{
if ( enteros[ i ] % 2 == 0 &&opcion==0)
{
cantidad++;
}

else
if ( enteros[ i ] % 2 != 0 &&opcion==1)
{
cantidad++;
}

return cantidad;
}

/**
* Mtodo para leer un nmero entero
*
* @param pregunta Texto con un pregunta para el usuario
* @return Nmero entero como respuesta a la pregunta
*/
public static int leerEntero ( String pregunta )
{
return Integer.parseInt( JOptionPane.showInputDialog( pregunta ) );
}

/**
* Mtodo para imprimir un texto en una ventana.
*
* @param texto Texto que se desea imprimir
*/
public static void imprimirMensaje( String texto )
{
JOptionPane.showMessageDialog( null, texto );
}
/**
* Mtodo para leer varios enteros y retornarlos en un arreglo
*
* @param pregunta Texto usado como pregunta al usuario
* @param cantidad Cantidad de textos a ingresar como respuesta
* @return Arreglo con los textos ingresados como respuesta
*/
public static int[] leerVectorEnteros ( String pregunta, int cantidad )
{
int i, enteros[];

enteros = new int [ cantidad ];

for ( i = 0 ; i < cantidad ; i++ )

{
enteros [ i ] = leerEntero( pregunta +
"( " + (i+1) + " de " + cantidad + " )" );
}

10
 return enteros;
}

/**
* Mtodo que imprime varios enteros dados en un arreglo
*
* @param cadenas Arreglo con los enteros a imprimir
*/
public static String devolverStringArreglo ( int[] cadenas )
{
String salida;
int i;

salida = "[";
for ( i = 0 ; i < cadenas.length ; i++ )
{
salida += cadenas[ i ] + " ";
}
salida +="]";
return ( salida );
}

Ejecucin

11
12
Programa para leer n enteros, que posteriormente elimina un elemento de una posicin-
Jugutier.

import javax.swing.JOptionPane;

/**
* Programa para leer n enteros, que posteriormente elimina un elemento de una
* posicin.
*
* @author Jugutier
*/
public class Ejemplo05{

/**
* @param args the command line arguments
*/
public static void main( String[] args) {
int cantidad, enteros[], nuevoArrego[], posicionEliminar;

cantidad = leerEntero ( "Cantidad de nmeros a leer" );

enteros = leerArreglo ( "Ingrese un entero ", cantidad );
posicionEliminar = leerEntero ( "Posicin a eliminar ( 0 - " +
(cantidad-1) + " )" );

nuevoArrego = eliminarElemento ( enteros, posicionEliminar );

imprimirMensaje( "Arreglo original: "+devolverStringArregloEnteros(enteros)+

"\nArreglo modificado: "+devolverStringArregloEnteros(nuevoArrego));

/**
* Mtodo para eliminar un elemento de un arreglo creando otro arreglo
* sin el elemento de la posicin especificada
*
* @param enteros Arreglo de enteros
* @param posicin Posicin a eliminar
* @return Un nuevo arreglo sin el elemento de la posicin dada
*/
public static int[] eliminarElemento ( int[] enteros, int posicion )
{
int nuevoArreglo[], i, j;

nuevoArreglo = new int [ enteros.length - 1 ];

j = 0;
for ( i = 0 ; i < enteros.length ; i++ )
{
if ( i != posicion )
{
nuevoArreglo [ j ] = enteros [ i ];
j++;
}

13
 }

return nuevoArreglo;
}

/**
* Mtodo para leer un nmero entero
*
* @param pregunta Texto con un pregunta para el usuario
* @return Nmero entero como respuesta a la pregunta
*/
public static int leerEntero ( String pregunta )
{
return Integer.parseInt( JOptionPane.showInputDialog( pregunta ) );
}

/**
* Mtodo para imprimir un texto en una ventana.
*
* @param texto Texto que se desea imprimir
*/
public static void imprimirMensaje( String texto )
{
JOptionPane.showMessageDialog( null, texto );
}

/**
* Mtodo para leer varios enteros y retornarlos en un arreglo
*
* @param pregunta Texto usado como pregunta al usuario
* @param cantidad Cantidad de textos a ingresar como respuesta
* @return Arreglo con los textos ingresados como respuesta
*/
public static int[] leerArreglo ( String pregunta, int cantidad )
{
int i, enteros[];

enteros = new int [ cantidad ];

for ( i = 0 ; i < cantidad ; i++ )

{
enteros [ i ] = leerEntero( pregunta +
"( " + (i+1) + " de " + cantidad + " )" );
}

return enteros;
}

/**
* Mtodo que imprime varios enteros dados en un arreglo
*
* @param enteros Arreglo con los enteros a imprimir
*/
public static String devolverStringArregloEnteros ( int[] enteros )

14
 {
String salida;
int i;

salida = "[ ";

for ( i = 0 ; i < enteros.length ; i++ )
{
salida += enteros[ i ] + " ";
}
salida+=" ]";
return salida ;
}

Ejecucin

15
16
Clase Arrays

Mtodo Descripcin
static boolean equals (int[ ] a,int[ ] a2) Devuelve true si los arreglos tienen los mismos
elementos, en el mismo orden
if(Arrays.equals(miArreglo1, miArreglo2))

static int[ ] copyOf (int[ ] original, int newLength); Copia el arreglo original (trunca o rellena para que el
resultado quede con el tamao requerido).

resultado = Arrays.copyOf(miArreglo1, 4);

static int[ ] copyOfRange(int[] original, int from, int to) Copia el arreglo original, desde la posicin inicial
hasta la final
static void fill (int[ ] a, int val) Rellena con val cada elemento del arreglo de enteros.

static void fill (int[ ] a, int inicio, int final, int val) Arrays.fill(miArreglo1, 5);

La segunda opcin permite especificar el rango de

posiciones en la que se va a efectuar el reemplazo
static String toString(int[] a) Retorna la representacin en String del contenido del
arreglo

17
Dados dos conjuntos realizar las operaciones de unin e interseccin

import java.util.Arrays;

import javax.swing.JOptionPane;

/**
* Dados dos conjuntos hallar la unin e interseccin.
*
* @author Sonia
*/
public class Ejemplo06{

/**
* @param args the command line arguments
*/
public static void main( String[] args) {
String conjunto1[], conjunto2[], union[], interseccion[];

conjunto1 = leerString( "Ingrese los elementos del primer conjunto separados por coma
").split(",");
conjunto2 = leerString( "Ingrese los elementos del segundo conjunto separados por
coma ").split(",");

union = hallarUnion (conjunto1, conjunto2);

interseccion = hallarInterseccion(conjunto1, conjunto2);

imprimirMensaje( "Conjunto1 :\n"+ Arrays.toString (conjunto1) +

"\nConjunto2 :\n"+ Arrays.toString (conjunto2) +
"\nUnion :\n"+ Arrays.toString(union) +
"\nInterserccion :\n"+ Arrays.toString (interseccion));

/**
* Halla la union de dos conjuntos
* @param conjunto1 El conjunto 1
* @param conjunto2 eE l conjunto 2
* @return La union de los dos conjuntos
*/
public static String[] hallarUnion(String conjunto1[], String conjunto2[])
{
String resultado[]=new String[conjunto1.length + conjunto2.length];
int contador = 0;
String dato = "";

//se copia primero el primer vector

for(int i=0; i<conjunto1.length; i++)
{
resultado [contador] = conjunto1 [i];
contador ++;
}

for(int i=0; i<conjunto2.length; i++)

18
 {
dato=conjunto2 [i];
if(verificarEstaContenido(resultado, dato) == false)
{
resultado [contador] = dato;
contador ++;
}

}
//Se eliminan los espacios en null
resultado=Arrays.copyOf(resultado, contador);

return resultado;
}
/**
* Halla la interseccion de dos conjuntos
* @param conjunto1 El conjunto 1
* @param conjunto2 eE l conjunto 2
* @return La interseccion de los dos conjuntos
*/
public static String[] hallarInterseccion(String conjunto1[], String conjunto2[])
{
String resultado[];
int tamMaximo=conjunto1.length;
int contador = 0;
String dato = "";

//se halla el tamao maximo del conjunto

if(conjunto2.length>tamMaximo)
{
tamMaximo = conjunto2.length;
}

resultado= new String[tamMaximo];

//se verifica si un elemento est en ambos conjuntos

for(int i=0; i<conjunto1.length; i++)
{
dato = conjunto1 [i];
if(verificarEstaContenido(conjunto2, dato))
{
resultado [contador] = dato;
contador ++;
}
}

//Se eliminan los espacios en null

resultado=Arrays.copyOf(resultado, contador);

return resultado;
}

/**
* Verifica si dato est contenido en el arreglo
* @param conjunto El arreglo de elementos
* @param dato El dato a buscar
* @return Un true si se encuentra en el arreglo, false en caso contrario
*/

19
public static boolean verificarEstaContenido(String conjunto[], String dato)
{
boolean centinela=false;
for(int i=0; i < conjunto.length && centinela == false; i++)
{
if(conjunto[i]!=null&& (conjunto[i].trim()).equals(dato.trim()))
{
centinela = true;
}
}

return centinela;
}

/**
* Mtodo para eliminar un elemento de un arreglo creando otro arreglo
* sin el elemento de la posicin especificada
*
* @param enteros Arreglo de enteros
* @param posicin Posicin a eliminar
* @return Un nuevo arreglo sin el elemento de la posicin dada
*/
public static int[] eliminarElemento ( int[] enteros, int posicion )
{
int nuevoArreglo[], i, j;

nuevoArreglo = new int [ enteros.length - 1 ];

j = 0;
for ( i = 0 ; i < enteros.length ; i++ )
{
if ( i != posicion )
{
nuevoArreglo [ j ] = enteros [ i ];
j++;
}
}

return nuevoArreglo;
}

/**
* Mtodo para leer un nmero entero
*
* @param pregunta Texto con un pregunta para el usuario
* @return Nmero entero como respuesta a la pregunta
*/
public static int leerEntero ( String pregunta )
{
return Integer.parseInt( JOptionPane.showInputDialog( pregunta ) );
}

/**
* Mtodo para imprimir un texto en una ventana.
*

20
 * @param texto Texto que se desea imprimir
*/
public static void imprimirMensaje( String texto )
{
JOptionPane.showMessageDialog( null, texto );
}

/**
* Mtodo para leer varios enteros y retornarlos en un arreglo
*
* @param pregunta Texto usado como pregunta al usuario
* @param cantidad Cantidad de textos a ingresar como respuesta
* @return Arreglo con los textos ingresados como respuesta
*/
public static int[] leerArreglo ( String pregunta, int cantidad )
{
int i, enteros[];

enteros = new int [ cantidad ];

for ( i = 0 ; i < cantidad ; i++ )

{
enteros [ i ] = leerEntero( pregunta +
"( " + (i+1) + " de " + cantidad + " )" );
}

return enteros;
}

/**
* Mtodo que imprime varios enteros dados en un arreglo
*
* @param enteros Arreglo con los enteros a imprimir
*/
public static String devolverStringArregloEnteros ( int[] enteros )
{
String salida;
int i;

salida = "[ ";

for ( i = 0 ; i < enteros.length ; i++ )
{
salida += enteros[ i ] + " ";
}
salida+=" ]";
return salida ;
}

/**
* Mtodo para leer un texto (cadena)
*
* @param pregunta Texto que se le muestra al usuario
* @return Texto ingresado
*/
public static String leerString ( String pregunta )
{
return JOptionPane.showInputDialog( pregunta );

21
 }

Ejecucin

22
Fusionar dos arreglos, el arreglo 1 se recorre de izquierda a derecha y el arreglo 2 de
derecha a izquierda

import java.util.Arrays;
import javax.swing.JOptionPane;

/**
* Fusionar dos arreglos.
*
* @author Sonia
*/
public class Ejemplo07{

/**
* @param args the command line arguments
*/
public static void main( String[] args) {
int arreglo1 [], arreglo2 [];
int cantidad;
int fusion [];

cantidad = leerEntero("Ingrese la cantidad mxima de elementos ");

arreglo1 = leerArreglo("ARREGLO 1: Ingrese el elemento ", cantidad);
arreglo2 = leerArreglo("ARREGLO 2: Ingrese el elemento ", cantidad);

fusion = fusionar (arreglo1 , arreglo2);

imprimirMensaje("Arreglo 1: \n"+Arrays.toString(arreglo1)+
"\nArreglo 2: \n"+Arrays.toString(arreglo2)+
"\nArreglo fusionado: \n"+Arrays.toString(fusion));
}

/**
* Se fusionan dos vectores, el arreglo 1 se recorre de izquierda a derecha
* y el arreglo 2 de derecha a izquierda
* @param arreglo1 El arreglo 1
* @param arreglo2 El arreglo 2
* @return El arreglo resultado de la fusion
*/

public static int [] fusionar(int arreglo1 [], int arreglo2[])

{
int [] resultado = new int [arreglo1.length + arreglo2.length];
int j = arreglo2.length-1;
int contador = 0;

for(int i=0; i<arreglo1.length; i++)

{

resultado[contador] = arreglo1 [i];

contador++;
resultado[contador] = arreglo2 [j];
contador++;
j--;

23
 }
return resultado;
}

/**
* Mtodo para leer varios enteros y retornarlos en un arreglo
*
* @param pregunta Texto usado como pregunta al usuario
* @param cantidad Cantidad de textos a ingresar como respuesta
* @return Arreglo con los textos ingresados como respuesta
*/
public static int [] leerArreglo ( String pregunta, int cantidad )
{
int i;
int reales[];

reales = new int[ cantidad ];

for ( i = 0 ; i < cantidad ; i++ )

{
reales [ i ] = leerEntero( pregunta +
"( " + (i+1) + " de " + cantidad + " )" );
}

return reales;
}

/**
* Mtodo para leer un nmero entero
*
* @param pregunta Texto con un pregunta para el usuario
* @return Nmero entero como respuesta a la pregunta
*/
public static int leerEntero ( String pregunta )
{
return Integer.parseInt( JOptionPane.showInputDialog( pregunta ) );
}

/**
* Mtodo para imprimir un texto en una ventana.
*
* @param texto Texto que se desea imprimir
*/
public static void imprimirMensaje( String texto )
{
JOptionPane.showMessageDialog( null, texto );
}

Ejecucin

24
25
Eliminar elementos repetidos de un arreglo

import java.util.Arrays;

import javax.swing.JOptionPane;

public class Ejemplo08 {

/**
* @param args the command line arguments
*/
public static void main( String[] args) {
String datos[], datosSinRepeticiones[];

datos = leerString( "Ingrese los elementos del vector a examinar, separados por
coma").split(",");
datosSinRepeticiones = eliminarRepetidos (datos);

imprimirMensaje( "Original: \n"+ Arrays.toString (datos) +

"\nSin Repeticiones:\n"+ Arrays.toString ( datosSinRepeticiones) );

/**
* Mtodo para eliminar los elementos repetidos de un arreglo
* @param original El arreglo original
* @return El arreglo sin repeticiones
*/
public static String[] eliminarRepetidos (String [] original)
{
String resultado[]= new String[original.length];
String cadena = "";
int contador = 0;

for(int i=0; i<original.length; i++)

{
cadena = original [i];
if(!verificarEstaContenido(resultado, cadena ))
{
resultado [contador] = cadena;
contador++;
}

resultado = Arrays.copyOf(resultado, contador);

return resultado;

/**
* Verifica si dato est contenido en el arreglo
* @param vector El arreglo de elementos
* @param dato El dato a buscar

26
 * @return Un true si se encuentra en el arreglo, false en caso contrario
*/

public static boolean verificarEstaContenido(String vector[], String dato)

{
boolean centinela=false;
for(int i=0; i < vector.length && vector[i]!=null && centinela == false; i++)
{
if(vector[i]!=null&&vector[i].trim().equals(dato.trim()))
{
centinela = true;
}
}

return centinela;
}

/**
* Mtodo para leer un texto (cadena)
*
* @param pregunta Texto que se le muestra al usuario
* @return Texto ingresado
*/
public static String leerString ( String pregunta )
{
return JOptionPane.showInputDialog( pregunta );
}

/**
* Mtodo para imprimir un texto en una ventana.
*
* @param texto Texto que se desea imprimir
*/
public static void imprimirMensaje( String texto )
{
JOptionPane.showMessageDialog( null, texto );
}

27
 TALLER DE ARREGLOS

1. Obtener el promedio de todos los nmeros primos que hay en un arreglo.

2. Obtener el promedio de todos los nmeros perfectos que hay en un arreglo. Un nmero es perfecto cuando la
suma de sus divisores propios es igual al mismo nmero. Ejemplo 6 es nmero perfecto, porque sus divisores
propios son 1, 2 y 3; y 6 = 1 + 2 + 3.

3. Programa para hallar la diferencia entre dos conjuntos.

4. Pasar de decimal a hexadecimal, almacenar el resultado en un vector.

5. Leer dos vectores A y B, e indicar si el uno est contenido en otro en orden estricto inverso
Ejemplo A= 1,2,3,4,5,7 B=5,4,3 Debe indicar que B est contenido en A

6. Desarrollar un mtodo que permita determinar los tres valores que ms se repiten en un
vector de n elementos enteros.

7. Dado un nmero indicar si es o no vampiro. Los nmeros vampiro sobreviven ocultos entre el resto de nuestro
sistema numrico, conservando los genes de sus padres tras multiplicarse. As, por ejemplo, el nmero 2.187 es
un nmero vampiro, al tener los mismos genes (dgitos) que sus dos progenitores, 27 y 81 (27 81 = 2.187).
Los nmeros vampiro verdaderos (con pedigr) cumplen cuatro condiciones:
Tienen un nmero par de dgitos.
Se obtienen al multiplicar dos nmeros, llamados colmillos, que tienen la mitad de dgitos que el original.
Tienen los mismos dgitos que los colmillos, y en la misma cantidad (aunque en cualquier orden).
Los colmillos no acaban simultneamente en 0.
Se han detectado tambin algunos nmeros vampiro primos por serlo sus colmillos (536.539 = 563 953), e incluso
vampiros con varios pares de colmillos (125.460 = 204 615 = 246 510). Algunos nmeros se limitan a imitar a
los vampiros, como el 126 (6 21) cuyos colmillos no tienen la misma longitud, o el 1.395 (5 9 31) que tiene tres
colmillo *

8. Hacer un mtodo para verificar si un nmero es polidivisible. Los nmeros

polidivisibles son aquellos nmeros que:
Son mayores que cero.
El nmero formado por su primer dgito es mltiplo de 1 (esto lo cumplen todos los nmeros).
El nmero formado por sus dos primeros dgitos es mltiplo de 2.
El nmero formado por sus tres primeros dgitos es mltiplo de 3.
El nmero formado por sus cuatro primeros dgitos es mltiplo de 4.

En general, el nmero formado por sus K primeros dgitos es mltiplo de K. Se debe asumir que los
nmeros se escriben en base 10 y sin ceros a la izquierda.
Por ejemplo, el nmero 2.016 es polidivisible, pues es mayor que cero y 2 es divisible por 1, 20 lo es por 2, 201 por
3 y, por ltimo, el propio 2.016 es divisible por 4. 1

1
Tomado de acepta el reto
28