Interpreter

type Ride = Record<string, number | boolean>;
const NUMBERS = new Set(["minutes", "hour"]), FLAGS = new Set(["weekend", "member"]);

// ---- The grammar as classes: each kind of expression knows how to evaluate itself. ----
interface Expr { evaluate(ride: Ride): boolean; describe(): string; }

class Flag implements Expr {
  constructor(private readonly name: string) {}
  evaluate(ride: Ride) { return Boolean(ride[this.name]); }
  describe() { return `Flag(${this.name})`; }
}

const OPS: Record<string, (a: number, b: number) => boolean> = { ">": (a, b) => a > b, ">=": (a, b) => a >= b, "<": (a, b) => a < b, "<=": (a, b) => a <= b, "==": (a, b) => a === b };

class Compare implements Expr {
  constructor(private readonly name: string, private readonly op: string, private readonly value: number) {}
  evaluate(ride: Ride) { return OPS[this.op](Number(ride[this.name]), this.value); }
  describe() { return `Compare(${this.name} ${this.op} ${this.value})`; }
}

class Not implements Expr {
  constructor(private readonly inner: Expr) {}
  evaluate(ride: Ride) { return !this.inner.evaluate(ride); }
  describe() { return `Not(${this.inner.describe()})`; }
}

class And implements Expr {
  constructor(private readonly left: Expr, private readonly right: Expr) {}
  evaluate(ride: Ride) { return this.left.evaluate(ride) && this.right.evaluate(ride); }
  describe() { return `And(${this.left.describe()}, ${this.right.describe()})`; }
}

class Or implements Expr {
  constructor(private readonly left: Expr, private readonly right: Expr) {}
  evaluate(ride: Ride) { return this.left.evaluate(ride) || this.right.evaluate(ride); }
  describe() { return `Or(${this.left.describe()}, ${this.right.describe()})`; }
}

// ---- A small recursive-descent parser turns text into that tree. ----
class RuleError extends Error {}

class Parser {
  private readonly tokens: string[];
  private pos = 0;
  constructor(text: string) { this.tokens = text.match(/>=|<=|==|[()<>]|\w+/g) ?? []; }

  private peek(): string | null { return this.pos < this.tokens.length ? this.tokens[this.pos] : null; }
  private take(): string {
    const tok = this.peek();
    if (tok === null) throw new RuleError("expected a condition, found the end of the rule");
    this.pos++;
    return tok;
  }

  parse(): Expr {
    const expr = this.rule();
    if (this.peek() !== null) throw new RuleError(`unexpected '${this.peek()}'`);
    return expr;
  }

  private rule(): Expr {   // rule := term ("or" term)*
    let expr = this.term();
    while (this.peek() === "or") { this.take(); expr = new Or(expr, this.term()); }
    return expr;
  }

  private term(): Expr {   // term := factor ("and" factor)*
    let expr = this.factor();
    while (this.peek() === "and") { this.take(); expr = new And(expr, this.factor()); }
    return expr;
  }

  private factor(): Expr {   // factor := "not" factor | "(" rule ")" | flag | name op number
    const tok = this.take();
    if (tok === "not") return new Not(this.factor());
    if (tok === "(") {
      const expr = this.rule();
      if (this.take() !== ")") throw new RuleError("expected ')'");
      return expr;
    }
    if (FLAGS.has(tok)) return new Flag(tok);
    if (NUMBERS.has(tok)) {
      const op = this.take();
      if (!(op in OPS)) throw new RuleError(`expected a comparison after '${tok}'`);
      const num = this.peek();
      if (num === null || !/^\d+$/.test(num)) throw new RuleError(`expected a number after '${op}'`);
      this.take();
      return new Compare(tok, op, Number(num));
    }
    throw new RuleError(`unknown name '${tok}'`);
  }
}

