C# 等级宽恕函数中的条件函数

在这段代码中，我认为我几乎正确地使用了它，但它没有按照我需要的方式进行计算。 代码应忽略第一个等级，仅当单个等级的第二个等级较高时

这是我为它构造的代码，但当我运行程序时，它总是计算二级，而不考虑其值

double ComputeGPA()
    {
        if (Count == 0) return 0;
        bool bForgiven = false;
        int nCourseCount = 0;
        int i;
        double gpa = 0.0;
        double gpaToAdd;
        for (i = 0; i < this.Count; i++)
        {
            gpaToAdd = 0.0; 
            Course c = this[i]; 
            gpaToAdd = GradePoints(c.Grade);
            if (c.Grade == null || c.Grade == "W") continue;
            if (bForgiven == false)
            {
                int nRep = FindCourse(c.Number, i + 1);
                if (nRep > 0)
                {
                    Course x = this[i + 1];
                    if(GradePoints(this[nRep].Grade > GradePoints(c.Grade)))
                        gpaToAdd = GradePoints(x.Grade); 
                    // This means we forgive only one grade
                    bForgiven = true;
                    continue;
                }
            }
        gpa = gpa + GradePoints(c.Grade);
        nCourseCount++;
    }
    //If we've forgiven a grade , we divide by one less course
    gpa = (nCourseCount > 0) ? gpa / nCourseCount : 0.0;
    return gpa;
}

这些是每个字母对应的值：

 public static double GradePoints(string grade)
    {
        switch (grade)
        {
            case "A":
            case "A+":
                return 4.0;
            case "A-":
                return 3.7;
            case "B+":
                return 3.3;
            case "B":
                return 3.0;
            case "B-":
                return 3.7;
            case "C+":
                return 2.3;
            case "C":
                return 2.0;
            case "C-":
                return 1.7;
            case "D+":
                return 1.3;
            case "D":
                return 1.0;
            case "D-":
            default:
                return 0.0;
        }
    }

---

看起来像是流量控制问题。请参阅我在

continue

语句中的注释：

for (i = 0; i < this.Count; i++)
    {
        gpaToAdd = 0.0; 
        Course c = this[i]; 
        gpaToAdd = GradePoints(c.Grade);
        if (c.Grade == null || c.Grade == "W") continue;
        if (bForgiven == false)
        {
            int nRep = FindCourse(c.Number, i + 1);
            if (nRep > 0)
            {
                Course x = this[i + 1];
                if(GradePoints(this[nRep].Grade > GradePoints(c.Grade)))
                    gpaToAdd = GradePoints(x.Grade); 
                // This means we forgive only one grade
                bForgiven = true;

                // This will restart the for loop at the next item, 
                // presumably skipping whatever code you left out
                // below
                continue; 
            }
        }

    // Something else is going on down here that you didnt show us-
    // my guess is something like:
    gpa = gpaToAdd + gpa;
    // but it is getting skipped when a grade is forgiven

for（i=0；i0）
{
课程x=本[i+1]；
如果（成绩点（此[nRep].Grade>GradePoints（c.Grade）））
gpaToAdd=成绩点（x.Grade）；
//这意味着我们只原谅一个等级
b原=真；
//这将在下一项中重新启动for循环，
//可能会跳过您遗漏的任何代码
//下面
继续；
}
}
//这里还发生了一些你没有告诉我们的事情-
//我猜是这样的：
gpa=gpaToAdd+gpa；
//但当分数被原谅时，它就被跳过了

---

此处记录了Continue:

看起来像是流量控制问题。请参阅我在

Continue

语句中的注释：

for (i = 0; i < this.Count; i++)
    {
        gpaToAdd = 0.0; 
        Course c = this[i]; 
        gpaToAdd = GradePoints(c.Grade);
        if (c.Grade == null || c.Grade == "W") continue;
        if (bForgiven == false)
        {
            int nRep = FindCourse(c.Number, i + 1);
            if (nRep > 0)
            {
                Course x = this[i + 1];
                if(GradePoints(this[nRep].Grade > GradePoints(c.Grade)))
                    gpaToAdd = GradePoints(x.Grade); 
                // This means we forgive only one grade
                bForgiven = true;

                // This will restart the for loop at the next item, 
                // presumably skipping whatever code you left out
                // below
                continue; 
            }
        }

    // Something else is going on down here that you didnt show us-
    // my guess is something like:
    gpa = gpaToAdd + gpa;
    // but it is getting skipped when a grade is forgiven

for（i=0；i0）
{
课程x=本[i+1]；
如果（成绩点（此[nRep].Grade>GradePoints（c.Grade）））
gpaToAdd=成绩点（x.Grade）；
//这意味着我们只原谅一个等级
b原=真；
//这将在下一项中重新启动for循环，
//可能会跳过您遗漏的任何代码
//下面
继续；
}
}
//这里还发生了一些你没有告诉我们的事情-
//我猜是这样的：
gpa=gpaToAdd+gpa；
//但当分数被原谅时，它就被跳过了

