números (A, B) de sincronización de una matriz de tal manera que a * 2> = b

super estrella secreta:

Estoy tratando de resolver los números de emparejamiento (a, b) en una matriz tal manera que a*2 >=b. Donde a y b son números de matriz de entrada.

Ejemplos:

entrada: a[] = {1,2,3,4,5}

salida: 2

explicación:

• podemos emparejar 1 con 3
• 2 con 4 o 5

entrada: a[] = {4,3,2,1,5}

salida: 2

explicación:

• podemos emparejar 1 con 3
• 2 con 4 o 5

entrada: a[] = {4,3,2,1,5,6}

salida: 3

explicación:

• podemos emparejar 5 con 1
• 2 con 4
• 3 con 6

Traté de resolver el problema con la recursividad como el de abajo, pero esto no da resultados correctos. Cualquier ayuda sería apreciada.

• Clasificar la matriz de entrada
• si un [Inicio] * 2> = [final] encontró entonces add 1a consecuencia recurrir durante start +1yend - 1
• lo demás se repiten para (start + 1, end), (start, end - 1)y(start + 1, end - 1)

Idea es coincidente a[start]con restantes elementos de la matriz y conseguir resultado max.

    public static int countPairs(int[] a){
       Arrays.sort(a);
       return countPairs(a,a.length,0,a.length-1);
    }

    public static int countPairs(int[] a, int n, int start, int end){


        if(end == start){
            return 0;
        }
        if(start >= n || end < 0){
            return 0;
        }

         System.out.print("matching start: "+start + " and end "+end+"   ");System.out.println("matching "+a[start] + " and "+a[end]);

        if(a[start] < a[end] && a[start] * 2 >= a[end]  ){

            int res = countPairs(a,n,start+1,end-1) +1;
             //System.out.print("inside if matching start: "+start + " and end "+end+"   ");System.out.println("matching "+a[start] + " and "+a[end] + " count is "+res);
            return res;
        }
        else{

            return max(countPairs(a,n,start+1,end) ,
                    countPairs(a,n,start,end - 1),countPairs(a,n,start+1,end - 1));
        }

    }

pruebas:

import org.junit.Test;

import java.util.Arrays;
import java.util.Random;


public class CountingPairsTest {

    static int countPairs(int[] a){
        return PairingNumbers.countPairs(a);
    }

    @Test
     public void test1(){
        int[] a = {1,2,3,4,5};
        System.out.println("****************************************\n" + Arrays.toString(a));
        int count = countPairs(a);
        System.out.println("count "+count);
    }

    @Test public void test2(){
        int[] a = {1,2,3,4,5,6};
        System.out.println("****************************************\n" + Arrays.toString(a));
        int count = countPairs(a);
        System.out.println("count "+count);
    }

    @Test public void test5(){
        int[] a = {1,2,3,7,4,5,6};
        System.out.println("****************************************\n" + Arrays.toString(a));
        int count = countPairs(a);
        System.out.println("count "+count);
    }

    @Test public void test6(){
        int[] a = {9,8,20,15,21};

        System.out.println("****************************************\n" + Arrays.toString(a));
        int count = countPairs(a);
        System.out.println("count "+count);
    }

    @Test public  void test3(){
        int[] a = {5,4,3,2,1};
        System.out.println("****************************************\n" + Arrays.toString(a));
        int count = countPairs(a);
        System.out.println("count "+count);
    }

    @Test public void test4(){
        int[] a = {2,4,5,3,1};

        System.out.println("****************************************\n" + Arrays.toString(a));
        int count = countPairs(a);
        System.out.println("count "+count);
    }

    @Test public void test7(){
        int[] a = new Random().ints(10,1,100).toArray();// IntStream.range(1,100).toArray();


        System.out.println("****************************************\n" + Arrays.toString(a));
        int count = countPairs(a);
        System.out.println("count "+count);
    }
    @Test public void test8(){
        int[] a = new Random().ints(10,1,10).toArray();// IntStream.range(1,100).toArray();


        System.out.println("****************************************\n" + Arrays.toString(a));
        int count = countPairs(a);
        System.out.println("count "+count);
    }
}

VV Ole:

Sugiero que la respuesta es a.length / 2. La mitad de la longitud de la matriz (redondeado a la baja si la longitud era impar). Puede emparejar los números de la forma que desee. Para no negativo una y b si un * 2 < b , sólo cambio una y B y que tendrá un * 2> = b . Por lo tanto, ya que toma dos números para hacer un par, siempre se puede formar con precisión tantos pares como la mitad de la longitud de la matriz.

Ejemplo (de los comentarios): [1, 2, 2, 2]. La longitud es de 4, la mitad de la longitud es 2, por lo que debe ser de 2 pares. Let cheque de: (1, 2) es un par agradable porque 1 * 2> = 2. (2, 2) es otro buen par desde el 2 * 2> = 2. En este caso, ni siquiera necesitamos ningún intercambio (en Por otra parte los mismos pares habrían trabajado con el canje demasiado: 2 * 2> = 1 y 2 * 2> = 2).

No siempre va a funcionar si la matriz puede contener números negativos. Así que es posible que desee agregar una validación de la matriz que no se comprueba que lo hace.

Lo que salió mal en su solución?

Su algoritmo recursivo es erróneo. Digamos que el array es [2, 3, 7, 9]. Claramente (2, 3) y (7, 9) son agradables pares, por lo que hay dos pares aquí. La forma en que describe su algoritmo, ya que (2, 9) no es un par válido, se descarta al menos uno de 2 y 9, sin dejar oportunidad de formar dos pares de los números restantes.