Java 创建3对由+；6个对象，每对对象具有唯一的&；未重复的对象

我有一个可能的物体列表，长度可能是6个或更多（+6个光子/伽马），我需要从这个列表中创建3对（3个π介子）。这些对都需要有唯一的对象，并且一旦伽马在一对中就不能重复使用

例如，如果π介子1是由gamma1（代码为ig1）和gamma2（ig2）组成的，那么π介子2和π介子3必须由Gamma3、4、5、6等所有可能的组合组成（可能有6个以上的Gamma，但我只关心3个总π介子），等等

我尝试以下列方式执行几个for循环：

int n_g = 8; // n_g >= 6
boolean hasDVPi0P = false;
for (int ig1 = 0; ig1 < n_g-5 && !hasDVPi0P ; ig1++) {
    for (int ig2 = ig1+1; ig2 < n_g-4 && !hasDVPi0P ; ig2++) {
        for (int ig3 = ig2+1; ig3 < n_g-3 && !hasDVPi0P ; ig3++) {
            for (int ig4 = ig3+1; ig4 < n_g-2 && !hasDVPi0P ; ig4++) {
                for (int ig5 = ig4+1; ig5 < n_g-1 && !hasDVPi0P ; ig5++) {
                    for (int ig6 = ig5+1; ig6 < n_g && !hasDVPi0P ; ig6++) {
                        System.out.println("(" + ig1 + "," + ig2 + ") , (" + ig3 + "," + ig4 + ") , (" + ig5 + "," + ig6 + ")");
                        }
                    }
                }
        }
    }
}  

我最初认为这是正确的，直到我检查了n_g=6，这让我明白了

(0,1) , (2,3) , (4,5)

这显然是错误的输出。我试图通过以下方式找到6 gamma的所有唯一可能对：

n_g=6;
for(int ig1 = 0; ig1 < n_g-1; ig1++) {
    for(int ig2 = ig1+1; ig2 < n_g; ig2++) {
        System.out.print("(" + ig1 + "," + ig2 + ") ");
    }
    System.out.println("");
}

---

有没有人知道我如何编辑第一个代码段，用6个for循环得到3对π介子，如果一个gamma用于1个π介子，它就不再重复了？配对顺序确实很重要，这意味着如果配对是（0,1），那么配对（1,0）是不同的，不可互换的。

我建议将其分为两个步骤

查找所有元素对（顺序很重要）

查找对的所有组合（顺序无关紧要）

如果你想分析的话，我把一个示例程序放在一起

我做的第一件事是创建一个简单的

Pair

类来跟踪这些对，比较值并打印它们：

public class Pair {
  Integer one;
  Integer two;
  
  public Pair(Integer one, Integer two)
  {
    this.one = one;
    this.two = two;
  }
  
  public boolean hasNoMatchingValues(Pair other)
  {
    return !this.one.equals(other.one) && !this.one.equals(other.two) && !this.two.equals(other.one) && !this.two.equals(other.two);
  }
  
  public static boolean hasNoMatchingValues(Pair...values)
  {
    for(int i = 0; i < values.length - 1; i++)
    {
      for(int j = i + 1; j < values.length; j++)
      {
        if(!values[i].hasNoMatchingValues(values[j]))
          return false;
      }
    }
    return true;
  }
  
  @Override
  public String toString()
  {
    return "(" + one + ", " + two + ")";
  }
}

