Encuentra las posiciones en las que los elementos situados en éstas tienen la menor distancia entre ellos

Revilo zednem:

Trato de lograr las posiciones en las que los elementos situados en éstas tienen la menor distancia entre ellos? tengo este código en Java 11:

public class Main {
    public static void main(String[] args) {
        int [] arr= {5, 50, 3, 42, 18, 16, 8, 30, 44};      // Array
        menorD l = new menorD();        
        menorD.MinD(arr);   
    }
}

public class  menorD {

    static int arr_zise;

    public static void minD (int [] arr) {
        arr_zise = arr.length;
        int i, j;
        int minD=0;

        for(i=0;i<arr_zise; i++) {
            for(j=0;j<arr_zise; j++) {
                if(arr[i]!=arr[j]) {
                    minD=arr[i]-arr[j];
                    System.out.print(" i="+ arr[i]+ " j="+ arr[j]+ " minD es: "+Math.abs(min));
                    System.out.println();
                }
            }
        }
    }
}

Trato de encontrar esto:

arr = {5, 50, 3, 42, 18, 16, 8, 30, 44}

mi Dmin sería la diferencia entre los números con menor distancia entre ellos, en este caso,

Dmin1 = 5-3 = 2;

Dmin2 = 18-16 = 2;

Dmin3 44-42 = 2;

Sin repetir el índice del número de la matriz. He hecho este código, pero tengo dificultades para encontrar lo que busco.

Marco R. :

Lo ideal sería que la manipulación de los datos que se agrupan lógicamente, debería distancia abstracta una clase para encapsular. En el caso de que quiera hacer un seguimiento de cada posible distancecombinación. Cada uno Combinationdebe llevar un registro de:

1. Los índices de los valores.
2. Valores en sí.
3. Distancia.
4. ¿Cuál es baja y cuál es alta.

Fuera de estos 3. y 4. se puede calcular a partir de 1. y 2.

    class Combination {
        int indexA, indexB, valueA, valueB;

        public Combination(int[] array, int indexA, int indexB) {
            this.indexA = indexA;
            this.indexB = indexB;
            this.valueA = array[indexA];
            this.valueB = array[indexB];
        }

        public int getDistance() { ... }
        public int getHigh() { ... }
        public int getLow() { ... }
        public int getHighIndex() { ... }
        public int getLowIndex() { ... }
    }

Con tal estructura de datos (clase) disponible, se puede construir objetos para cada una de las posibles combinaciones (sin repeticiones de curso - prestar atención cómo jse inicia de forma variable en el i + 1que no se repita combinaciones posibles):

        List<Combination> combinations = new ArrayList<>();
        for (int i = 0; i < array.length; i++) 
            for (int j = i + 1; j < array.length; j++) 
                combinations.add(new Combination(array, i, j));

Luego, utilizando esta Listde Combinationque puede calcular la distancia mínima entre todos ellos:

        int min = combinations.stream()
                .mapToInt(Combination::getDistance)
                .min().getAsInt();

Y, por último, puede seleccionar aquellas combinaciones que responden a la distancia mínima calculada previamente:

        combinations.stream()
            .filter(c -> c.getDistance() == min)
            .forEach(c -> System.out.println(c));

La clave es tener la Combinationclase abstraído en su propia clase encapsulado, lo que puede ser el único responsable de proporcionar las API necesarias para inspeccionar una combinación particular: índices, valores, distancias, de alto valor, valor bajo e incluso String( toStringrepresentaciones).

La siguiente es una demostración completa de trabajo de este enfoque, ejecutarlo para tener una idea de que:

import java.util.ArrayList;
import java.util.List;

public class MinimumDistance {

    public static void main(String[] args) {
        printMinimums(5, 50, 3, 42, 18, 16, 8, 30, 44);
    }

    public static void printMinimums(int... array) {
        List<Combination> combinations = new ArrayList<>();
        for (int i = 0; i < array.length; i++) 
            for (int j = i + 1; j < array.length; j++) 
                combinations.add(new Combination(array, i, j));

        int min = combinations.stream()
                .mapToInt(Combination::getDistance)
                .min().getAsInt();

        combinations.stream()
            .filter(c -> c.getDistance() == min)
            .forEach(c -> System.out.println(c));
    }

    static class Combination {
        int indexA, indexB, valueA, valueB;

        public Combination(int[] array, int indexA, int indexB) {
            this.indexA = indexA;
            this.indexB = indexB;
            this.valueA = array[indexA];
            this.valueB = array[indexB];
        }

        public int getDistance() {
            return getHigh() - getLow();
        }

        public boolean isValueAHigh() {
            return valueA > valueB;
        }

        public int getHigh() {
            return isValueAHigh() ? valueA : valueB; 
        }

        public int getLow() {
            return isValueAHigh() ? valueB : valueA; 
        }

        public int getHighIndex() {
            return isValueAHigh() ? indexA : indexB; 
        }

        public int getLowIndex() {
            return isValueAHigh() ? indexB : indexA; 
        }

        public String toString() {
            return String.format("%d[%d] - %d[%d] = %d", 
                                    getHigh(), getHighIndex(), 
                                    getLow(), getLowIndex(), 
                                    getDistance());
        }
    }
}

código completo en GitHub

Espero que esto ayude.