---

这里记录了Continue:

除了Chris Shain的评论之外，我觉得这部分很奇怪：

 Course x = this[i + 1];
 if(GradePoints(this[nRep].Grade > GradePoints(c.Grade)))
   gpaToAdd = GradePoints(x.Grade); 

---

为什么我在这里+1？这不是列表中的下一个吗，不一定是同一个课程号吗？gpaToAdd不是应该是更好的成绩吗（这[nRep].grade）？

除了Chris Shain的评论，这部分对我来说很奇怪：

 Course x = this[i + 1];
 if(GradePoints(this[nRep].Grade > GradePoints(c.Grade)))
   gpaToAdd = GradePoints(x.Grade); 

---

为什么这里是i+1？这不就是列表中的下一个吗？不一定是同一个课程号吗？gpaToAdd不应该是更好的成绩吗（这[nRep].grade）？

有两个问题导致了错误的计算

1） 正如其他人提到的，continue语句是一个问题。这里的问题是，当您跳过该项时，您只希望它继续（并设置bForgiven）。换句话说，它需要包含在if语句中，如下所示：

if (GradePoints(trans[nRep].Grade) > GradePoints(c.Grade))
{
    gpaToAdd = GradePoints(x.Grade);
    // This means we forgive only one grade
    bForgiven = true;
    continue;
}

2） 你在用这句台词循环“这个”

for (i = 0; i < this.Count; i++)

问题是，您正在查找一个更晚的（列表中）编号，并且从不与较早的记录进行比较，因此当它找到第一个“3113”（记录0）时，它会查找并与第二个（记录3）进行比较，但当它找到记录3时，它永远不会找到第一个，因为它从记录4开始搜索

修复方法是FindCourse从开始到当前进行搜索，因此在您的示例中，它会触发记录3的命中，而不是像这样的记录0

public int FindCourse(int Number, int nCurrent)
{
    int i;
    for (i = 0; i < nCurrent; i++)
    {
        Course c = this[i];
        if (c.Number == Number) return i;
    }
    return -1; // Signifies no course was found
}

int nRep = FindCourse(c.Number, i);

---

有两个问题导致错误计算的发生

1） 正如其他人提到的，continue语句是一个问题。这里的问题是，当您跳过该项时，您只希望它继续（并设置bForgiven）。换句话说，它需要包含在if语句中，如下所示：

if (GradePoints(trans[nRep].Grade) > GradePoints(c.Grade))
{
    gpaToAdd = GradePoints(x.Grade);
    // This means we forgive only one grade
    bForgiven = true;
    continue;
}

2） 你在用这句台词循环“这个”

for (i = 0; i < this.Count; i++)

问题是，您正在查找一个更晚的（列表中）编号，并且从不与较早的记录进行比较，因此当它找到第一个“3113”（记录0）时，它会查找并与第二个（记录3）进行比较，但当它找到记录3时，它永远不会找到第一个，因为它从记录4开始搜索

修复方法是FindCourse从开始到当前进行搜索，因此在您的示例中，它会触发记录3的命中，而不是像这样的记录0

public int FindCourse(int Number, int nCurrent)
{
    int i;
    for (i = 0; i < nCurrent; i++)
    {
        Course c = this[i];
        if (c.Number == Number) return i;
    }
    return -1; // Signifies no course was found
}

int nRep = FindCourse(c.Number, i);

---

你能给出示例输入和预期输出吗？我想这会让你的问题更清楚。不幸的是，我无法理解你的问题。你能改革一下吗？我想做一个条件函数，它将用二级值覆盖一级值，但前提是它更高并且只覆盖一次。你能给出示例吗输入，以及预期的输出？我想这会让你的问题更清楚。不幸的是，我无法理解你的问题。你能改革它吗？我想做一个条件函数，它将用二级值覆盖一级值，但前提是它更高并且只覆盖一次。好的-但你知道这将是跳过当一个等级被原谅时会被忽略，对吗？对不起，我对这一点很陌生。没问题。尝试使用调试器在方法的开头创建一个断点，然后逐步执行。你会看到执行从continue行返回到for循环的开头。好吧-但是你意识到当等级被原谅时会跳过它，对吗嗯，我对t真的很陌生