Mi algoritmo para eliminar datos de un array (tengo que usar 5 arrays)

[KaRaLLo]

Hola, después de haberme rayado la cabeza desde las ocho de la tarde, he conseguido sacar el ejercicio que me mandaron hoy en DAM en el módulo de programación (Java).

El ejercicio consiste en juntar 4 arrays

A un array String van asociados los valores de un array Int
A otro array String se le asocian los valores de otro array Int

Otro array fusiona los dos anteriores Strings[]
y otro fusiona los dos int[]

Ni que decir tengo que cada elemento del String fusionado[] tiene que corresponderle su valor.

Se ve mejor pensando que :

Un banco tiene estos clientes

String clientes[]           Int capital[]

Otro banco tiene estos

String clientes2[]         Int clientes2[]

Pero se fusionan y acaban todos

String clientes3[]        int clientes3[]

Código (java) [Seleccionar] Expandir

public class PruebasMain {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] a ={"Pedro", "Rodrigo", "Manuel",
"Jose",   "Paco",};


String[] b={"Luis",   "Antonio", "Pedro",
"Juan",  "Rodrigo"};

String[] N={"Pedro", "Rodrigo", "Manuel",
"Jose",   "Paco"  , "Luis",
"Antonio","Pedro" , "Juan",
"Rodrigo"};
int M[]={100,200,300,
400,500,600,
1000,2000,
3000,4000,
5000,};

int[] c={100,200,300,
400,500};

int[] d={1000,2000,3000,
4000,5000};
int k;
String auxNombre="";boolean bandera=false;

for (int j = 0; j < b.length; j++) { //el indice indica el elemento a compara
for (int i = 0; i < a.length; i++) { //el indice indica los elementos que compara
if(b[j].equals(a[i])){ //si el nombre es igual al otor array
auxNombre=a[i]; //asigna el nombre a un auxiliar
int auxDin=c[i]+d[j]; //y a un auxiliar la suma de los dos valores de sus capitales
for (int l = 0; l < N.length; l++) { //este for asigna los valores al tercer array
if(N[l].equals(auxNombre)){ //si N es igual al nombre encontrado
M[l]=c[i]+d[j]; //se le asigna el dinero de auxDin
N[l]=N[l]+" duplicado"; //si se le concatena al string de su nombre duplicado
int o=l; //se guarda el indice
if (l>o && N[l].equals(auxNombre)) { //para asegurarme que no vacie el primero
N[l]="(--Vacio--)";
M[l]=0;
}
}
}
}
}
}//fin del segundo
}// fin del primero
}


Se ve mejor pensando que :

Un banco tiene estos clientes

String clientes[]           Int capital[]

Otro banco tiene estos

String clientes2[]         Int clientes2[]

Pero se fusionan y acaban todos

String clientes3[]        int clientes3[]


Añado que todavía no di los arreglos multidimensionales. Si no veo ninguna respuesta lo entiendo ya que esto me parece un poco cocedura xD.

Lo posteo porque me gustaría saber que os pareces o si se podría hacer de una forma mas simple.

PD: Si alguien lo resuelve con 2 líneas de código abro la ventana y me tiro
siento el tocho

[1mpuls0]

Trolololol

Código (java) [Seleccionar] Expandir


public class trolololo {    public static void main(String args[]){        String[] a ={"Pedro", "Rodrigo", "Manuel", "Jose", "Paco"};        String[] b={"Luis", "Antonio", "Pedro", "Juan","Rodrigo"};        int[] c={100,200,300, 400,500};        int[] d={1000,2000,3000,4000,5000};         int totalElementos=a.length+b.length;         String [] fusionNombre= new String[totalElementos];         int [] fusionCapital = new int[totalElementos];         int posicion=0;
       for(int contador=0; contador<totalElementos;contador++){            if(contador<a.length){                fusionNombre[contador]=a[contador];                fusionCapital[contador]=c[contador]; }else{                fusionNombre[contador]=b[posicion];                fusionCapital[contador]=d[posicion];              posicion++; } System.out.println(fusionNombre[contador]); System.out.println(fusionCapital[contador]); } } }


Bien espero tu parte xD

Si alguien lo resuelve con 2 líneas de código abro la ventana y me tiro

Está en dos líneas de código (bendito sean los ; y {}) xD

Bueno para fusionar ya está así como lo planteas, pero veo que en tu código tienes por si se llega a repetir un nombre (no le veo lógica, pero bueno)

Saludos.

[bewa]

No entiendo muy bien lo que quieres hacer pero estoy viendo bucles dentro de bucles y probablemente se pueda hacer con recursividad de forma más fácil.

PD. Yo también estoy haciendo DAM.