Verificando se os conjuntos de colunas são iguais, em linha em R, em qualquer ordem

BaseR:

df$assessment <- apply(df, 1, \(x) identical(table(x[1:3]), table(x[4:6])))

#   col1 col2 col3 col4 col5 col6 assessment
# 1    a    a    a    a    a    b      FALSE
# 2    b    b    a    b    a    b       TRUE
# 3    c    d    a    d    c    a       TRUE
# 4    d    a    a    a    d    a       TRUE

Dados reproduzíveis:

df <- data.frame(
  col1 = c("a", "b", "c", "d"), col2 = c("a", "b", "d", "a"),
  col3 = c("a", "a", "a", "a"), col4 = c("a", "b", "d", "a"),
  col5 = c("a", "a", "c", "d"), col6 = c("b", "b", "a", "a")
)

PS: Por que table() e indentical em vez de sort(), ==, all()? Eu esperaria que fosse melhor dimensionado com o número de colunas (dado o baixo número de valores exclusivos). Exemplo:

df <- as.data.frame(lapply(1:600, \(x) sample(letters, size = 4000, replace = TRUE)))
bench::mark(
  apply(df, 1, \(x) identical(table(x[1:300]), table(x[301:600]))),
  apply(df, 1, \(x) all(sort(x[1:300]) == sort(x[301:600])))
)
#   expression                                                   min median `itr/sec` mem_alloc 
#   <bch:expr>                                                 <bch> <bch:>     <dbl> <bch:byt>   
# 1 apply(df, 1, function(x) identical(table(x[1:300]), table… 1.68s  1.68s     0.594     333MB   
# 2 apply(df, 1, function(x) all(sort(x[1:300]) == sort(x[301… 9.01s  9.01s     0.111     191MB 

PS 2: Substituir table(x)por collapse::fcount(x, sort = TRUE)dá uma grande aceleração.

Usando dplyr você pode fazer o seguinte:

df %>%
  rowwise() %>%
  mutate(result = all(sort(c_across(col1:col3)) == sort(c_across(col4:col6))))

# A tibble: 4 × 7
# Rowwise: 
  col1  col2  col3  col4  col5  col6  result
  <chr> <chr> <chr> <chr> <chr> <chr> <lgl> 
1 a     a     a     a     a     b     FALSE 
2 b     b     a     b     a     b     TRUE  
3 c     d     a     d     c     a     TRUE  
4 d     a     a     a     d     a     TRUE  

Evite iterar nas linhas

Geralmente, a iteração nas linhas é lenta e descobri que dplyr::rowwise()as abordagens se tornam muito lentas com mais de alguns milhares de linhas. Tende a ser mais rápido de usar purrr::pmap()e muito mais rápido de iterar nas colunas.

abordagem base R

Você poderia pegar a transposição das colunas relevantes e iterar sobre as colunas disso.

cols <- paste0("col", 1:6)

df$assessment <- df[cols] |>
    t() |>
    data.frame() |>
    sapply(\(x) all(sort(x[1:3]) == sort(x[4:6])))

#   col1 col2 col3 col4 col5 col6 assessment
# 1    a    a    a    a    a    b      FALSE
# 2    b    b    a    b    a    b       TRUE
# 3    c    d    a    d    c    a       TRUE
# 4    d    a    a    a    d    a       TRUE

tidyverseabordagem: converter de largo para longo

Alternativamente, se você quiser permanecer no tidyversevocê pode converter de largo para longo:

df %>%
    mutate(
        assessment = . |>
            mutate(id = row_number()) |>
            tidyr::pivot_longer(
                -id,
                names_to = "col",
                names_transform = readr::parse_number
            ) |>
            group_by(id) |>
            summarise(
                assessment = all(
                    sort(
                        value[col %in% 1:3]
                    ) ==
                        sort(
                            value[col %in% 4:6]
                        )
                )
            ) |>
            pull(
                assessment
            )
    )

Isso é mais detalhado, mas suspeito que será consideravelmente mais rápido com qualquer conjunto de dados de tamanho razoável.

Na base R você poderia usar vapplye sort:

df$assessment <- vapply(seq_len(nrow(df)), \(x) 
                        all(sort(unlist(df[x,1:3])) == sort(unlist(df[x,4:6]))), logical(1))

Saída:

