Question

I want to convert a string of playing cards given as in A into a form B such that I can produce a result C.

A: "(AK,AQ,(A2:*h*h)):*s*s!AsQs,(JJ:*s*h)"
B: (((AsKs union AsQs union (A2 intersect hand with two hearts)) intersect hand with two spades) less AsQs) union (JJ intersect hand with one spade one heart)
C: AsKs,JsJh

The precedence of operations is

• 1) parentheses, ‘()’
• 2) intersect and less (left associative), ‘:!’
• 3) union, ‘,’

I have the functionality to perform the operations in B, for example Intersect(“AA”, “*s*s”) == “AsAs”, but I need a way to get from the form A into the form B of inputs and associated operations that I can perform in sequence to arrive at C.

I have looked at Irony and some other lexer/parser solutions, but they seem a bit overkill for this problem. Is there a simpler solution?

• Perhaps recursively splitting the string into a tree with nodes representing operations?
• Breaking down the string in reverse order of precedence and pushing it onto a stack? If so how (roughly) could this be implemented?

A working example of what I am trying to emulate is given here. You can find a more detailed description of the syntax for A here.

Answer 1

You could parse A to construct a tree of instructions and then execute them starting from the leaves (as I assume you’d want to execute the contents of the innermost brackets first). For this parsing task, you could use Regexes, or whatever else you want. Off the top of my head, I think you can first look for the parenthesis and operator symbols to figure out the tree structure, then fill in each leaf with the actual elementary instruction and each junction with the operator.

The data structure storing A can be composed of objects (call them Expression) implementing an interface IOperand; each Expression should have three fields:

1. A field Operator which is an instance of enum Operations {Union, Intersection, SetDiff}, or just a string, depending on which you prefer.
2. Two fields Operand1 and Operand2, which can be either something like “Ah” (defining a set of cards), or another Expression. Therefore, they should be declared as instances of IOperand.

Your class for holding a single set of cards, like “Ah”, should also implement this IOperand. The interface IOperand itself need not actually do anything.

For matching each given instruction to an operation, you could use a simple switch, or alternatively a Dictionary of string (or enum) to delegate IOperand SetOp(IOperand, IOperand);, and then populate your Dictionary with (anonymous) functions (that would contain the instructions for B).

In the Dictionary case, you would simply be able to do instructionList[thisExpression.Operation](thisExpression); (this can probably be done a bit more elegantly to avoid referencing thisExpression twice) and the appropriate C# translation of the string input would be executed.

Proof of Concept

I have made a basic implementation and a console app to demonstrate usage here: https://bitbucket.org/Superbest/lexer

If you succeed at progressing through the whole exercise with your sanity intact (the computer will use you as a surrogate parsing and operation library, so good luck with that) then the final step should ask you to evaluate an expression equal to C and then print what you just entered back at you. (When running for the first time, you might want to comply with the program’s directives. I suspect it is very easy to break the code and get lots of exceptions, and confuse yourself very much if you try to think about what happened to your invalid input.)

If you are running the code as is, try the following sequence of answers (, = Enter):

n, y, 2, n, n, n, y, 2, n, n, y, n, y, 2, n, n, n, n, alpha, beta, gamma

Your output will be:

gamma

You should be able to simply update the bodies of methods marked obsolete and have a working program.

If you wish to add more binary operations, see the TODO in the body of Simplification.Simplification(). The appropriate syntax will be obvious from looking at the three operations I already made; as it is, the code supports only binary operations. If your methods consume strings, you can use the SimplifiedOperand.Symbol field.