【问题标题】：Sort 2 columns simultaneously based on the group name根据组名同时对 2 列进行排序
【发布时间】：2022-01-25 23:07:51
【问题描述】：

数据集

> read.delim("df.tsv")
   col1 col2 group
1     3    2    aa
2     1    1    aa
3     4    1    aa
4     4    3    aa
5     5    3    ab
6     3    2    ab
7     4    1    ab
8     2    4    ab
9     4    2    ba
10    1    4    ba
11    3    1    ba
12    4    3    ba
13    4    2    bb
14    2    3    bb
15    3    1    bb
16    1    2    bb

我想排序列 col1 和 col2 在 4 个组中的每一个中，按以下方式：

如果组名中的第一个字符是“a”，则在中排序col1 >下降方式，如果是“b”则上升
如果组名中的第二个字符是“a”，则将col2排序到下降方式，如果是“b”则上升
重要的是，我希望这两列同时排序，即，如果该组为“aa”，该组的排序应如下所示：

   col1 col2 group
1     4    3    aa
2     3    2    aa
3     4    1    aa
4     1    1    aa
...

这可以通过例如一个"one row at a time" approach，先是col1，然后是col2，每行交替进行。

当前代码和输出

library(dplyr)

read.delim("df.tsv") %>%
  group_by(group) %>%
  arrange(ifelse(substr(group, 1,1) == "a", desc(col1), col1), # if first character in group name is "a", sort col1 in a descending manner, and ascending if it's "b"
          ifelse(substr(group, 2,2) == "a", desc(col2), col2), # if second character in group name is also "a", sort also col2 in a descending manner, and ascending if it's "b"
          .by_group = TRUE)

    col1  col2 group
 1     4     3 aa   
 2     4     1 aa   
 3     3     2 aa   
 4     1     1 aa   
 5     5     3 ab   
 6     4     1 ab   
 7     3     2 ab   
 8     2     4 ab   
 9     1     4 ba   
10     3     1 ba   
11     4     3 ba   
12     4     2 ba   
13     1     2 bb   
14     2     3 bb   
15     3     1 bb   
16     4     2 bb

但是，这不满足第三个标准，即“一次同时排序一行”。

期望的输出

    col1  col2 group
 1     4     3 aa   
 2     3     2 aa   
 3     4     1 aa   
 4     1     1 aa   
 5     5     3 ab   
 6     4     1 ab   
 7     3     2 ab   
 8     2     4 ab   
 9     1     4 ba   
10     4     3 ba   
11     3     1 ba   
12     4     2 ba   
13     1     2 bb   
14     3     1 bb   
15     2     3 bb   
16     4     2 bb

编辑

实际上有几个答案可以完成建议的任务，所以我认为一个平局可能是该算法在要排序的列数方面是灵活的，例如3：

col1    col2    col3    group
3   2   4   aaa
1   1   2   aaa
4   1   4   aaa
4   3   1   aaa
5   3   3   aab
3   2   2   aab
4   1   1   aab
2   4   1   aab
4   2   3   aba
1   4   3   aba
3   1   2   aba
4   3   3   aba
3   2   4   abb
1   1   2   abb
4   1   4   abb
4   3   1   abb
4   2   1   baa
2   3   2   baa
3   1   2   baa
1   2   1   baa
5   3   3   bab
3   2   2   bab
4   1   1   bab
2   4   1   bab
4   2   3   bba
1   4   3   bba
3   1   2   bba
4   3   3   bba
4   2   1   bbb
2   3   2   bbb
3   1   2   bbb
1   2   1   bbb

输出应该是

col1    col2    col3    group
4   3   1   aaa
3   2   4   aaa
4   1   4   aaa
1   1   2   aaa
5   3   3   aab
2   4   1   aab
4   1   1   aab
3   2   2   aab
4   2   3   aba
3   1   2   aba
4   3   3   aba
1   4   3   aba
4   1   4   abb
1   1   2   abb
4   3   1   abb
3   2   4   abb
1   2   1   baa
2   3   2   baa
3   1   2   baa
4   2   1   baa
2   4   1   bab
5   3   3   bab
4   1   1   bab
3   2   2   bab
1   4   3   bba
3   1   2   bba
4   2   3   bba
4   3   3   bba
1   2   1   bbb
3   1   2   bbb
4   2   1   bbb
2   3   2   bbb

目前，当包含 3 列或更多列时，建议的 2 个解决方案不起作用，它们仅基于 2 列进行排序。

编辑 2

如果例如group=='aba'，该组的第一行应该是col1中包含最高值的那一行；第 2 行包含 col2 中（剩余的）最低值的行；第 3 行包含 col3 中的（剩余）最高值，第 4 行是剩余的行。但是，这应该是灵活的，以允许每组超过 4 行，在这种情况下，第 4 行应该是包含 col1 中（剩余）最高值的行；第 5 行应该是包含 col2 中（剩余）最低值的行；等等

更多详情

示例：对于 'aba' 组的第 2 行，在 col2 中的最低（剩余）值的 2 行之间存在平局的情况下，例如

row-a 3 1 4 aba
row-b 2 1 4 aba

（请注意，两行中的 col2 中都有一个 1），理想情况下，选择的第二行将是 row-a，因为 col1 在该组中必须以降序方式（'a'）排序，并且3>2，无论如何对于 col3 4==4。

如果改为

row-a 3 1 4 aba
row-b 2 1 5 aba

让优先级转到 col3>col2>col1，因为循环转到 col1>col2>col3... 所以第二行将是 row-b，因为 5>4。

所以概括地说，如果有 5 列并且组是 'aabaa'，并且在 2 行之间选择第 3 行存在平局：

row-a 3 2 1 3 3 aabaa
row-b 5 4 1 4 2 aabaa

(col3 == 1 in both)，那么要选择的将是 row-a，因为 col5 3>2。如果改为

row-a--> 3 2 1 3 3
row-b--> 5 4 1 4 3

（col5==3 in both），然后选择 row-b since for col4 4>3.

【问题讨论】：

我不确定我是否理解为什么 col1 应该是 4 3 4 而不是 4 4 3？
因为如果 col1 为 4 4 3 表示 col2 为 3 1 2，而我想要的是第一行在 col1 中具有最高值，那么 row2 在 col2 中具有剩余的最高值，那么row3 col1 中剩余的最高值
好的，现在更有意义了。

标签： r dataframe sorting dplyr tidyverse

【解决方案1】：

再想一想，我想我可以把那个选项传给你。您现在可以指定任何您想要的骑行方式。

alt_order <- function(..., type, cyc) {
  cols <- unname(list(...))
  stopifnot(
    # sanity checks; you may skip if you think they are unnecessary
    length(unique(lengths(cols))) == 1L,
    length(cols) == length(type),
    all(unlist(type) %in% c(1L, -1L))
  ) 
  cols <- mapply(`*`, cols, type, SIMPLIFY = FALSE)
  out <- integer(length(cols[[1L]]))
  this <- cols
  for (i in seq_along(out)) {
    out[[i]] <- do.call(order, this)[[1L]]
    cols <- lapply(cols, `is.na<-`, out[[i]])
    this <- cols[cyc(i)]
  }
  out
}

cyc 应该是一个接受单个整数作为输入并返回整数向量的函数。例如，如果您有 3 列并且想要复制我在下面的评论中描述的 rev 循环行为，您可以这样做

mycyc <- function(i) list(1:3, 3:1)[[(i - 1) %% 2L + 1L]]
df %>% group_by(group) %>% slice(alt_order(col1, col2, col3, type = ab2sign(group), cyc = mycyc))

好吧，也许一个效率不高但简单的解决方案是只对两列进行连续排序，每次交换主要列，然后排出第一个元素，直到没有元素需要排序。这是函数。

alt_order <- function(..., type) {
  cols <- unname(list(...))
  stopifnot(
    # sanity checks; you may skip if you think they are unnecessary
    length(unique(lengths(cols))) == 1L,
    length(cols) == length(type),
    all(unlist(type) %in% c(1L, -1L))
  ) 
  cols <- mapply(`*`, cols, type, SIMPLIFY = FALSE)
  out <- integer(length(cols[[1L]]))
  for (i in seq_along(out)) {
    out[[i]] <- do.call(order, cols)[[1L]]
    cols <- rev(lapply(cols, `is.na<-`, out[[i]]))
  }
  out
}

我们将值分配给NAs 以释放它们，因为NAs 将按升序排列到最后。 type 应该是 1 或 -1，用于简化我们想要施加的顺序，因为 c(1,2,3) 的降序与 -1 * c(1,2,3) 的升序相同。我们还需要一个如下的辅助函数来将你的groups 转换为 1 和 -1

ab2sign <- function(x) {
  out <- data.table::transpose(strsplit(x, "", fixed = TRUE))
  lapply(out, function(x) 2L * (x == "b") - 1L)
}

现在我们可以应用它们了

df %>% group_by(group) %>% slice(alt_order(col1, col2, type = ab2sign(group)))

输出

# A tibble: 16 x 3
# Groups:   group [4]
    col1  col2 group
   <int> <int> <chr>
 1     4     3 aa   
 2     3     2 aa   
 3     4     1 aa   
 4     1     1 aa   
 5     5     3 ab   
 6     4     1 ab   
 7     3     2 ab   
 8     2     4 ab   
 9     1     4 ba   
10     4     3 ba   
11     3     1 ba   
12     4     2 ba   
13     1     2 bb   
14     3     1 bb   
15     2     3 bb   
16     4     2 bb

我希望在赏金到期之前看到更高效（也许是矢量化）的解决方案。

【讨论】：

