Devolviendo verdad si puedes dividir una lista en una lista más pequeña con mínimo dos valores en la lista separada de otra manera devolver falso

Question

En una cubierta de tarjetas, cada tarjeta tiene un entero escrito en ella. Regresar verdadero si es posible dividir toda la cubierta en 1 o más grupos de tarjetas, donde: Cada grupo tiene al menos 2 cartas. Todas las cartas de cada grupo tienen el mismo entero. Ejemplo: Entrada: cubierta = [1,2,3,4,4,3,2,1] Producto: verdadero Explicación: Posible partición [1,1],[2,2],[3,3],[4,4]. Intenté resolver esto usando pila, pero no funciona como se espera y se está imponiendo falso donde se supone que debe imprimir verdad. He añadido comentario para la claridad de mi código. package practicepkg; import java.util.Stack; public class DeckInteger { public static void main(String[] args) { Stack stack = new Stack(); //declaring individual variable for each integer and setting all of them to zero int p_1=0,p_2=0,p_3=0,p_4=0,p_5=0,p_6=0,p_7=0,p_8=0,p_9=0; //adding element which can form pair and should return true stack.add(1); stack.add(2); stack.add(1); stack.add(2); stack.add(1); stack.add(2); //checking till stack is empty and comparing the top of stack to all the individual integer and incrementing them and popping the top element while(stack.empty()==false) { if(stack.peek()==1) { p_1+=1; stack.pop(); break; } else if(stack.peek()==2) { p_2+=1; stack.pop(); break; } else if(stack.peek()==3) { stack.pop(); p_3+=1; break; } else if(stack.peek()==4) { stack.pop(); p_4+=1; break; } else if(stack.peek()==5) { stack.pop(); p_5+=1; break; } else if(stack.peek()==6) { stack.pop(); p_6+=1; break; } else if(stack.peek()==7) { stack.pop(); p_7+=1; break; } else if(stack.peek()==8) { stack.pop(); p_8+=1; break; } else { stack.pop(); p_9+=1; break; } } //checking if any of the integer variable have the value 1 then it cannot form pair as x>=2 so it should print false if(p_1==1||p_2==1||p_3==1||p_4==1||p_5==1||p_6==1||p_7==1||p_8==1||p_9==1) { System.out.println( False ); } //print true as if any of the variable have a value other than one else { System.out.println( True ); } } }

codecraftsman · Accepted Answer

Si tienes a_i tarjetas con entero i, entonces todas las particiones posibles serían divisores de a_iDe lo contrario, esta tarjeta no puede dividirse. Por lo tanto sólo necesita contar todos los números únicos y calcular su mayor divisor común. Este mayor divisor común sería el mayor X posible.

scriptwarrior · Answer

En el código que está usando break dentro de cada if condición. Así que se rompería el while bucle en la primera iteración misma. Tan solo p_1 Sería igual 1 y todos los demás serían 0. Hay una manera mucho mejor de resolver esto usando Maps con llave como el entero y el valor como se cuenta Suponiendo la entrada como un array : int[] input private boolean isValidGroup(Stack stack){ Map countMap = new HashMap<>(); while(!stack.empty()){ countMap.merge(stack.pop(),1,Integer::sum); } // The above map would contain the count for each integer. // For input : {1,2,4,2,4,3,1,3} , the map would be {1:2,2:2,3:2,4:2} List distinctCounts = countMap.values().stream().distinct().collect(Collectors.toList()); // The above list contains the distinct group counts. // Ideally the number of distinct count value should be 1 and the value should be >=2. //In such case, we return true. return (distinctCounts.size()==1 && distinctCounts.get(0)>=2); }

Gpt · Answer

El problema en tu código es que estás utilizando el método break dentro de tus condicionales, lo cual está interrumpiendo el bucle while prematuramente. Esto hace que solo se compare el primer elemento de la pila y se salga del bucle.

Una manera de abordar este problema es utilizar un HashMap para contar la frecuencia de cada entero en la pila. Luego, puedes verificar si cada entero tiene una cantidad igual o mayor a 2 para formar grupos de al menos dos cartas con el mismo entero. Aquí te dejo una posible implementación:

java
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

public class DeckInteger {

    public static void main(String[] args) {
        Stack stack = new Stack<>();
        stack.add(1);
        stack.add(2);
        stack.add(1);
        stack.add(2);
        stack.add(1);
        stack.add(2);

        Map freqMap = new HashMap<>();

        // Contando la frecuencia de cada entero en la pila
        while (!stack.isEmpty()) {
            int current = stack.pop();
            freqMap.put(current, freqMap.getOrDefault(current, 0) + 1);
        }

        // Verificando si cada entero tiene al menos 2 cartas
        for (int frequency : freqMap.values()) {
            if (frequency < 2) {
                System.out.println("False");
                return;
            }
        }

        System.out.println("True");
    }
}

Con esta implementación, se contará la frecuencia de cada entero en la pila y luego se verificará si cada entero tiene al menos dos cartas. Si se cumple la condición para todos los enteros, el programa imprimirá "True"; de lo contrario, imprimirá "False".

Respondida el Dec 18, 2020 a las 15:18 - por Gpt

Gemini · Answer

El problema principal con tu código es que no estás manejando correctamente el caso en el que la pila stack contiene más de un elemento con el mismo valor. Esto puede llevar a resultados incorrectos.

Aquí tienes una versión modificada de tu código que debería funcionar correctamente:

java
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

public class DeckInteger {

    public static void main(String[] args) {
        Stack stack = new Stack();
        Map map = new HashMap<>();

        // Añadiendo elementos a la pila
        stack.add(1);
        stack.add(2);
        stack.add(1);
        stack.add(2);
        stack.add(1);
        stack.add(2);

        // Procesando la pila y contando las ocurrencias de cada entero
        while (!stack.empty()) {
            int num = stack.pop();
            map.put(num, map.getOrDefault(num, 0) + 1);
        }

        // Comprobando si todos los enteros tienen al menos dos ocurrencias
        boolean isValid = true;
        for (int count : map.values()) {
            if (count < 2) {
                isValid = false;
                break;
            }
        }

        // Imprimiendo el resultado
        System.out.println(isValid ? "True" : "False");
    }
}

En este código mejorado:

Utilizamos un Map llamado map para contar las ocurrencias de cada entero en la pila. Recorremos la pila y actualizamos el recuento para cada entero en el map.

Después, recorremos el `map` y comprobamos si todos los valores del recuento son mayores o iguales que 2. Si todos los recuentos son válidos, imprimimos "True"; de lo contrario, imprimimos "False".

Este enfoque garantiza que contemos correctamente las ocurrencias de cada entero y que podamos determinar si la división es posible o no.

Respondida el Dec 18, 2020 a las 15:29 - por Gemini

Devolviendo verdad si puedes dividir una lista en una lista más pequeña con mínimo dos valores en la lista separada de otra manera devolver falso

4 Respuestas: