Генерация 8 пар целых чисел

Question

Я хочу иметь 8 пар целых чисел, так что все они имеют разные координаты, и все они находятся в пределах 5 единиц друг от друга (используя евклидово расстояние).

Чтобы уточнить, я хочу иметь

(x1, y1)

(x2, y2)

(x3, y3)

(x4, y4)

(x5, y5)

(x6, y6)

(x7, y7)

(x8, y8)

, где xi и yi являются случайно сгенерированными целыми числами (через nextInt), так что нет индексов i, j, таких как xi = xj и yi = yj и такой, что для всех индексов i, j sqrt( (xi - xj)^2 + (yi - yj)^2 ) <= 5.

Я попытался сгенерировать первую пару с помощью nextInt, а затем с помощью 7 сложных циклов while выбрать 7 других пар, новычисление занимает слишком много времени:

    int r_x = generateur.nextInt(2*n + 1) - n;
    int r_y = generateur.nextInt(2*n + 1) - n;
    int p_x = generateur.nextInt(2*n + 1) - n;
    int p_y = generateur.nextInt(2*n + 1) - n;
    int b1_x = generateur.nextInt(2*n + 1) - n;
    int b1_y = generateur.nextInt(2*n + 1) - n;
    int b2_x = generateur.nextInt(2*n + 1) - n;
    int b2_y = generateur.nextInt(2*n + 1) - n;
    int g1_x = generateur.nextInt(2*n + 1) - n;
    int g1_y = generateur.nextInt(2*n + 1) - n;
    int g2_x = generateur.nextInt(2*n + 1) - n;
    int g2_y = generateur.nextInt(2*n + 1) - n;
    int m_x = generateur.nextInt(2*n + 1) - n;
    int m_y = generateur.nextInt(2*n + 1) - n;
    int w_x = generateur.nextInt(2*n + 1) - n;
    int w_y = generateur.nextInt(2*n + 1) - n;

    Point2D pt_r = new Point2D(r_x, r_y);
    Point2D pt_p = new Point2D(p_x, p_y);
    Point2D pt_b1 = new Point2D(b1_x, b2_y);
    Point2D pt_b2 = new Point2D(b2_x, b2_y);
    Point2D pt_g1 = new Point2D(g1_x, g1_y);
    Point2D pt_g2 = new Point2D(g2_x, g2_y);
    Point2D pt_m = new Point2D(m_x, m_y);
    Point2D pt_w = new Point2D(w_x, w_y);



    boolean r_p = false;
    boolean r_p_b1 = false;
    boolean r_p_b1_b2 = false;
    boolean r_p_b1_b2_g1 = false;
    boolean r_p_b1_b2_g1_g2 = false;        
    boolean r_p_b1_b2_g1_g2_m = false;
    boolean r_p_b1_b2_g1_g2_m_w = false;

    while(!r_p_b1_b2_g1_g2_m_w){
        while(!r_p_b1_b2_g1_g2_m){
            while(!r_p_b1_b2_g1_g2){
                while(!r_p_b1_b2_g1){
                    while(!r_p_b1_b2){
                        while(!r_p_b1){
                            while(!r_p){

                                p_x = generateur.nextInt(n + 1) - n/2;
                                p_y = generateur.nextInt(n + 1) - n/2;

                                r_p = pt_r.test(p_x, p_y);


                            }

                            pt_p = new Point2D(p_x, p_y);
                            this.peon.setPos(pt_p);

                            b1_x = generateur.nextInt(n/2 + 1) - n/4;
                            b1_y = generateur.nextInt(n/2 + 1) - n/4;

                            r_p_b1 = (pt_r.test(b1_x, b1_y) && pt_p.test(b1_x, b1_y));

                        }

                        pt_b1 = new Point2D(b1_x, b1_y);
                        this.bugs1.setPos(pt_b1);

                        b2_x = generateur.nextInt(n/4 + 1) - n/8;
                        b2_y = generateur.nextInt(n/4 + 1) - n/8;

                        r_p_b1_b2 = (pt_r.test(b2_x, b2_y) && pt_p.test(b2_x, b2_y) && pt_b1.test(b2_x, b2_y));
                    }

                    pt_b2 = new Point2D(b2_x, b2_y);
                    this.bugs2.setPos(pt_b2);

                    g1_x = generateur.nextInt(n/8 + 1) - n/16;
                    g1_y = generateur.nextInt(n/8 + 1) - n/16;

                    r_p_b1_b2_g1 = (pt_r.test(g1_x, g1_y) && pt_p.test(g1_x, g1_y) && pt_b1.test(g1_x, g1_y) && pt_b2.test(g1_x, g1_y));
                }

                pt_g1 = new Point2D(g1_x, g1_y);
                this.guillaumeT.setPos(pt_g1);

                g2_x = generateur.nextInt(n/16 + 1) - n/32;
                g2_y = generateur.nextInt(n/16 + 1) - n/32;

                r_p_b1_b2_g1_g2 = (pt_r.test(g2_x, g2_y) && pt_p.test(g2_x, g2_y) && pt_b1.test(g2_x, g2_y) && pt_b2.test(g2_x, g2_y) && pt_g1.test(g2_x, g2_y));
            }

            pt_g2 = new Point2D(g2_x, g2_y);
            this.grosBill.setPos(pt_g2);

            m_x = generateur.nextInt(n/32 + 1) - n/64;
            m_y = generateur.nextInt(n/32 + 1) - n/64;

            r_p_b1_b2_g1_g2_m = (pt_r.test(m_x, m_y) && pt_p.test(m_x, m_y) && pt_b1.test(m_x, m_y) && pt_b2.test(m_x, m_y) && pt_g1.test(m_x, m_y)
                                 && pt_g2.test(m_x, m_y));
        }

        pt_m = new Point2D(m_x, m_y);
        this.merlin.setPos(pt_m);

        w_x = generateur.nextInt(n/64 + 1) - n/128;
        w_y = generateur.nextInt(n/64 + 1) - n/128;

        r_p_b1_b2_g1_g2_m_w = (pt_r.test(w_x, w_y) && pt_p.test(w_x, w_y) && pt_b1.test(w_x, w_y) && pt_b2.test(w_x, w_y) && pt_g1.test(w_x, w_y)
                                 && pt_g2.test(w_x, w_y) && pt_w.test(w_x, w_y));
    }

    pt_w = new Point2D(w_x, w_y);
    this.wolfie.setPos(pt_w);

, где n - степень 2

Answer 1

Простой подход к алгоритму проб и ошибок:

1. Произвольно определить вектор первой позиции.
2. Произвольно определить оставшиеся семь векторов положения в окрестности первого вектора положения ± 5 единиц в направлении x и y.
3. После определения вектора положения и до определения следующего вектора положенияпроверьте, что вектор положения полностью удовлетворяет условиям относительно уже существующих векторов положения.Если условия не выполняются, отбрасывают вектор положения и случайным образом определяют новый, пока все условия не будут выполнены.

Векторы положения определяются в:

private void determinePositionVectors() {
    positionVector[0] = getFirstPositionVector();                       // 1.
    for (int i = 1; i < positionVector.length; i++) {
        if (positionVector[i] == null) {
            positionVector[i] = getRemainingPositionVectors();          // 2.
            while(!checkConditions(i)) {                                // 3.
                positionVector[i] = getRemainingPositionVectors();
            }
        }
    }
}

с помощью

private Point2D getFirstPositionVector() {
    int n1 = random.nextInt(2 * MAXIMUM_POSITION_FIRST_POSITIONVECTOR + 1) - MAXIMUM_POSITION_FIRST_POSITIONVECTOR;
    int n2 = random.nextInt(2 * MAXIMUM_POSITION_FIRST_POSITIONVECTOR + 1) - MAXIMUM_POSITION_FIRST_POSITIONVECTOR;
    return new Point2D(n1, n2); 
}
private Point2D getRemainingPositionVectors() {
    int n1 = random.nextInt(2 * MAXIMUM_DISTANCE + 1) - MAXIMUM_DISTANCE;
    int n2 = random.nextInt(2 * MAXIMUM_DISTANCE + 1) - MAXIMUM_DISTANCE;
    Point2D p = positionVector[0].add(n1,n2);
    return p; 
}
private boolean checkConditions(int i) {
    for (int j = 0; j < i; j++) {
        double distance = positionVector[i].distance(positionVector[j]);
        boolean positionVectorsEquals = positionVector[j].equals(positionVector[i]);
        if (positionVectorsEquals || distance > MAXIMUM_DISTANCE) {
            return false;
        }
    }
    return true;
}

Используемые константы, поля и т. Д. Определяются как:

package application;

import java.util.Arrays;
import java.util.Random;
import javafx.geometry.Point2D;

public class RandomVectors {

    private final static int NUMBER_OF_POSITIONVECTORS = 8;
    private final static int MAXIMUM_DISTANCE = 5;
    private final static int MAXIMUM_POSITION_FIRST_POSITIONVECTOR = 10;

    private static Random random = new Random();
    private Point2D[] positionVector = new Point2D[NUMBER_OF_POSITIONVECTORS];

    public static void main(String[] args) {
        RandomVectors randomVectors = new RandomVectors();
        randomVectors.determinePositionVectors();
        Arrays.stream(randomVectors.positionVector).forEach(p->System.out.print("(" + p.getX() + "," + p.getY() + ") "));
    }

    private void determinePositionVectors() {...} 
    private Point2D getFirstPositionVector() {...}
    private Point2D getRemainingPositionVectors() {...}
    private boolean checkConditions(int i) {...}
}

Для некоторых параметров (например, небольших значений MAXIMUM_DISTANCE и больших значений NUMBER_OF_POSITIONVECTORS) проблема не имеет решения, поскольку существуютслишком много векторов положения на слишком маленьком пространстве.Это приводит к бесконечному циклу while в definePositionsVectors.Пока что не существует механизма, предотвращающего такой бесконечный цикл.Простой подход заключается в подсчете количества циклов while и остановке программы при превышении порогового значения.

Answer 2

Существует 25 пар координат от (0, 0) до (4, 4).Вы можете сразу удалить пять из них: (0, 0), (1, 1) и т. Д. С одинаковыми значениями x и y.Это оставляет 20 возможных значений.Из этих 20 только две находятся на расстоянии более 5 единиц: (0, 4) и (4, 0), которые находятся на расстоянии 32 (32) друг от друга.Если вы выберете одну из этих двух, вы не сможете выбрать другую.Кроме того, вы можете выбрать любой в данном диапазоне.