Pequeña duda

NelglakFG #1 May '21

Buenas,

Tengo esto:

import java.util.Arrays;

public class Main {

public static void main(String[] args) {

    int contador = 0;
    int[] array = {1, 2, 3, 1, 2, 3, 1, 1, 6, 9, 9, 7, 1};
    Arrays.sort(array); //Ordeno el array
    int aux = array[0]; //Almaceno en aux el primer valor del array

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

        if (aux == array[i]) {
            contador++;
        } else {
            System.out.println("El número " + aux + " se repite " + contador + " veces");
            contador = 1;
            aux = array[i];
        }
    }

    System.out.println("El número " + aux + " se repite " + contador + "veces");

}

}

Y mi pregunta es ¿dónde/como puedo guardar los resultados mientras recorro el array y solo recorriéndolo 1 vez para que sea más óptimo??

Por cierto algún sitio donde pueda hacer/mirar ejercicios de este estilo?
Quiero mejorar en todos los aspectos que pueda para prepararme para el curso que viene y me gustaría entender mejor estructura de datos y creación de algoritmos aunque sea a nivel basico-medio

Un saludo!

GaaRa90 #2 May '21

para empezar la manera mas sencilla seria antes del for, creas un hashmap, y al entren en el else, añades al hashmap como clave el numero (aux) y valor, veces, despues tendras un hashmap con claves de los numeros que habia y valores las veces repetidas.

1

Lafayette #3 May '21

En otro array?

1 respuesta

GaaRa90 #4 May '21

#3 no, en otro array solo podras amacenar un dato (o valor o numero de repeticiones), pero no sabes a que dato hace referencia, ademas tendria que ser bidimensional
[1][2]...
[5][2]..
o crearte un objeto que dentro tenga como atributos valorNumerico y repeticiones.
ademas de que tendrias que crear el array con el tamaño de la lista de numero en el caso de que no se repitiera ninguno, menos eficiente.
cuando tienes que almacenar una cantidad de datos que no sabes la cantidad exacta array no es tu primera opcion.

PD: array != vector. porcierto

1

desu #5 May '21

Si quieres que la gente te pueda ayudar bien, pon siempre el enunciado o explica detalladamente lo que quieres hacer. Porque no se entiende bien lo que dices... Nos lo imaginamos... Pero vamos, el código no hace lo que estas preguntando y es confuso.

Imaginamos que lo que quieres es sacar un contador de cuantas veces se repiten los números. En tu ejemplo el resultado seria:

{
    7: 1,
    1: 5,
    9: 2,
    6: 1,
    2: 2,
    3: 2,
}

Tienes 3 maneras de resolverlo, dependiendo del enunciado.

array estatico

La mas simple y basica es resolverlo con un array. Si sabes el numero maximo o el rango de numeros que tienes en tu array lo puedes aplicar directamente. Por ejemplo si sabes que solo tendras numeros 10 numeros. Puedes inicializar un array vacio con [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] y luego iterar tu array, cuando encuentres un valor, sabes que su indice sera valor - 1, incrementas.

fn array() {
    let array = [1, 2, 3, 1, 2, 3, 1, 1, 6, 9, 9, 7, 1]; // array original
    let mut counter = [0; 10]; // contador con 10 zeros
    for n in &array { 
        counter[n-1] += 1; // para cada n, su indice, sera n - 1, incremento el valor
    }
}

map/diccionario

La opcion habitual cuando no conces el tama;o es un hashmap, para cada elemento del array, coges la entrada y la modificas incrementando 1, si no existe le pones un 1.

    let mut map: HashMap<u32, u32> = HashMap::new();
    let array = [1, 2, 3, 1, 2, 3, 1, 1, 6, 9, 9, 7, 1];
    for n in &array {
        map.entry(*n)
            .and_modify(|v| *v += 1)
            .or_insert(1);
    }

coleccion de array

Otra opcion es en el caso de que no conozcas el tama;o total de tu array, puedes usar una estructura de datos como una ArrayList en java. La diferencia entre una estructura como el array list y un array es que en el segundo conoces su tama;o de antemano. En el caso anterior hemos supuesto que tendriamos como maximo 10 elementos, por tanto podemos inicializar ese array con 10 posiciones a 0. En el caso del arraylist no sabemos cuantos elementos tendremos.

fn array_list() {
    let array = [1, 2, 3, 1, 2, 3, 1, 1, 6, 9, 9, 7, 1];
    let mut counter: Vec<i32> = Vec::new(); // inicializo un array con 0
    for n in &array {
        if n > &counter.len() { // si intento poner un numero que no cabe tengo que hacer el array mas grande
            counter.resize_with(*n, Default::default); // lo que hago es incrementar el tam;ao del array y copiarme los valores que ya teniamos
        }
        counter[n-1] +=  1;  // incrementamos el valor
    }
}

Aunque hacer esto ultimo tu a mano no tiene mucho sentido, normalmente los hashmaps internamente ya lo haran por ti y de manera mas inteligente...

Como puedes ver esto es mas complejo, cada vez que mi array se queda peque;o porque necesito meter una n mas grande de lo que consideraba, tengo que llamar una funcion para rehacer el array.

En general si vas a programar te recomiendo que primero empieces escribiendo la funcion y el resultado, aunque sea un print por pantalla de lo que quieres obtener. Asi puedes completar la funcion y comprobar si esta bien. Ponte unos cuantos ejemplos a mano...

1 1 respuesta

NelglakFG #6 May '21

#5 Muchas gracias, basicamente no hay enunciado es un ejercicio que me he impuesto yo. Teniendo esto {1, 2, 4, 1, 2, 3, 5, 1, 3, 9, 2, 1, 1} (O cualquier otro array) tengo que sacar cuanto se repite cada número recorriendo el array una sola vez y guardar el resultado en algun sitio y no sacarlo asi tan cutre con el println.

Básicamente mi modo no es el más óptimo y quería entender/razonar como hacerlo más óptimo.

1 respuesta

desu #7 May '21

#6 Puedes buscar ejercicios en la categoría de facil en hackerrank. Diria que son los mas simples de este estilo para aprender.

La intuición del coste es pensando en cuantas veces tienes que recorrer el array... Si puedes recorrer en 1 pasada siempre sera mejor que en 2.

Este video parece que esta bien, si entiendes que cuantos mas bucles anidados y mayor sea el tama;o de las listas mas tardara pues ya esta... tampoco te ralles. primero trata de resolver el problema que funcione bien, luego mira de hacerlo mas optimo si puedes.

Pequeña duda

Usuarios habituales

Tags