谢谢，这是建议的任务，但请检查编辑
我不确定如何编码。我们只知道第一轮你想主要根据 col1、col2 和 col3（基本上是 123）进行排序，但是后面的轮次呢？保持原来的顺序，把用过的移到最后，如果需要循环，123 -> 213 -> 312 -> 123 -> 213 -> ...?或者继续下一个未使用的，如果需要循环，不重启123 -> 213 -> 321 -> 132 -> 213 -> 321 -> ...？还是重启123 -> 213 -> 321 -> 123 -> 213 -> 321 -> ...？太多的可能性。你想如何做到这一点对我来说并不是很明显。你能澄清一下吗？ @米格尔
我目前的方法类似于两列案例。基本上，123 -> 321 -> 123 -> 321 -> 123 -> ...@Miguel
谢谢，请看edit2；哪个应该是执行那里描述的循环？
还是一头雾水。考虑您发布的所有四个新示例。对于第一个，我们首先比较 col2 > 1 vs 1 > undetermined > 比较 col2 > 4 vs 4 > undetermined > 完成所有 cols > 循环到 col1 > 3 vs 2 > 确定（将行移动到行前-b 因为组'a'）。我可以毫无问题地将这个逻辑用于第二个新示例。但是，对于第三个和第四个示例，为什么我们跳过 col4 呢？我认为应该是：首先比较 col3 > 1 与 1 > 未确定 > 比较 col4 > 3 与 4 > 确定（由于组 'a'，将行 b 移动到行 a 之前）？ @米格尔

【解决方案2】：

更新

以下是在一般情况下可能有效的选项，即超过 2 列：

f <- function(.) {
  col <- .[-length(.)] * (2 * (t(list2DF(strsplit(.$group, ""))) == "b") - 1)
  r <- data.frame()
  while (nrow(.)) {
    p <- do.call(order, col[(seq_along(col) + nrow(r) - 1) %% length(col) + 1])[1]
    r <- rbind(r, .[p, ])
    col <- col[-p, ]
    . <- .[-p, ]
  }
  r
}

df %>%
  group_by(group) %>%
  do(f(.)) %>%
  ungroup()

给了

    col1  col2  col3 group
   <int> <int> <int> <chr>
 1     4     3     1 aaa
 2     3     2     4 aaa
 3     4     1     4 aaa
 4     1     1     2 aaa
 5     5     3     3 aab
 6     2     4     1 aab
 7     4     1     1 aab
 8     3     2     2 aab
 9     4     2     3 aba
10     3     1     2 aba
# ... with 22 more rows

这是一个使用动态编程的选项（但可能效率不高）

f <- function(.) {
  col <- with(., data.frame(col1, col2) * (2 * (t(list2DF(strsplit(.$group, ""))) == "b") - 1))
  r <- data.frame()
  while (nrow(.)) {
    p <- do.call(order, ifelse(nrow(r) %% 2, rev, I)(col))[1]
    r <- rbind(r, .[p, ])
    col <- col[-p,]
    . <- .[-p, ]
  }
  r
}

df %>%
  group_by(group) %>%
  do(f(.)) %>%
  ungroup()

给了

# A tibble: 16 x 3
    col1  col2 group
   <int> <int> <chr>
 1     4     3 aa
 2     3     2 aa
 3     4     1 aa
 4     1     1 aa
 5     5     3 ab
 6     4     1 ab
 7     3     2 ab
 8     2     4 ab
 9     1     4 ba
10     4     3 ba
11     3     1 ba
12     4     2 ba
13     1     2 bb
14     3     1 bb
15     2     3 bb
16     4     2 bb

【讨论】：

谢谢，这是建议的任务，但请检查编辑
@Miguel 那么3列的情况的逻辑是什么？
如果例如group=='aba'，该组的第一行应该是col1中包含最高值的那一行；第 2 行包含 col2 中（剩余的）最低值的行；第 3 行包含 col3 中（剩余的）最高值，第 4 行是剩余的行。但是，这应该是灵活的，以允许每组超过 4 行，在这种情况下，第 4 行应该是包含 col1 中（剩余）最高值的行；第 5 行应该是包含 col2 中（剩余）最低值的行；等
@Miguel 谢谢。然后，对于第 2 行，我们在剩余的值中找到 col2 中的最低值，但是 col1 和 col3 的优先级是多少？优先级应该像 col2 > col1 > col3 那样排列吗？
对于第 2 行，最高优先级是 col2。如果 col2 中的 2 行之间存在最低（剩余）值，例如行-a --> 3 1 4 ; row-b --> 2 1 4 （注意两行 col2 中都有一个 1），理想情况下，选择的行是 row-a，因为 col1 必须以降序方式排序（'a'）在这个组中，3>2，对于 col3 4==4 无论如何。然而，这并不重要。

【解决方案3】：

我可以告诉你答案，但我不能为它写完整的r 代码，因为我不知道r，我希望有人可以编辑我的代码以获得完整的答案。

假设这两种都是升序的（您可以将其推广到您的情况）

idx1=order(col1)
idx2=order(col2[idx1])

return col1[idx1[idx2]], col2[idx1[idx2]]

【讨论】：

谢谢，但不幸的是，你的代码应该如何应用到 R 来完成任务对我来说并不明显
我在 R 中尝试过这段代码，但它不适合我。