Блог

То, что я пытаюсь сделать, это получить количество прямоугольных треугольников от 1 до 20 с обеих сторон.

Большая часть логики в порядке, но когда я хочу проверить наличие 3, 4 и 5, это один треугольник, в то время как 4, 3 и 5 не будут действительными, поскольку это 3, 4, 5 в другом порядке.

Вот код, который я написал для проблемной области

 public bool isAlreadyValidTriangle(int intAdj, int intOpp, List<Triangle> triangleList)
{
    bool breakLoop = false;
    Int32 length = triangleList.Count;
    for (int index = 0; index < length amp;amp; breakLoop != false; index  )
    {
        //This is to compare an existing adjacent that is stored in the list to the
        //supplied opposite, this is to prebent the 3, 4, 5 and 4, 3, 5 issue
        var response = triangleList.Find(r => r.IntAdjacent == intOpp);

        if (response !=null)
        {
            //This is to compare an existing opposite that is stored in the list to the
            //supplied adjacent, this is to prebent the 3, 4, 5 and 4, 3, 5 issue
            var otherResponse = triangleList.Find(r => r.IntOpposite == intAdj);

            if (otherResponse != null)
            {
                breakLoop = true;
            }
        }
    }
    return breakLoop;
}
  

На всякий случай, если кому-то нужен код треугольника, вот он

 public class Triangle
{
    private int intAdjacent;
    private int intOpposite;
    private int intHypotenuse;

    public Triangle(int intAdjacent, int intOpposite, int intHypotenuse)
    {
        this.intAdjacent = intAdjacent;
        this.intOpposite = intOpposite;
        this.intHypotenuse = intHypotenuse;
    }

    public int IntAdjacent
    {
        get { return intAdjacent; }
    }

    public int IntOpposite
    {
        get { return intOpposite; }
    }

    public int IntHypotenuse
    {
        get { return intHypotenuse; }
    }
}
  

Может ли кто-нибудь увидеть, где я допускаю ошибку в логике или допустил ошибку в самом коде?
Кит

Вы можете значительно упростить это следующим образом:

 public bool isAlreadyValidTriangle(int intAdj, int intOpp, List<Triangle> triangleList)
{
    if(triangleList.Any(t => t.IntAdjacent == intAdj amp;amp; t.IntOpposite == intOpp))
        return true;

    return triangleList.Any(t => t.IntAdjacent == intOpp amp;amp; t.IntOpposite == intAdj);

}
  

Сначала он ищет любые совпадения, в которых переданные значения совпадают, затем отменяет поиск, если они не совпадают. Это немного отличается от вашего кода тем, что он одновременно ищет как смежные, так и противоположные объекты, в чем вы ошиблись. Кроме того, он использует Any , который возвращает логическое значение, если найден какой-либо элемент, который соответствует.

Думая об этом дальше, я бы изменил функцию, чтобы сделать ее методом расширения, подобным этому:

 public static bool isAlreadyValidTriangle(this List<Triangle> triangleList, int intAdj, int intOpp)
{
    if(triangleList.Any(t => t.IntAdjacent == intAdj amp;amp; t.IntOpposite == intOpp))
        return true;

    return triangleList.Any(t => t.IntAdjacent == intOpp amp;amp; t.IntOpposite == intAdj);

}
  

Это означает, что вы можете вызвать его с немного большей удобочитаемостью:

 List<Triangle> triangleList = new List<Triangle>();
... fill list with triangles ...

if(triangleList.isAlreadyValidTriangle(adjacent, opposite)
{
    ...
}
  

Прежде всего, спасибо за совет и помощь.

Вот полный код от начала до конца

     using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Collections;

    namespace ConsoleApplication1
    {
    public class Program
    {
    private static double doubleHypotenuse = 0;
    private static int adjacent = 1;
    private static int opposite = 1;
    private static int limit = 200;
    private static int count = 0;

    public static void Main(string[] args)
    {

        TriangleLogic triLogic = new TriangleLogic();
        List<Triangle> triangleList = new List<Triangle>();
        List<Triangle> trianglePlus1 = new List<Triangle>();

        while (adjacent < limit)
        {
            opposite = 1;
            while (opposite < limit)
            {
                doubleHypotenuse = triLogic.intRightAngle(adjacent, opposite);
                if (doubleHypotenuse % 1 == 0)
                {
                    if (!triLogic.isAlreadyValidTriangle(adjacent, opposite, triangleList))
                    {
                        triangleList.Add(new Triangle(adjacent, opposite, (int)Convert.ToInt32(doubleHypotenuse)));
                    }

                    count  ;
                }
                opposite  ;
            }
            adjacent  ;
        }

        Console.WriteLine("The following are integer triangles");
        triangleList.ForEach(delegate(Triangle pytag)
        {
            if ((pytag.IntHypotenuse - pytag.IntOpposite) == 1)
            {
                trianglePlus1.Add(new Triangle(pytag.IntAdjacent, pytag.IntOpposite, pytag.IntHypotenuse));
            }
            Console.WriteLine(pytag.IntAdjacent   ", "   pytag.IntOpposite   " and "   pytag.IntHypotenuse);
        });

        Console.WriteLine("the number of squares is "   count);
        Int32 length = triangleList.Count;
        Console.WriteLine("the length of the list is "   length);

        Console.WriteLine("");
        Console.WriteLine("the List of triangles with the hypotenuse 1 ");
        Console.WriteLine("more than the opposite");

        trianglePlus1.ForEach(delegate(Triangle pytagPlus1)
        {
            Console.WriteLine(pytagPlus1.IntAdjacent   ", "   pytagPlus1.IntOpposite   " and "   pytagPlus1.IntHypotenuse);
        });


        Int32 lengthPlus1 = trianglePlus1.Count;
        Console.WriteLine("the length of the list is "   lengthPlus1);

    }
}
}
  

Вот класс Треугольника

     public class Triangle
    {
    private int intAdjacent;
    private int intOpposite;
    private int intHypotenuse;

    public Triangle(int intAdjacent, int intOpposite, int intHypotenuse)
    {
        this.intAdjacent = intAdjacent;
        this.intOpposite = intOpposite;
        this.intHypotenuse = intHypotenuse;
    }

    public int IntAdjacent
    {
        get { return intAdjacent; }
    }

    public int IntOpposite
    {
        get { return intOpposite; }
    }

    public int IntHypotenuse
    {
        get { return intHypotenuse; }
    }
}
  

И, наконец, класс TriangleLogic

     public class TriangleLogic
    {
    private double squareAdjacent = 0;
    private double squareOpposite = 0;
    private double squareSum = 0;

    public TriangleLogic()
    {

    }

    public double intRightAngle(int intAdjacent, int intOpposite)
    {
        squareAdjacent = Math.Pow(Convert.ToDouble(intAdjacent), 2);
        squareOpposite = Math.Pow(Convert.ToDouble(intOpposite), 2);
        squareSum = squareAdjacent   squareOpposite;
        return Math.Sqrt(squareSum);
    }

    public bool isAlreadyValidTriangle(int intAdj, int intOpp, List<Triangle> triangleList)
    {
        if (triangleList.Any(t => t.IntAdjacent == intAdj amp;amp; t.IntOpposite == intOpp))
            return true;

        return triangleList.Any(t => t.IntAdjacent == intOpp amp;amp; t.IntOpposite == intAdj);
    }
}
  

Еще раз спасибо за поддержку