Question

我想借助附图中描述的系统计算数字之间的距离。

例如：7到5之间的距离是-2,7到1之间的距离是2等...

有关如何在c ++中执行此操作的任何想法？首选方向是逆时针方向...... 我正在使用（int）向量。

Answer 1

如果你以直截了当的方式（通过考虑所有可能性），它可能看起来如下

    [Serializable]
[DebuggerStepThrough]
[XmlType(AnonymousType = true)]
[XmlRoot(ElementName="kostentraeger_liste", Namespace = "urn:ehd/001", IsNullable = false)]
public class KostentraegerListe
{
    private List<Kostentraeger> _kostentraegerListe;

    [XmlElement("kostentraeger")]
    public List<Kostentraeger> Kostentraeger
    {
        get { return _kostentraegerListe ?? (_kostentraegerListe = new List<Kostentraeger>()); }
        set { _kostentraegerListe = value; }
    }
}

[SerializableAttribute]
[DebuggerStepThrough]
[XmlType(AnonymousType = true)]
public class Kostentraeger
{
    private string _kostentraegernummer = String.Empty;

    [XmlAttribute("V")]
    public string Kostentraegernummer
    {
        get { return _kostentraegernummer; }
        set { _kostentraegernummer = value; }
    }
}

如果您愿意，可以改写为

int distance(int a, int b)
{ // Distance from `a` to `b`
  int d = b - a;
  return
    a <= b ? 
      (d <= +4 ? d : d - 8) :
      (d <= -4 ? d + 8 : d);
}

另一种更优雅的方法是始终计算正CCW距离，如果它大于4，则将其翻转为负CW距离

int distance(int a, int b)
{ // Distance from `a` to `b`
  int d = b - a;
  return -4 < d && d <= 4 ? d : (d > 0 ? d - 8 : d + 8);
}

但是如果您希望编译器为此生成最有效的代码，请遵循黄金法则“在任何地方使用无符号类型，只有在必须时才使用签名类型”：

int distance(int a, int b)
{ // Distance from `a` to `b`
  int d = (b + 8 - a) % 8;
  // `d` is CCW distance from `a` to `b`
  return d <= 4 ? d : d - 8;
}

Answer 2

这些都是非常复杂的答案。这是一个更简单的一个：

int distance(int x, int y) {
    int d = (y - x) & 7;
    return d > 4 ? d - 8 : d;
}

这总是返回-3 .. + 4范围内的结果。当环大小为2的幂时，模块化算法更容易编写，就像这里的情况一样。

distance(7, 5) = -2
distance(5, 7) = +2
distance(6, 2) = +4
distance(2, 6) = +4

我们使用& 7因为它是获取模数的最简单方法。或者，您可以使用% 8，但您还必须添加8才能确保输入不是负数：

int d = (y - x + 8) % 8; // same result

或者，您可以明确处理负数：

int d = (y - x) % 8;
if (d < 0) {
    d += 8;
}
// same result

这只是风格问题。

Answer 3

为简单起见，您可以找到std::find中的元素，并从std::distance

开始获取距离例如，

正如您所提到的那样，保存在int vector

中

std::vector<int>::iterator it1 = std::find(myvec.begin(), myvec.end(), val_1);
std::vector<int>::iterator it2 = std::find(myvec.begin(), myvec.end(), val_2);

int dist = std::distance(myvec.begin(),it1) - std::distance(myvec.begin.it2);
if(dist < 0) return dist
else(dist > 0) return myvector.size() - dist()

所以希望这会给出距离作为图像......

Answer 4

我很确定这有效：

list = [0,1,2,3,4,5,6,7]
distance(x,y) {
    a = y-x
    b = length(list)-abs(y-x)
    z = min(abs(a), abs(b))
    if(z=abs(a)) { return a }
    if(z=abs(b)) { return b }
}

其中abs()是数学绝对值函数。

我在这里做了一些假设。

正如@HédiGhédiri指出的那样，两次都不是逆时针计数。我假设你计算到数字的最短路径。（我使用了数学min()函数）
您更喜欢正值而不是负值（@ Harper的评论）。如果您更喜欢负值，请切换最后两个if语句。

可能有一种更简洁的方法，但这（希望）有效。请评论是否错误。希望这有用！

编辑：这是伪造的。用c ++编写应该很容易。使用abs()中的<stdlib.h>功能忘记list和length(list)。对变量使用int类型，其他一切都应该有效。

Answer 5

以下代码已准备好满足您的所有需求，例如我假设，如果方向是顺时针方向，则距离为负。

#include <iostream>

#define RING_SIZE 8

enum direction
{
    clockwise,
    counterClockwise
};

int distance(int a, int b, direction dir)
{
    int dist;
    if(dir == clockwise)
    {
        if(a>b)
        {
            dist = -(a-b); 
        }
        else
        {
            dist =-(RING_SIZE-b+a); 
        }
    }
    else
    {
        if(a<b)
        {
            dist = b-a; 
        }
        else
        {
            dist = RING_SIZE-a+b; 
        }

    }
    if(a==b) dist = 0;//Add this if distance between same point must to be 0
    return dist;
}

int main()
{
  std::cout << distance(7, 2, clockwise) << std::endl;
}

Answer 6

我认为这应该有效

int func(a,b)
{
    dist=(b-a);
    if(dist<0) 
      dist +=8;
    return dist;

}

万一你真的被困了

如何计算c ++中数字之间的距离？

6 个答案: