C# 在有偏差的三个变量之间平衡一个数字

我有一个问题，我也在寻找解决方案。我有三个变量A、B和C。我需要做的是根据第四个数字（输入）在三个变量之间平衡一个值100和一个偏差（我认为这是正确的词）

所以，在开始时，A是100，B和C是0。然后，随着输入的增加，A将减少，B将增加相同的值（因此A+B+C始终等于100）。然后，当B达到100时，增加输入将增加C，同时减少B。反过来也是如此，因此减少输入将使值从C>B>A移动

我希望我已经解释得足够清楚了

编辑：到目前为止，我的尝试是这样的，在本例中，A、B和C是vCam.m_权重0、vCam.m_权重1、vCam.m_权重2

我的问题是，我在切换activeCam时绊倒了，所以下一个会立即跳到100。我相信这是一个糟糕的代码，但我正在努力想另一种方法

//Input is clamped between 0 - 100
private void HandleCameraSwitching(float newWeight)
{
    if (activeCam == 0)
    {
        vCam.m_Weight1 = newWeight;
        vCam.m_Weight0 = 100 - newWeight;
    }
    else if (activeCam == 1)
    {
        vCam.m_Weight2 = newWeight;
        vCam.m_Weight1 = 100 - newWeight;
    }
    else if (activeCam == 2)
    {
        vCam.m_Weight2 = newWeight;
        vCam.m_Weight1 = 100 - newWeight;

    }

    if (vCam.m_Weight0 == 100)
    { activeCam = 0; }
    else if (vCam.m_Weight1 == 100)
    {
        if (zoomingIn)
        {
            activeCam = 1;
        } else
        {
            activeCam = 0;
        }
    }
    else if(vCam.m_Weight2 == 100)
    {
        if (zoomingIn)
        {
            activeCam = 2;
        }
        else
        {
            activeCam = 1;
        }
    }
}

---

我认为您所解释的是您想要实现的特定场景。在编程术语中，这意味着构建一个模型来表示您的场景

假设一开始，A=100，B=0，C=0

然后定义更新函数。这就是你实现你提到的细节的地方

• a） 当a达到100并有输入时，开始从a删除并添加到B
• b） 当b达到100&有输入时，开始从b中删除并添加到C
• c） 当有一些输出时，从最后一个铲斗中取出并添加到上一个铲斗中

如果逻辑不正确，请澄清

对于update函数，假设Input（）看起来像

（伪代码）

我的逻辑是，如果任何一个bucket是100&您正在添加，那么从该bucket中删除并添加到下一个bucket。从逻辑上讲，我们可以推断，不应该存在a>0&b>0&c>0的情况，因此，如果100处没有值，您可以通过查看相邻的两个存储桶中哪些存储桶有值要传输，来确定哪两个存储桶需要传输

反转输出（）的逻辑（从c->b->a向后）

这可能不准确，我还没有测试或执行逻辑。如果（很可能）错误或不完整，请更正。这些是解决问题所必需的步骤，但不必从头开始构建整个模型

public class Camera
{
    public Camera()
    {
        zoomingIn = true;
        m_Weight0 = 100;
        m_Weight1 = 0;
        m_Weight2 = 0;
    }
    public bool zoomingIn { get; set; }
    public float m_Weight0 { get; set; }
    public float m_Weight1 { get; set; }
    public float m_Weight2 { get; set; }

    public void HandleCameraSwitching(float newWeight)
    {
        if (m_Weight0 == 100) zoomingIn = true;
        else if (m_Weight2 == 100) zoomingIn = false;

        if (zoomingIn)
        {
            if (m_Weight0 == 100 || (m_Weight0 > 0 && m_Weight1 > 0))
            {
                m_Weight0 = 100 - newWeight;
                m_Weight1 = newWeight;
            }
            else if (m_Weight1 == 100 || (m_Weight1 > 0 && m_Weight2 > 0))
            {
                m_Weight1 = 100 - newWeight;
                m_Weight2 = newWeight;
            }
        }
        else
        {
            if (m_Weight2 == 100 || (m_Weight2 > 0 && m_Weight1 > 0))
            {
                m_Weight2 = 100 - newWeight;
                m_Weight1 = newWeight;
            }
            else if (m_Weight1 == 100 || (m_Weight1 > 0 && m_Weight0 > 0))
            {
                m_Weight1 = 100 - newWeight;
                m_Weight0 = newWeight;
            }
        }
    }
}

---

bool放大

在A或C等于100时发生变化

如果我理解正确，在我看来，我们可以将这三个变量视为一个整体。似乎我们有一个最小值

100

，我们可以将最大值

200

添加到此值。为了更好地描述变量，下表显示了A、B和C的初始值，后跟用户输入，然后是添加输入后的值。最后一列显示了我们将要计算的“总”值（即100的起始值加上用户的输入）：

如果您查看上表，我们可以看到一种模式：

• 如果

  Total

  小于

  200

  ，则

  C

  为

  0

  ，

  B

  为

  Total-100

  ，

  A

  为

  100-B

• 如果

  Total

  大于或等于

  200

  ，则

  A

  为

  0

  ，

  C

  为

  Total-100

  ，

  B

  为

  100-C

• 我们可以通过测试

  A

  或

  C

  是否

  0

  来计算

  Total

  ，然后使用上面的公式来计算Total:

  如果（A==0）Total=200+C；其他合计=100+B

然后，我们可以简单地将此逻辑应用于接收输入值的方法中：

• 计算总数
• 添加输入值
• 根据新的总数设置三个变量

在代码中，这看起来像：

private static int A = 100;
private static int B;
private static int C;

