Java for循环确定合法三角形

如果两条边的和大于第三条，三个数字构成一个合法的三角形。因此[7,3,6]和[8,8,8]有效，而[2,6,4]和[8,6,1]无效。我得到一个只有3个值的数组

public boolean isLegalTriangle(double[] lens){
  a = lens[0]
  b = lens[1]
  c = lens[2]

  return ( a+b > c && b+c > a && a+c > b )
}

这是我写的代码。可以用for循环重写这个吗？（对索引进行硬编码似乎很简单）

您可以对传入数组进行排序（使用-这将对数组进行适当排序），然后比较最大（第一个）项与第二个/第三个项的总和，避免在“if”语句中使用多个子句

不过，上面的内容似乎简洁易懂，我通常会赞成这样做。

您可以对传入数组进行排序（使用-这将对数组进行适当排序），然后比较最大（第一个）条目与第二个/第三个条目之和，避免使用“if”语句中的多个子句

---

然而，上面的内容似乎简洁易懂，我通常会赞成这样做。

您可以使用模来实现这一点：

public boolean isLegalTriangle(double[] lens){
    int l = lens.length;
    for (int i = 0 ; i < l; i++) {
        if ( lens[i%l] + lens[(i+1)%l] <= lens[(i+2)%l] ) {
            return false;
        }
    }
    return true;
}

public boolean isLegalTriangle（双[]镜头）{
int l=镜头长度；
对于（int i=0；i如果（lens[i%l]+lens[（i+1）%l]您可以使用模来实现这一点：

public boolean isLegalTriangle(double[] lens){
    int l = lens.length;
    for (int i = 0 ; i < l; i++) {
        if ( lens[i%l] + lens[(i+1)%l] <= lens[(i+2)%l] ) {
            return false;
        }
    }
    return true;
}

public boolean isLegalTriangle（双[]镜头）{
int l=镜头长度；
对于（int i=0；i如果（lens[i%l]+lens[（i+1）%l]将值相加。如果任何值大于或等于总和的一半，则它不是有效的三角形

public boolean isLegalTriangle(double[] lens){
  double max = (lens[0] + len[1] + lens[2]) * 0.5;

  return (lens[0] < max) && (lens[1] < max) && (lens[2] < max);
}

public boolean isLegalTriangle（双[]镜头）{
双最大值=（透镜[0]+透镜[1]+透镜[2]）*0.5；
返回（镜头[0]

使用for循环：

public boolean isLegalTriangle(double[] lens){
  double max = 0.0;
  for(int i = 0; i < 3; i++)
      max += lens[i];
  max *= 0.5;

  for(int i = 0; i < 3; i++)
      if(lens[i] >= max)
          return false;
  return true;
]

public boolean isLegalTriangle（双[]镜头）{
双最大值=0.0；
对于（int i=0；i<3；i++）
max+=镜头[i]；
最大值*=0.5；
对于（int i=0；i<3；i++）
如果（镜头[i]>=最大值）
返回false；
返回true；
]
将值相加。如果任何值大于或等于总和的一半，则该值不是有效的三角形

public boolean isLegalTriangle(double[] lens){
  double max = (lens[0] + len[1] + lens[2]) * 0.5;

  return (lens[0] < max) && (lens[1] < max) && (lens[2] < max);
}

public boolean isLegalTriangle（双[]镜头）{
双最大值=（透镜[0]+透镜[1]+透镜[2]）*0.5；
返回（镜头[0]

使用for循环：

public boolean isLegalTriangle(double[] lens){
  double max = 0.0;
  for(int i = 0; i < 3; i++)
      max += lens[i];
  max *= 0.5;

  for(int i = 0; i < 3; i++)
      if(lens[i] >= max)
          return false;
  return true;
]

public boolean isLegalTriangle（双[]镜头）{
双最大值=0.0；
对于（int i=0；i<3；i++）
max+=镜头[i]；
最大值*=0.5；
对于（int i=0；i<3；i++）
如果（镜头[i]>=最大值）
返回false；
返回true；
]
当然有可能..你被困在哪里了？为什么你认为你当前的解决方案很原始？这对我来说似乎是一个非常有效的解决方案，因为
n
既小又固定。如果给我一个数组，比如[4，-1,8,2,5,3]当我被要求计算使用这些数字可以生成多少个合法三角形时，我需要使用多个循环。因此，我正试图将我的代码发展到下一个级别。@BCronyn-这似乎是一个完全不同的要求和问题，与您上面提出的问题相比，尝试使用递归将提供简单的解决方案确保这是可能的。@BCronyn-这似乎是一个完全不同的要求和问题你卡住了吗？为什么你认为你当前的解决方案是原始的？考虑到
n
既小又固定，这似乎是一个完全有效的解决方案。如果给我一个数组，如[4，-1,8,2,5,3]当我被要求计算使用这些数字可以生成多少个合法三角形时，我需要使用多个循环。因此，我正在尝试将我的代码发展到下一个级别。@BCronyn-这似乎是一个与您上面所问完全不同的要求和问题尝试使用递归将提供简单的解决方案您的答案很聪明，而且非常简单回答了我的直接问题——我并不否认这一点。但是，如果给我一个由6个值组成的数组，并让我计算使用这些数字可以生成多少个合法三角形，那么你上面的代码只会测试3个接触值[I，I+1，I+2]。有没有办法测试所有的值？那么你需要这样的东西：
int count=0；for（int i=0；…）{for（int j=i+1；…）{for（int k=j+1；…）{if（isLegalTriangle（lens[i]，lens[j]，lens[k]）{System.out.println（count）；
where:
public boolean isLegalTriangle（double a，double b，double c）{return（a+b>c&&b+c>a&&a+c>b）}
但这可以作为一个不同的问题来问。我们希望我们的解决方案能帮助很多人。最好针对不同的问题提出不同的问题。你的答案很聪明，它回答了我的直接问题——我不否认这一点。但是，如果给我一个数组，比如说6个值，让我数一数有多少合法的tria可以使用这些数字生成NGLE，您上面的代码只需测试3个接触值[i，i+1，i+2]。是否有办法测试所有值？然后您需要这样的内容：
int count=0；for（int i=0；…）{for（int j=i+1；…）{for（int k=j+1；…）{if（isLegalTriangle（lens[i]，lens[j]，lens[k]）count++}}System.out.println（count）；
where:
public boolean isLegalTriangle（double a，double b，double c）{return（a+b>c&&b+c>a&&a+c>b）}
但是它可以作为一个不同的问题来问。我们希望我们的解决方案能帮助很多人。对于不同的问题，最好有不同的问题。