如果> 2个差异，则数组循环和比较

Question

我正在尝试检查 c# 中的项目主列表与列表数组之间的区别。

不太确定如何以有效的方式构建此逻辑。

例子：

我的主清单是：var MasterOrderIDs = {1,2,3,4}

然后我有一个客户/订单对象，它存储客户 ID 及其订单 ID

CustomerID|OrderID
    1     |  1
    1     |  2
    1     |  3
    1     |  4
    1     |  5
    2     |  1
    2     |  2
    2     |  3
    2     |  4
    2     |  5
    2     |  6
    3     |  2
    3     |  3
    3     |  4

我想返回一个包含 CustomerID 和 OrderIDs 的数组，其中 MasterOrderIDs 的差异小于 2。

类似： var OrderDifferences = new Dictionary<int, List<int>>();

所以对于客户/订单，我想退货：

{[1, [5]], [3, [1]}

这是因为对于 CustomerID 1，有一个 Order ID 5，小于 2 个差值。与 CustomerID 3 类似，有一个 Order ID 1，它出现在 MasterOrderIDs 中，并且差异小于 2。

如何创建这样的支票？

在现实生活场景中，我将拥有大数据，因此想知道什么是最有效的方法。

Answer 1

根据我们得到的信息，我可以想到两个相对较小的优化。所以我的免责声明是，基本方法仍然是蛮力，也许有更聪明的方法来提取信息，但我们仍然可以执行一些检查以排除一些不必要的数据。

小优化1

我们正在寻找与订单主列表相比最多多一个或少一个订单的客户。换句话说，根据您的示例

var MasterOrderIDs = {1,2,3,4}

拥有 5 个订单的客户（如 customerOrders = { 7, 8, 9, 10, 11 }）仍然可能有效，但拥有 6 个订单的客户 customerOrders = { 7, 8, 9, 10, 11, 12 } 则无效。

底数也一样。拥有 3 个订单的客户也可能有效 customerOrders = { 7, 8, 9 }，但少于两个订单的客户 customerOrders = { 7, 8 } 则无效。

因此，基于此，我们可以执行我们的第一个小型优化归档客户，这些客户的订单超过 MasterOrderIDs.Count() + 2 或少于 MasterOrderIDs.Count() - 2

小优化2

即使我们在适当的订单范围内，我们也希望确保我们的 orderId 重叠。我们只能允许 1 个订单出现在其中一个列表中，而不出现在另一个列表中。基本上这并不完全是一种优化，但这是我们可以构建查询的第二个标准。

这是：

首先播种一些数据：

class Order
{
    public int CustomerId { get; set; }
    public int OrderId { get; set; }

    public static List<Order> Seed()
    {
        return new List<Order>
        {
            new Order { CustomerId = 1, OrderId = 1},
            new Order { CustomerId = 1, OrderId = 2},
            new Order { CustomerId = 1, OrderId = 3},
            new Order { CustomerId = 1, OrderId = 4},
            new Order { CustomerId = 1, OrderId = 5},
            new Order { CustomerId = 2, OrderId = 1},
            new Order { CustomerId = 2, OrderId = 2},
            new Order { CustomerId = 2, OrderId = 3},
            new Order { CustomerId = 2, OrderId = 4},
            new Order { CustomerId = 2, OrderId = 5},
            new Order { CustomerId = 2, OrderId = 6},
            new Order { CustomerId = 3, OrderId = 2},
            new Order { CustomerId = 3, OrderId = 3},
            new Order { CustomerId = 3, OrderId = 4}
        };
    }
}

然后设置初始数据：

var masterList = new List<int> { 1, 2, 3, 4 };
var upperBorder = masterList.Count() + 2;
var bottomBorder = masterList.Count() - 2;
var orders = Order.Seed();

最后提取我们需要的记录：

var ordersWithinRange = orders
                .GroupBy(o => o.CustomerId)
                .Where(x => x.Count() < upperBorder && x.Count() > bottomBorder && x.Select(o => o.OrderId).Except(masterList).Concat(masterList.Except(x.Select(o => o.OrderId))).Count() < 2)
                .ToDictionary(d => d.Key, d => d.Select(o => o.OrderId).Except(masterList).Concat(masterList.Except(d.Select(o => o.OrderId))).ToList());

再次。这将花费大量计算时间，但我认为它比一系列 for 循环一次过滤一件事要快一些。