标签: grouping

是否可以使用条件组子句编写LINQ语句？这基本上就是我要做的事情:

bool someFlag = false;

var result = from t in tableName
   group t by new { (someFlag ? 0 : t.FieldA), t.FieldB } into g
   select g;

所以基本上如果someFlag设置为true,我想只按FieldB分组,但如果它是假的,我想按FieldA和FieldB分组.

有没有办法添加列分组？例如:

   Unit 1    |    Unit 2    |
Pre Mid Post | Pre Mid Post |
--- --- ---- | --- --- ---- |
 2   4   5   |  3   4   4   |
 1   2   4   |  3   4   5   |

基本上,我需要一个Unit的标题行,它在Unit组中有三个子列; 前,中,后.

这个概念也可以在下面的图片中看到:

所以这很简单.我需要一种将细胞分组在一起的方法.像一个<div>或一个,<span>但没有一个工作.<tbody>似乎是一个很好的解决方案,但它只适用于表行.救命!

我有一个对象列表,如下所示:

[
  {
    "ip": "1.1.1.1",
    "component": "name1"
  },
  {
    "ip": "1.1.1.2",
    "component": "name1"
  },
  {
    "ip": "1.1.1.3",
    "component": "name2"
  },
  {
    "ip": "1.1.1.4",
    "component": "name2"
  }
]

现在,我想对组件进行分组和键入,并为每个组件分配一个ips列表:

{
  "name1": [
    "1.1.1.1",
    "1.1.1.2"
  ]
},{
  "name2": [
    "1.1.1.3",
    "1.1.1.4"
  ]
}

我有2,500,000个产品名称,我想尝试将它们组合在一起,即找到名称相似的产品.例如,我可以有三种产品:

• 亨氏焗豆400克;
• Hz Bkd Beans 400g;
• 亨氏豆400克.

这实际上是相同的产品,可以合并在一起.

我的计划是使用Jaro Winkler的距离算法来实现匹配.该过程如下:

• 列出内存中所有产品名称的大清单;
• 选择列表中的第一个产品;
• 将它与列表中的每个产品进行比较并计算出"Jaro分数";
• 报告任何具有高匹配(例如0.95f或更高)的产品;
• 转到下一个产品.

所以这有一些优化,因为它只对每个产品进行单向匹配,节省了一半的处理时间.

我把它编码并测试了它.它运作完美,并发现了数十个匹配的调查.

将1个产品与2,500,000个其他产品进行比较需要大约20秒钟,并计算出"Jaro评分".假设我的计算是正确的,这意味着它将花费一年的最佳时间来完成处理.

显然这不实用.

我让同事们查看代码,他们设法将Jaro分数计算部分的速度提高了20%.他们使这个过程成为多线程,并使其更快一点.我们还删除了一些存储的信息,将其简化为产品名称和唯一标识符列表; 这似乎对处理时间没有任何影响.

通过这些改进,我们仍然认为这需要几个月的时间来处理,我们需要花费数小时(或最多几天).

我不想详细介绍,因为我认为这不是完全相关的,但我将产品详细信息加载到列表中:

private class Product
{
    public int MemberId;
    public string MemberName;
    public int ProductId;
    public string ProductCode;
    public string ProductName;
}
private class ProductList : List<Product> { }
private readonly ProductList _pl = new ProductList();

然后我使用以下处理每个产品:

{Outer loop...
var match = _pl[matchCount];

for (int count = 1; count < _pl.Count; count++)
{
    var search = _pl[count];
    //Don't match …

假设我有一个数组数组,如下所示:

[
  [0, 1, 3],
  [2, 4, 6],
  [5, 5, 7],
  [10, 0, 3]
]

如何生成一个新数组,该数组在javascript中对内部数组的每个位置的所有值求和？在这种情况下,结果将是:[17,19,19].无论内部数组的长度如何,我都需要能够提供一个有效的解决方案.我认为这可以使用map和for-of的一些组合,或者可能减少,但我不能完全围绕它.我搜索过但找不到任何与此相符的例子.

假设我有一组碰碰车,它们两侧有尺寸,颜色和标识符("汽车代码").

class BumperCar {
    int size;
    String color;
    String carCode;
}

现在我需要的碰碰车映射到List的DistGroup对象,每个包含属性size,color以及List汽车代码.

class DistGroup {
    int size;
    Color color;
    List<String> carCodes;

    void addCarCodes(List<String> carCodes) {
        this.carCodes.addAll(carCodes);
    }
}

例如,

[
    BumperCar(size=3, color=yellow, carCode=Q4M),
    BumperCar(size=3, color=yellow, carCode=T5A),
    BumperCar(size=3, color=red, carCode=6NR)
]

应该导致:

[
    DistGroup(size=3, color=yellow, carCodes=[ Q4M, T5A ]),
    DistGroup(size=3, color=red, carCodes=[ 6NR ])
]

我尝试了以下,实际上做了我想要它做的事情.但问题是,它物化的直接结果(成Map),我认为,也可以在做一次(可能使用mapping或collectingAndThen或reducing或东西),导致更优雅的代码.

List<BumperCar> bumperCars = ...
Map<SizeColorCombination, List<BumperCar>> map …

我有以下数据：

pd.DataFrame({'Group_ID':[1,1,1,2,2,2,3,4,5,5],
          'Item_id':[1,2,3,4,5,6,7,8,9,10],
          'Target': [0,0,1,0,1,1,0,0,0,1]})

   Group_ID Item_id Target
0         1       1      0
1         1       2      0
2         1       3      1
3         2       4      0
4         2       5      1
5         2       6      1
6         3       7      0
7         4       8      0
8         5       9      0
9         5      10      1

我需要根据“Group_ID”将数据集拆分为训练集和测试集，以便 80% 的数据进入训练集，20% 进入测试集。

也就是说，我需要我的训练集看起来像：

    Group_ID Item_id Target
0          1       1      0
1          1       2      0
2          1       3      1
3          2       4      0
4          2       5      1
5          2       6      1 …

假设我们有一组v偶数基数，例如 ，v <- 1:6和一个由 的df条目组成的data.frame v，它是由每列中每个元素的固定出现次数定义的v，即k，例如

k <- 2
x <- rep(v, each = k)
df <- data.frame(A = x, B = c(tail(x, -(k + 1)), head(x, k + 1)))

显示为

> df
   A B
1  1 2
2  1 3
3  2 3
4  2 4
5  3 4
6  3 5
7  4 5
8  4 6
9  5 6
10 5 1
11 6 1
12 …

我有一些具有各种属性的数据,我想对这些数据进行分层分组.例如:

public class Data
{
   public string A { get; set; }
   public string B { get; set; }
   public string C { get; set; }
}

我希望这个分组为:

A1
 - B1
    - C1
    - C2
    - C3
    - ...
 - B2
    - ...
A2
 - B1
    - ...
...

目前,我已经能够使用LINQ对其进行分组,使得顶部组将数据除以A,然后每个子组除以B,然后每个B子组包含C的子组等.LINQ看起来像这样(假设一个IEnumerable<Data>序列被调用data):

var hierarchicalGrouping =
            from x in data
            group x by x.A
                into byA
                let subgroupB = from x in byA
                                group x by x.B
                                    into byB …