如何将逻辑规则字符串转换为支持双向映射与距离计算的定长整数向量

存在完全满足你提出的三个要求的转换方案，具体实现逻辑和R语言示例如下：

核心实现思路 #

要同时满足定长、相似度匹配、双向转换三个要求，核心是先构建全局统一的编码词典，再按固定规则映射到定长整数向量：

1. 先全量扫描所有输入的规则字符串，拆分出4类基础元素，分别分配唯一整数编码：
   • 变量ID：比如示例中的X[,1]、X[,2]、X[,3]，按出现顺序编码为1/2/3……
   • 比较运算符：比如>、<、>=、<=，编码为1/2/3/4……
   • 阈值：所有规则出现的阈值去重后排序编码，比如示例中的0.2/0.3/0.5/1，编码为1/2/3/4……
   • 逻辑连接符：比如&、|，编码为1/2……
2. 提前确定整数向量的统一长度：可以按业务场景下规则的最大复杂度预留足够长度，比如最多支持5个原子条件拼接，就固定向量长度为20，空缺位统一补0即可保证所有向量长度一致。

要求匹配验证 #

• 满足定长要求：所有输出向量按提前约定的固定长度生成，空缺位补0，天然长度统一
• 满足相似度匹配要求：相似规则的编码会天然相似，比如同变量的规则变量编码位相同、同阈值的规则阈值编码位相同，只有差异部分编码不同，直接计算汉明距离、余弦距离就能反映规则的相似度
• 满足双向转换要求：每个位置的编码都对应预定义词典，反向转换时按位置读取编码查词典，拼接即可还原为原规则字符串，完全可逆

R语言实现示例 #

# 示例规则
rules <- c("X[,1]>0.5 & X[,2]<1" , "X[,3]>0.2" , "X[,3]>0.3")

# ---------------------- 第一步：构建全局编码词典 ----------------------
# 拆分所有规则的原子条件
split_conds <- lapply(rules, function(x) strsplit(x, " & | \\| ")[[1]])
# 变量词典：提取所有变量并编码
all_vars <- unique(gsub("([><=]+).*", "\\1", unlist(split_conds), invert = TRUE))
var_dict <- setNames(seq_along(all_vars), all_vars)
# 运算符词典：提取所有比较符并编码
all_ops <- unique(gsub(".*([><=]+).*", "\\1", unlist(split_conds)))
op_dict <- setNames(seq_along(all_ops), all_ops)
# 阈值词典：提取所有阈值并编码
all_vals <- unique(as.numeric(gsub(".*[><=]+(.*)", "\\1", unlist(split_conds))))
val_dict <- setNames(seq_along(all_vals), as.character(all_vals))
# 逻辑连接符词典
logic_dict <- c("&" = 1, "|" = 2)
# 固定向量长度为10（可根据需要调整，预留冗余即可）
vec_len <- 10

# ---------------------- 第二步：规则转整数向量 ----------------------
rule_to_int <- function(rule) {
  rule_parts <- strsplit(rule, " ")[[1]]
  int_vec <- rep(0, vec_len)
  ptr <- 1
  for (part in rule_parts) {
    if (part %in% names(logic_dict)) {
      int_vec[ptr] <- logic_dict[part]
      ptr <- ptr + 1
    } else {
      var <- gsub("([><=]+).*", "\\1", part, invert = TRUE)
      op <- gsub(".*([><=]+).*", "\\1", part)
      val <- gsub(".*[><=]+(.*)", "\\1", part)
      int_vec[ptr] <- var_dict[var]
      int_vec[ptr+1] <- op_dict[op]
      int_vec[ptr+2] <- val_dict[val]
      ptr <- ptr + 3
    }
    if (ptr > vec_len) break
  }
  return(int_vec)
}
# 生成整数矩阵
int_mat <- do.call(rbind, lapply(rules, rule_to_int))
# 查看转换结果
cbind.data.frame(rules, int_mat)

# ---------------------- 第三步：整数向量转回规则 ----------------------
int_to_rule <- function(int_vec) {
  rule_parts <- c()
  ptr <- 1
  while(ptr <= vec_len && int_vec[ptr] != 0) {
    if (int_vec[ptr] %in% logic_dict) {
      rule_parts <- c(rule_parts, names(logic_dict)[which(logic_dict == int_vec[ptr])])
      ptr <- ptr + 1
    } else {
      var <- names(var_dict)[which(var_dict == int_vec[ptr])]
      op <- names(op_dict)[which(op_dict == int_vec[ptr+1])]
      val <- names(val_dict)[which(val_dict == int_vec[ptr+2])]
      rule_parts <- c(rule_parts, paste0(var, op, val))
      ptr <- ptr + 3
    }
  }
  return(paste(rule_parts, collapse = " "))
}
# 验证双向转换正确性
all(sapply(1:nrow(int_mat), function(i) int_to_rule(int_mat[i,]) == rules[i]))
# 输出为TRUE即证明完全可逆

注意事项 #

如果后续需要新增未在初始词典中出现的变量、运算符或阈值，只需要更新全局词典、原有编码保持不变即可，不会影响历史转换结果的可用性。

内容的提问来源于stack exchange，提问作者mr.T