Finding the best possible combinations based on multiple conditions with R dplyr

I think an efficient way is using Monte Carlo method (no need to build a full dataset of all possible combinations), where we stop searching after finding the desired output through random sampling

repeat {
  idx <- unlist(
    Map(
      sample,
      split(1:nrow(df), df$role),
      c(2, 4, 4)
    )
  )
  s <- sum(df$score[idx])
  if (s >= 95.5 & s <= 100.4) break
}
df[sort(idx), ]

I used data.table. choose(4, 2) * choose(8, 4) * choose(8, 4) = 29400 combinations. Basically brute force. I'm sure there's a more elegant solution.

library(data.table)
library(magrittr)

set.seed(123)
players <- paste("player",rep(1:20))
score <- runif(20, min=4, max=16.7)
index <- runif(20, min=-1, max=9)
role <- rep(c("C","F","F","G","G"),4)

dt <- data.table(players, score, index,role)
centers <- dt[role == "C"]
forwards <- dt[role == "F"]
guards <- dt[role == "G"]
c_combos <- combn(nrow(centers), 2) %>% t() %>% as.data.table()
c_combos <- lapply(c_combos, function(x) centers[x])
c_combos <- data.table(c_combos[[1]]$players, c_combos[[2]]$players, 
                       c_combos[[1]]$score + c_combos[[2]]$score,
                       c_combos[[1]]$index + c_combos[[2]]$index) %>% 
  setnames(c('C1', 'C2', 'score_c', 'index_c'))
f_combos <- combn(nrow(forwards), 4) %>% t() %>% as.data.table()
f_combos <- lapply(f_combos, function(x) forwards[x])
f_combos <- data.table(f_combos[[1]]$players, f_combos[[2]]$players, 
                       f_combos[[3]]$players, f_combos[[4]]$players,
                       f_combos[[1]]$score + f_combos[[2]]$score + 
                         f_combos[[3]]$score + f_combos[[4]]$score,
                       f_combos[[1]]$index + f_combos[[2]]$index + 
                         f_combos[[3]]$index + f_combos[[4]]$index) %>% 
  setnames(c('F1', 'F2', 'F3', 'F4', 'score_f', 'index_f'))
g_combos <- combn(nrow(guards), 4) %>% t() %>% as.data.table()
g_combos <- lapply(g_combos, function(x) guards[x])
g_combos <- data.table(g_combos[[1]]$players, g_combos[[2]]$players, 
                       g_combos[[3]]$players, g_combos[[4]]$players,
                       g_combos[[1]]$score + g_combos[[2]]$score + 
                         g_combos[[3]]$score + g_combos[[4]]$score,
                       g_combos[[1]]$index + g_combos[[2]]$index + 
                         g_combos[[3]]$index + g_combos[[4]]$index) %>% 
  setnames(c('G1', 'G2', 'G3', 'G4', 'score_g', 'index_g'))

combined <- expand.grid(1:nrow(c_combos), 1:nrow(f_combos), 1:nrow(g_combos))
ans <- rbindlist(lapply(1:nrow(combined), 
                               function(x) data.table(c_combos[combined$Var1[x]],
                                                 f_combos[combined$Var2[x]],
                                                 g_combos[combined$Var3[x]])))
ans[, score := score_c + score_f + score_g]
ans[, index := index_c + index_f + index_g]
ans[, c('score_c', 'score_f', 'score_g', 'index_c', 'index_f', 'index_g') := NULL]
ans[score %between% c(99.5, 100.4), .SD[which.max(index)]]

Gives:

         C1       C2       F1       F2        F3        F4       G1       G2
1: player 1 player 6 player 3 player 7 player 12 player 17 player 4 player 5
          G3        G4   score    index
1: player 14 player 19 99.6097 62.07025

Here's an approach using some tidyverse and base functions. Brute force, but probably fast enough (~0.2 sec) at this scale.

First I make vectors of player numbers for each position, then figure out the possible combinations within each position. Then use tidyr::crossing to get all the combinations of those combinations. By pivoting those long and joining to original data, we can more easily get the total score for each combination, and filter those to the required range.

Looks like 1,878 combinations below 95.5, 24,743 over 100.4, and 2,779 in the desired range.

library(dplyr); library(tidyr) 
df %>% split(.$role) -> df_split   
C <- df_split$C$players
F <- df_split$F$players
G <- df_split$G$players

C_comb <- combn(C, 2) %>% t %>% as_tibble()
F_comb <- combn(F, 4) %>% t %>% as_tibble()
G_comb <- combn(G, 4) %>% t %>% as_tibble()

crossing(C_comb, F_comb, G_comb, .name_repair = "unique") %>%
  mutate(sim_num = row_number()) %>%
  pivot_longer(-sim_num) %>%
  left_join(df, by = c("value" = "players")) %>%
  group_by(sim_num) %>%
  mutate(total_score = sum(score)) %>%
  ungroup() %>%
  filter(total_score >= 95.5, score <= 100.4)