R中按可变数量列实现子集划分、条件统计及组合获取方法

Got it, let's break this down step by step for your maximization algorithm in R. Since you're dealing with a variable number of columns and need to handle for each traversal plus conditional counts/sums (what you called "count/sum if"), here's a practical, flexible approach that works no matter how many variable columns you have. We'll use a 3-column sample dataset as you mentioned, but the code scales automatically.

The key here is twofold:

• Generate all unique combinations of values across your variable columns (regardless of how many there are)
• For each combination, compute the conditional count or sum you need—either with an explicit traversal or a more efficient vectorized method

First, let's create a sample dataset matching your description (no ID/Category columns, just 3 variable columns):

set.seed(123) # For reproducibility
sample_df <- data.frame(
  var1 = sample(c("A", "B", "C"), 100, replace = TRUE),
  var2 = sample(c("X", "Y"), 100, replace = TRUE),
  var3 = sample(c(0, 1), 100, replace = TRUE)
)

Step 1: Get All Unique Combinations #

We need to generate every possible unique combination of values across our variable columns. This works for any number of columns, not just 3:

Using Tidyverse (Clean & Intuitive) #

library(tidyverse)

unique_combinations <- sample_df %>%
  expand(across(everything())) # Automatically uses all columns in the dataset

Using Base R (No External Packages) #

unique_combinations <- do.call(expand.grid, lapply(sample_df, unique))

Step 2: Dynamic "Count/Sum If" for Each Combination #

Now we'll compute the conditional stats for each unique combination. We'll cover both an explicit traversal (for full control) and a vectorized method (faster for large datasets).

Explicit Traversal (For Each Combination) #

If you need granular control over the loop, here's a function-based approach:

Count Matching Rows

# Function to count rows that match a given combination
count_matches <- function(combination, data) {
  # Create a logical condition for each column
  conditions <- pmap(combination, ~ data[[..1]] == ..2)
  # Combine all conditions with AND (all columns must match)
  full_condition <- reduce(conditions, `&`)
  # Count the number of TRUE values
  sum(full_condition)
}

# Apply the function to every row in our unique combinations
unique_combinations$match_count <- apply(unique_combinations, 1, count_matches, data = sample_df)

Sum a Target Column for Matching Rows

If you need to sum a specific column where the combination matches (e.g., sum var3):

# Function to sum a target column for matching rows
sum_matches <- function(combination, data, target_col) {
  conditions <- pmap(combination, ~ data[[..1]] == ..2)
  full_condition <- reduce(conditions, `&`)
  # Sum the target column where conditions are met
  sum(data[[target_col]][full_condition], na.rm = TRUE)
}

# Apply to get sum of var3 for each combination
unique_combinations$sum_var3 <- apply(unique_combinations, 1, sum_matches, data = sample_df, target_col = "var3")

Vectorized Alternative (Faster for Large Data) #

For bigger datasets, looping can be slow. Instead, use dplyr's grouping to avoid explicit loops—this is way more efficient:

result <- sample_df %>%
  group_by(across(everything())) %>% # Group by all variable columns
  summarize(
    match_count = n(), # Count rows in each group
    sum_var3 = sum(var3, na.rm = TRUE), # Sum var3 for the group
    .groups = "drop" # Ungroup after summarizing
  )

The best part? All of these methods work regardless of how many variable columns you have. If your dataset grows to 5, 10, or more columns, you don't need to modify the code—across(everything()) (tidyverse) and lapply(sample_df, unique) (base R) automatically adapt to the number of columns present.

This should cover your core needs: dynamic traversal of all unique combinations and conditional count/sum stats for your maximization algorithm.

内容的提问来源于stack exchange，提问作者desig_nate