#   col1 col2 col3 col4 col5 col6 assessment
# 1    a    a    a    a    a    b      FALSE
# 2    b    b    a    b    a    b       TRUE
# 3    c    d    a    d    c    a       TRUE
# 4    d    a    a    a    d    a       TRUE

Como foi observado, você deve evitar operações em linha. Aqui está uma alternativa que compara conjuntos usando uma função auxiliar que classifica com eficiência por linha para que as comparações sejam completamente vetorizadas.

library(dplyr)

f <- function(set1, set2) {
  s1 <- as.matrix(pick({{set1}}))
  s2 <- as.matrix(pick({{set2}}))
  row_sort <- function(m) matrix(m[order(row(m), m)], ncol = ncol(m), byrow = TRUE)
  !rowSums(row_sort(s1) != row_sort(s2)) > 0
}

dat %>%
  mutate(assessment = f(col1:col3, col4:col6))

  col1 col2 col3 col4 col5 col6 assessment
1    a    a    a    a    a    b      FALSE
2    b    b    a    b    a    b       TRUE
3    c    d    a    d    c    a       TRUE
4    d    a    a    a    d    a       TRUE

Uma dplyropção vecsetspoderia ser:

df %>%
 rowwise() %>%
 mutate(cond = vsetequal(c_across(col1:col3), c_across(col4:col6), multiple = TRUE))

  col1  col2  col3  col4  col5  col6  cond 
  <chr> <chr> <chr> <chr> <chr> <chr> <lgl>
1 a     a     a     a     a     b     FALSE
2 b     b     a     b     a     b     TRUE 
3 c     d     a     d     c     a     TRUE 
4 d     a     a     a     d     a     TRUE

A mesma ideia com purrr::pmap():

df %>%
 mutate(cond = pmap_lgl(across(col1:col6), 
                        ~ vsetequal(c(...)[1:3], c(...)[4:6], multiple = TRUE)))

Esta é uma solução excessivamente ineficiente, mas por curiosidade:

df %>%
 rowwise() %>%
 mutate(cond = toString(sort(c_across(col1:col3))) == toString(sort(c_across(col4:col6))))

A mesma ideia com purrr:pmap():

df %>%
 mutate(cond = pmap_lgl(across(col1:col6), 
                        ~ toString(sort(c(...)[1:3])) == toString(sort(c(...)[4:6]))))

Usando a lógica de transposição do @SamR com vecsets:

df %>%
 mutate(cond = map2_lgl(.x = across(col1:col3) %>% t() %>% data.frame(), 
                        .y = across(col4:col6) %>% t() %>% data.frame(), 
                        vsetequal))

A mesma abordagem usando data.table::transpose():

df %>%
 mutate(cond = map2_lgl(.x = data.table::transpose(across(col1:col3)), 
                        .y = data.table::transpose(across(col4:col6)), 
                        vsetequal))

Experimente o código abaixo com split.default+colMeans

df$assessment <-
    colMeans(
        do.call(
            `==`,
            lapply(split.default(
                df,
                grepl("[1-3]$", names(df))
            ), \(d) apply(d, 1, sort))
        )
    ) == 1

que deveria dar

> df
  col1 col2 col3 col4 col5 col6 assessment
1    a    a    a    a    a    b      FALSE
2    b    b    a    b    a    b       TRUE
3    c    d    a    d    c    a       TRUE
4    d    a    a    a    d    a       TRUE

Este é bastante detalhado, mas não consigo resistir. Aqui está um com pivotamento:

library(dplyr)
library(tidyr)

df %>%
  pivot_longer(cols = starts_with("col"), names_to = "col_set") %>%
  group_by(group = (row_number() - 1) %/% ncol(df) + 1) %>% 
  mutate(x = lead(value, 3)) %>% 
  na.omit() %>% 
  mutate(across(c(value, x), ~sort(.))) %>% 
  summarize(check = all(value == x), .groups = "drop") %>% 
  bind_cols(df) %>% 
  select(-group)

# A tibble: 4 × 7
  check col1  col2  col3  col4  col5  col6 
  <lgl> <chr> <chr> <chr> <chr> <chr> <chr>
1 FALSE a     a     a     a     a     b    
2 TRUE  b     b     a     b     a     b    
3 TRUE  c     d     a     d     c     a    
4 TRUE  d     a     a     a     d     a