const rides: Record<string, Ride> = {
  A: { weekend: true, member: true, minutes: 25, hour: 14 },
  B: { weekend: true, member: false, minutes: 15, hour: 23 },
  C: { weekend: false, member: false, minutes: 40, hour: 22 },
};
for (const text of ["weekend and minutes > 20", "member or (hour >= 22 and minutes < 30)", "not member and weekend", "weekend and", "speed > 3"]) {
  console.log(`rule: ${text}`);
  let tree: Expr;
  try {
    tree = new Parser(text).parse();
  } catch (e) {
    if (!(e instanceof RuleError)) throw e;
    console.log(`  error: ${e.message}`);
    continue;
  }
  console.log(`  tree: ${tree.describe()}`);
  const hits = Object.keys(rides).filter((name) => tree.evaluate(rides[name]));
  console.log(`  applies to: ${hits.join(", ") || "none"}`);
}

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.BiPredicate;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    static final Set<String> NUMBERS = Set.of("minutes", "hour"), FLAGS = Set.of("weekend", "member");
    static final Map<String, BiPredicate<Integer, Integer>> OPS = Map.of(">", (a, b) -> a > b, ">=", (a, b) -> a >= b, "<", (a, b) -> a < b, "<=", (a, b) -> a <= b, "==", (a, b) -> a.equals(b));

    // ---- The grammar as classes: each kind of expression knows how to evaluate itself. ----
    interface Expr { boolean evaluate(Map<String, Object> ride); String describe(); }

    record Flag(String name) implements Expr {
        public boolean evaluate(Map<String, Object> ride) { return (Boolean) ride.get(name); }
        public String describe() { return "Flag(" + name + ")"; }
    }

    record Compare(String name, String op, int value) implements Expr {
        public boolean evaluate(Map<String, Object> ride) { return OPS.get(op).test((Integer) ride.get(name), value); }
        public String describe() { return "Compare(" + name + " " + op + " " + value + ")"; }
    }

    record Not(Expr inner) implements Expr {
        public boolean evaluate(Map<String, Object> ride) { return !inner.evaluate(ride); }
        public String describe() { return "Not(" + inner.describe() + ")"; }
    }

    record And(Expr left, Expr right) implements Expr {
        public boolean evaluate(Map<String, Object> ride) { return left.evaluate(ride) && right.evaluate(ride); }
        public String describe() { return "And(" + left.describe() + ", " + right.describe() + ")"; }
    }

    record Or(Expr left, Expr right) implements Expr {
        public boolean evaluate(Map<String, Object> ride) { return left.evaluate(ride) || right.evaluate(ride); }
        public String describe() { return "Or(" + left.describe() + ", " + right.describe() + ")"; }
    }

    // ---- A small recursive-descent parser turns text into that tree. ----
    static class RuleError extends RuntimeException {
        private static final long serialVersionUID = 1L;
        RuleError(String message) { super(message); }
    }

    static class Parser {
        private final List<String> tokens = new ArrayList<>();
        private int pos;

        Parser(String text) {
            Matcher m = Pattern.compile(">=|<=|==|[()<>]|\\w+").matcher(text);
            while (m.find()) tokens.add(m.group());
        }

        private String peek() { return pos < tokens.size() ? tokens.get(pos) : null; }
        private String take() {
            String tok = peek();
            if (tok == null) throw new RuleError("expected a condition, found the end of the rule");
            pos++;
            return tok;
        }

        Expr parse() {
            Expr expr = rule();
            if (peek() != null) throw new RuleError("unexpected '" + peek() + "'");
            return expr;
        }

        private Expr rule() {   // rule := term ("or" term)*
            Expr expr = term();
            while ("or".equals(peek())) { take(); expr = new Or(expr, term()); }
            return expr;
        }

        private Expr term() {   // term := factor ("and" factor)*
            Expr expr = factor();
            while ("and".equals(peek())) { take(); expr = new And(expr, factor()); }
            return expr;
        }

        private Expr factor() {   // factor := "not" factor | "(" rule ")" | flag | name op number
            String tok = take();
            if (tok.equals("not")) return new Not(factor());
            if (tok.equals("(")) {
                Expr expr = rule();
                if (!take().equals(")")) throw new RuleError("expected ')'");
                return expr;
            }
            if (FLAGS.contains(tok)) return new Flag(tok);
            if (NUMBERS.contains(tok)) {
                String op = take();
                if (!OPS.containsKey(op)) throw new RuleError("expected a comparison after '" + tok + "'");
                String num = peek();
                if (num == null || !num.matches("\\d+")) throw new RuleError("expected a number after '" + op + "'");
                take();
                return new Compare(tok, op, Integer.parseInt(num));
            }
            throw new RuleError("unknown name '" + tok + "'");
        }
    }

    static Map<String, Object> ride(boolean weekend, boolean member, int minutes, int hour) {
        return Map.of("weekend", weekend, "member", member, "minutes", minutes, "hour", hour);
    }

    public static void main(String[] args) {
        Map<String, Map<String, Object>> rides = new LinkedHashMap<>();
        rides.put("A", ride(true, true, 25, 14));
        rides.put("B", ride(true, false, 15, 23));
        rides.put("C", ride(false, false, 40, 22));
        for (String text : List.of("weekend and minutes > 20", "member or (hour >= 22 and minutes < 30)", "not member and weekend", "weekend and", "speed > 3")) {
            System.out.println("rule: " + text);
            Expr tree;
            try {
                tree = new Parser(text).parse();
            } catch (RuleError e) {
                System.out.println("  error: " + e.getMessage());
                continue;
            }
            System.out.println("  tree: " + tree.describe());
            List<String> hits = new ArrayList<>();
            for (Map.Entry<String, Map<String, Object>> r : rides.entrySet()) if (tree.evaluate(r.getValue())) hits.add(r.getKey());
            System.out.println("  applies to: " + (hits.isEmpty() ? "none" : String.join(", ", hits)));
        }
    }
}