Question

我要做的是在两侧获得1到20之间的直角三角形的数量。

大多数逻辑都很好，但是当我想检查3,4和5时，这是一个三角形，而4,3和5不是有效的，因为它以不同的顺序分别为3,4,5。 / p>

以下是我为问题区域编写的代码

public bool isAlreadyValidTriangle(int intAdj, int intOpp, List<Triangle> triangleList)
{
    bool breakLoop = false;
    Int32 length = triangleList.Count;
    for (int index = 0; index < length && 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;
}

万一有人需要Triangle代码，这里是

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; }
    }
}

有没有一个地方能看到我在逻辑中犯了错误或在代码本身出错了？基思

Answer 1

你可以这样简化这个：

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

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

}

它首先查找传入值匹配的任何匹配项，如果不匹配则反转搜索。它与您的代码略有不同，因为它在同一时间查找相邻和相反的位置，这是您出错的地方。此外，它使用Any，如果找到匹配的任何项，则返回布尔值。

进一步考虑这个问题，我会更改函数，使其成为这样的扩展方法：

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

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

}

这意味着你可以用更多的可读性来调用它：

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

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

Answer 2

首先感谢您的建议和帮助。

以下是从头到尾的完整代码

    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 && t.IntOpposite == intOpp))
            return true;

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

再次感谢您的支持

C＃将List对象与传递的参数进行比较

2 个答案: