Рекурсивные функции в R для применения регулярных выражений внутри вложенных круглых скобок

Вам нужно, чтобы условие OR обязательно оценивалось как 1, если TRUE? Или, другими словами, было бы нормально, если бы (A OR B) оценивалось как 2 (что в логическом смысле все равно было бы TRUE) в тех случаях, когда и A, и B равны TRUE? Если да, то очень простым решением будет следующее:

gsub(" +AND +"," * ",gsub(" +OR +"," + ",expr))

Обратите внимание, что это также позаботится о любых дополнительных пробелах, которые вы случайно добавили вокруг выражений OR/AND.

Обновлено: Кроме того, как упомянул другой пользователь в комментарии под вашим вопросом, вам не хватает одной скобки в начале expr.

Если мы преобразуем входные данные в действительный код R, мы можем использовать анализ и замену. Например, эта вспомогательная функция делает свое дело

transform <- function(expr) {
  tx <- function(e) {
    if (is.call(e)) {
      parts <- as.list(e)
      if (parts[[1]] == quote(`%OR%`)) {
        parts[[1]] <- quote(`min`)
        parts[[3]] <- bquote(.(tx(parts[[2]])) + .(tx(parts[[3]])))
        parts[[2]] <- 1
        as.call(parts)         
      } else if (parts[[1]]==quote(`%AND%`)) {
        parts[[1]] <- quote(`*`)
        parts[[2]] <- tx(parts[[2]])
        parts[[3]] <- tx(parts[[3]])
        as.call(parts)
      } else {
        parts[-1] <- lapply(parts[-1], tx)
        as.call(parts)
      }
    } else {
      e
    }
  }
  fix <- gsub("\\bOR\\b", "%OR%", gsub("\\bAND\\b", "%AND%", expr))
  fix <- gsub("\\|\\|", "%OR%", gsub("\\&\\&", "%AND%", fix))
  deparse1(tx(str2lang(fix)))
}

С помощью которого мы можем протестировать

expr <- "(((a OR b) OR c) AND d) OR (e AND f)"
transform(expr)
# [1] "min(1, ((min(1, (min(1, a + b)) + c)) * d) + (e * f))"
input_2 <- "(r1 && r2) || r3 + r4 + (r5 && r6)"
transform(input_2)
# [1] "min(1, (r1 * r2) + r3) + r4 + (r5 * r6)"
input_3 <- "(r1 && r2) || (r3 && r4) + r5 || (r6 + r7)"
transform(input_3)
# [1] "min(1, (r1 * r2) + (r3 * r4)) + min(1, r5 + (r6 + r7))"

Мы превращаем OR и AND в %OR% и %AND%, которые можно проанализировать с помощью R, а затем пройти по абстрактному синтаксическому дереву и выполнить преобразование. Анализ выполняет тяжелую работу по построению дерева.

Я бы преобразовал текст в анализируемый код R, проанализировал, рекурсивно просмотрел полученный вызов, а затем разобрал:

(s0 <- "(((a OR b) OR c) AND d) OR (e AND f)")
## [1] "(((a OR b) OR c) AND d) OR (e AND f)"
(s1 <- gsub(" OR ", " | ", gsub(" AND ", " & ", s0)))
## [1] "(((a | b) | c) & d) | (e & f)"

recurse <- function(x) {
    if (!is.call(x))
        x
    else if ((n <- length(x)) == 3L) {
        if (identical(x[[1L]], quote(`|`)))
            call("min", 1, call("+", Recall(x[[2L]]), Recall(x[[3L]])))
        else if (identical(x[[1L]], quote(`&`)))
            call("*", Recall(x[[2L]]), Recall(x[[3L]]))
        else x
    }
    else {
        if (n >= 2L) for (i in 2L:n) x[[i]] <- Recall(x[[i]])
        x
    }    
}

(s2 <- deparse(recurse(str2lang(s1))))
## [1] "min(1, ((min(1, (min(1, a + b)) + c)) * d) + (e * f))"

Попытка использования замены строк:

string <- "(((a OR b) OR c) AND d) OR (e AND f)"

# function to substitute a single expression
process_expression <- function(expression) {
  # check if expression is something OR something, or something AND something, with optional parentheses
  if (grepl("^[^()]+\\s+(?:OR|AND)\\s+[^()]+$", expression) || grepl("^\\([^()]+\\s+(?:OR)|(?:AND)\\s+[^()]+\\)$", expression)) {
    # convert to required output, using braces {} to avoid clashes with the () in string
    result <- gsub("\\(?([^()]+)\\s+OR\\s+([^()]+)\\)?", "min{1, \\1 + \\2}", expression)
    result <- gsub("\\(?([^()]+)\\s+AND\\s+([^()]+)\\)?", "{\\1 * \\2}", result)
  } else {
    stop("Invalid expression")
  }
  return(result)
}

# function to find and replace all expressions in a string
process_string <- function(string) {
  # find the (innermost) expressions
  match_data <- gregexpr("\\(?[^()]+\\s+(?:OR|AND)\\s+[^()]+\\)?", string)
  # get the match strings
  matches <- regmatches(string, match_data)[[1]]
  # substitute the matches for their processed equivalents
  result <- Reduce(\(s, m) gsub(m, process_expression(m), s, fixed = TRUE), matches, init=string)
  # recurse if any AND or OR remain
  if (grepl("(AND|OR)", result)) {
    result <- process_string(result)
  }
  # change braces back to parentheses
  result <- gsub("{", "(", gsub("}", ")", result, fixed = TRUE), fixed = TRUE)
  
  return(result)
}

process_string(string)
#> [1] "min(1, (min(1, min(1, a + b) + c) * d) + (e * f))"

^{Created on 2024-06-24 with reprex v2.1.0}

string_parse <- function(x){
  if (is.call(x)){
    if (x[[1]] == '|') x <-  call('min', 1, call('+', x[[2]], x[[3]]))
    else if (x[[1]] == '&') x[[1]] <- as.name('*')
    x[-1] <- lapply(x[-1], string_parse)
  }
  x
}

string <- "(((a OR b) OR c) AND d) OR (e AND f)"

string_parse(str2lang(gsub("AND", "&", gsub("OR", "|", string))))
min(1, ((min(1, (min(1, a + b)) + c)) * d) + (e * f))