公共类对{
整数一；
整数二；
公共对（整数1、整数2）
{
这个1=1；
这个2=2；
}
公共布尔值hasnatchingvalue（对其他）
{
return！this.one.equals（other.one）&！this.one.equals（other.two）&！this.two.equals（other.one）&！this.two.equals（other.two）；
}
公共静态布尔值hasnatchingvalue（对…值）
{
对于（int i=0；i

在此之后，我使用以下代码查找所有对，然后将它们匹配到3的组合中：

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

public class PairCombinations
{
  public static void main(String[] args)
  {
    //Builds the list of unique objects
    List<Integer> objectList = new ArrayList<>();
    for(int i = 0; i < 8; i++)
      objectList.add(i);

    //Finds all pairs and adds them to pairsList
    List<Pair> pairsList = new ArrayList<>();
    for(int i = 0; i < objectList.size() - 1; i++)
    {
      for(int j = i + 1; j < objectList.size(); j++)
      {
        pairsList.add(new Pair(objectList.get(i), objectList.get(j)));
        pairsList.add(new Pair(objectList.get(j), objectList.get(i)));
      }
    }
    
    //Loop three times since you want three combinations. Can be adjusted to a recursive form.
    List<List<Pair>> allCombos = new ArrayList<>();
    for(int i = 0; i < pairsList.size() - 2; i++)
    {
      for(int j = i + 1; j < pairsList.size() - 1; j++)
      {
        for(int k = j + 1; k < pairsList.size(); k++)
        {
          Pair one = pairsList.get(i), two = pairsList.get(j), three = pairsList.get(k);
          if(Pair.hasNoMatchingValues(one, two, three))
          {
            List<Pair> combos = new ArrayList<>();
            combos.add(one);
            combos.add(two);
            combos.add(three);
            allCombos.add(combos);
          }
        }
      }
    }
    
    //Print the results
    for(List<Pair> combo : allCombos)
      System.out.println(combo);
  }
}

import java.util.ArrayList；
导入java.util.List；
公共类成对组合
{
公共静态void main（字符串[]args）
{
//生成唯一对象的列表
List objectList=new ArrayList（）；
对于（int i=0；i<8；i++）
对象列表。添加（i）；
//查找所有对并将它们添加到pairsList
List pairsList=new ArrayList（）；
对于（int i=0；i

---

如果您有任何问题，请告诉我。

以防有人希望看到具有嵌套for循环的版本，以及认为（0,1）与（1,0）相同的版本。这是一个比这两个类的答案稍微简单的版本，我认为如果有人来寻找一种以稍微不同的方式配对的方法，他们可能会受益

int n_g = 6;
boolean hasDVPi0P = false;
for (int ig1 = 0; ig1 < n_g && !hasDVPi0P ; ig1++) {
    for (int ig2 = 0; ig2 < n_g && !hasDVPi0P ; ig2++) {
        for (int ig3 = 0; ig3 < n_g && !hasDVPi0P ; ig3++) {
            for (int ig4 = 0; ig4 < n_g && !hasDVPi0P ; ig4++) {
                for (int ig5 = 0; ig5 < n_g && !hasDVPi0P ; ig5++) {
                    for (int ig6 = 0; ig6 < n_g && !hasDVPi0P ; ig6++) {
                        if( true
                            && ig1<ig2 && ig3<ig4 && ig5<ig6 // different photons in each pair
                            && ig1<ig3 && ig1<ig5 && ig3<ig5 // unique first photon from each pair
                            && ig2!=ig3 && ig2!=ig4 && ig2!=ig5 && ig2!=ig6 // clean up rest of pairs below
                            && ig3!=ig4 && ig3!=ig5 && ig3!=ig6
                            && ig4!=ig5 && ig4!=ig6
                            ){
                            System.out.println("(" + ig1 + "," + ig2 + ") , (" + ig3 + "," + ig4 + ") , (" + ig5 + "," + ig6 + ")\n");
                        }
                    }
                }
            }
        }
    }
}

int n_g=6；
布尔hasDVPi0P=false；
对于（intig1=0；ig1&&ig1I运行了i<6的配对组合以进行快速检查，在输出中，我看到pair1总是有一个gamma0与其他的组合[（0,1），（1,0），（0,2），（2,0），等等]。然而，pair1也可能是（3,6），例如，或具有任何不包含第0个的Gamma组合。我还检查了I<8，它与0有相同的问题，但也存在gamma1和2。此方法肯定会获得比我更多的组合，但不是所有组合。@Illari如果
I@Tom Hunter，它肯定会始终包含第0个元素，关于第0个ob，您是对的杰特，我一直忘了循环是从公元前0年开始的，在我的笔记中我写下了gamma1-6，但我忘了…这是一个非常有趣的答案。你介意我问一下你在这背后的想法是什么吗？@Illari隔离顺序执行的过程步骤是我的主要想法。找出哪些步骤会改变数据，在下面了解数据在每个步骤结束时的外观，并组织每个流程在该步骤处理数据。更容易将数据视为每个变形步骤后的外观，并尝试在该状态下隔离处理，而不是考虑可能需要几个变形步骤才能达到的最终结果。您的场景这是一个很好的例子，可以将这些对抽象为
import java.util.ArrayList;
import java.util.List;

public class PairCombinations
{
  public static void main(String[] args)
  {
    //Builds the list of unique objects
    List<Integer> objectList = new ArrayList<>();
    for(int i = 0; i < 8; i++)
      objectList.add(i);

    //Finds all pairs and adds them to pairsList
    List<Pair> pairsList = new ArrayList<>();
    for(int i = 0; i < objectList.size() - 1; i++)
    {
      for(int j = i + 1; j < objectList.size(); j++)
      {
        pairsList.add(new Pair(objectList.get(i), objectList.get(j)));
        pairsList.add(new Pair(objectList.get(j), objectList.get(i)));
      }
    }
    
    //Loop three times since you want three combinations. Can be adjusted to a recursive form.
    List<List<Pair>> allCombos = new ArrayList<>();
    for(int i = 0; i < pairsList.size() - 2; i++)
    {
      for(int j = i + 1; j < pairsList.size() - 1; j++)
      {
        for(int k = j + 1; k < pairsList.size(); k++)
        {
          Pair one = pairsList.get(i), two = pairsList.get(j), three = pairsList.get(k);
          if(Pair.hasNoMatchingValues(one, two, three))
          {
            List<Pair> combos = new ArrayList<>();
            combos.add(one);
            combos.add(two);
            combos.add(three);
            allCombos.add(combos);
          }
        }
      }
    }
    
    //Print the results
    for(List<Pair> combo : allCombos)
      System.out.println(combo);
  }
}

int n_g = 6;
boolean hasDVPi0P = false;
for (int ig1 = 0; ig1 < n_g && !hasDVPi0P ; ig1++) {
    for (int ig2 = 0; ig2 < n_g && !hasDVPi0P ; ig2++) {
        for (int ig3 = 0; ig3 < n_g && !hasDVPi0P ; ig3++) {
            for (int ig4 = 0; ig4 < n_g && !hasDVPi0P ; ig4++) {
                for (int ig5 = 0; ig5 < n_g && !hasDVPi0P ; ig5++) {
                    for (int ig6 = 0; ig6 < n_g && !hasDVPi0P ; ig6++) {
                        if( true
                            && ig1<ig2 && ig3<ig4 && ig5<ig6 // different photons in each pair
                            && ig1<ig3 && ig1<ig5 && ig3<ig5 // unique first photon from each pair
                            && ig2!=ig3 && ig2!=ig4 && ig2!=ig5 && ig2!=ig6 // clean up rest of pairs below
                            && ig3!=ig4 && ig3!=ig5 && ig3!=ig6
                            && ig4!=ig5 && ig4!=ig6
                            ){
                            System.out.println("(" + ig1 + "," + ig2 + ") , (" + ig3 + "," + ig4 + ") , (" + ig5 + "," + ig6 + ")\n");
                        }
                    }
                }
            }
        }
    }
}