private static void ProcessInput(int input)
{
    // Calculate current value new value
    var currentValue = C > 0 ? 200 + C : B > 0 ? 100 + B : 100;
    var newValue = currentValue + input;

    // We don't support values less than 100 or greater than 300
    if (newValue < 100 || newValue > 300) throw new ArgumentOutOfRangeException();

    C = newValue == 300 ? 100 : newValue < 200 ? 0 : newValue - 200;
    B = newValue == 200 ? 100 : newValue > 200 ? 100 - C : newValue - 100;
    A = newValue <= 200 ? 100 - B : 0;
}

输出

---

A、 B和C总是介于0和100之间，但它们的总和必须 始终为100，输入为0.1或-0.1–Ben

我在内部将值表示为0到1000之间的整数。要将它们公开为十进制数，请将其转换为double（或任何您想要的类型）并除以10。这将消除多次增加（）和/或减少（）时的舍入错误

下面是一个例子：

public partial class Form1 : Form
{

    public Form1()
    {
        InitializeComponent();
    }

    private CameraWeight cw = new CameraWeight();

    private void Form1_Load(object sender, EventArgs e)
    {
        label1.Text = cw.ToString();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        cw.Increase();
        label1.Text = cw.ToString();
    }

    private void button2_Click(object sender, EventArgs e)
    {
        cw.Decrease();
        label1.Text = cw.ToString();
    }

}

public class CameraWeight
{

    private int _m_Weight0 = 1000;
    private int _m_Weight1 = 0;
    private int _m_Weight2 = 0;

    public double m_Weight0
    {
        get { return (double)_m_Weight0/10; }
    }
    public double m_Weight1
    {
        get { return (double)_m_Weight1/10; }
    }
    public double m_Weight2
    {
        get { return (double)_m_Weight2/10; }
    }

    public void Increase()
    {
        if(_m_Weight0 > 0)
        {
            _m_Weight0 += -1;
            _m_Weight1 += 1;
        }
        else if (_m_Weight1 > 0.0)
        {
            _m_Weight1 += -1;
            _m_Weight2 += 1;
        }
    }

    public void Decrease()
    {
        if (_m_Weight2 > 0.0)
        {
            _m_Weight2 += -1;
            _m_Weight1 += 1;
        }
        else if (_m_Weight1 > 0.0)
        {
            _m_Weight1 += -1;
            _m_Weight0 += 1;
        }
    }

    public override string ToString()
    {
        return string.Format("{0}, {1}, {2}", m_Weight0.ToString("F1"), m_Weight1.ToString("F1"), m_Weight2.ToString("F1"));
    }

}

---

你能给出一组有几个给定输入的a、B和C的示例值吗？a、B和C将始终在0和100之间，但它们的总和必须始终为100，输入为0.1或-0。1@Ben你有什么问题？请编辑您的问题，包括您的源代码以及您的问题/挣扎。您的权利对不起。我试图概括，所以我不必解释不相关的东西。但我太笼统了。我发布的代码希望能澄清这一点。再一次，你的权利对不起，从0开始，而不是1。所以它是m_权重0，m_权重1，m_权重2

private static int A = 100;
private static int B;
private static int C;

private static void ProcessInput(int input)
{
    // Calculate current value new value
    var currentValue = C > 0 ? 200 + C : B > 0 ? 100 + B : 100;
    var newValue = currentValue + input;

    // We don't support values less than 100 or greater than 300
    if (newValue < 100 || newValue > 300) throw new ArgumentOutOfRangeException();

    C = newValue == 300 ? 100 : newValue < 200 ? 0 : newValue - 200;
    B = newValue == 200 ? 100 : newValue > 200 ? 100 - C : newValue - 100;
    A = newValue <= 200 ? 100 - B : 0;
}

private static void ShowValues()
{
    Console.WriteLine($"Current values: A = {A}, B = {B}, C = {C}.");
}

private static int GetIntFromUser(string prompt)
{
    int input;

    do
    {
        Console.Write(prompt);
    } while (!int.TryParse(Console.ReadLine(), out input));

    return input;
}

private static void Main(string[] args)
{
    while (true)
    {
        ShowValues();
        ProcessInput(GetIntFromUser("Input a value: "));
    }
}

public partial class Form1 : Form
{

    public Form1()
    {
        InitializeComponent();
    }

    private CameraWeight cw = new CameraWeight();

    private void Form1_Load(object sender, EventArgs e)
    {
        label1.Text = cw.ToString();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        cw.Increase();
        label1.Text = cw.ToString();
    }

    private void button2_Click(object sender, EventArgs e)
    {
        cw.Decrease();
        label1.Text = cw.ToString();
    }

}

public class CameraWeight
{

    private int _m_Weight0 = 1000;
    private int _m_Weight1 = 0;
    private int _m_Weight2 = 0;

    public double m_Weight0
    {
        get { return (double)_m_Weight0/10; }
    }
    public double m_Weight1
    {
        get { return (double)_m_Weight1/10; }
    }
    public double m_Weight2
    {
        get { return (double)_m_Weight2/10; }
    }

    public void Increase()
    {
        if(_m_Weight0 > 0)
        {
            _m_Weight0 += -1;
            _m_Weight1 += 1;
        }
        else if (_m_Weight1 > 0.0)
        {
            _m_Weight1 += -1;
            _m_Weight2 += 1;
        }
    }

    public void Decrease()
    {
        if (_m_Weight2 > 0.0)
        {
            _m_Weight2 += -1;
            _m_Weight1 += 1;
        }
        else if (_m_Weight1 > 0.0)
        {
            _m_Weight1 += -1;
            _m_Weight0 += 1;
        }
    }

    public override string ToString()
    {
        return string.Format("{0}, {1}, {2}", m_Weight0.ToString("F1"), m_Weight1.ToString("F1"), m_Weight2.ToString("F1"));
    }

}