24 game/CSharp
C_sharp
The C# language does not directly contain an Eval function for evaluating a string as a math expression, though there are still a number of ways to go about it.
You could, for example, use the CodeDOM to dynamically compile an object that contains the expression string.
Or, while not necessarily a good coding practice, but certainly a short and simple route, you could use System.Xml.XPath.XPathNavigator.Evaluate(string xpath) as shown here: <lang csharp> public class XPathEval : I24MathParser { public float Evaluate(string expression) { System.Xml.XPath.XPathNavigator navigator = new System.Xml.XPath.XPathDocument(new System.IO.StringReader("<r/>")).CreateNavigator();
//expath evaluator needs // '/' expressed as "div" // '%' expressed as "mod" string xpathExpression = expression.Replace("/", " div ").Replace("%", " mod "); float answer = Convert.ToSingle(navigator.Evaluate(String.Format("number({0})", xpathExpression)));
return answer; } } </lang>
The XPathEval class is implementing this interface to facilitate swapping out Evaluate providers:
<lang csharp>
interface I24MathParser {
float Evaluate(string expression);
}
</lang>
Here is a more verbose, native solution - a lightweight math expression parser for evaluating 24 Game user input:
<lang csharp>
/// <summary>
/// Lightweight math parser - C# does not have an Evaluate function
/// </summary>
public class MathParser : I24MathParser {
//used to translate brackets to implied multiplication - i.e. "3(4)5(6)" will be interpreted as "3*(4)*5*(6)"
private const string bracketsPattern = @"(?<=[0-9)])(?<rightSide>\()|(?<=\))(?<rightSide>[0-9])";
//finds multiplication or division sub expression - i.e. "4*8-4*2)" yields {"4*8", "4*2"} private const string multiplyDividePattern = @"[0-9]+[/*][0-9]+";
//finds bracketed expressions - i.e. "(4+30)(10-1)" yields {"4+30", "10-1"} private const string subExpressionPattern = @"\(([0-9/*\-+]*)\)";
//splits expression into it elements - i.e. "4+-30-4.123" yields {"4", "+", "-30" ,"-", "4.123"} private const string tokenPattern = @"(?:(?<=[/*\-+]|^)[+-]?)?(?:[0-9]+(?:\.[0-9]*)?)|[/*\-+]";
Regex brackets; Regex multiplyDivide; Regex subExpression; Regex token;
public MathParser() {
//initialize reusable regular expressions
brackets = new Regex(bracketsPattern, RegexOptions.Compiled);
subExpression = new Regex(subExpressionPattern, RegexOptions.Compiled);
token = new Regex(tokenPattern, RegexOptions.Compiled);
multiplyDivide = new Regex(multiplyDividePattern, RegexOptions.Compiled);
}
public float Evaluate(string input) {
//brackets with no operator implies multiplication
string equation = brackets.Replace(input, "*${rightSide}");
float answer = Solve(equation);
return answer; }
float Solve(string equation) {
//carry out order of operations
// bracketed subexpressions - for any operator
equation = SolveSubExpressions(subExpression, equation);
// multiplication and division equation = SolveSubExpressions(multiplyDivide, equation);
// addition and subtraction float answer = ParseEquation(equation);
return answer; }
string SolveSubExpressions(Regex subExpression, string equation) {
float subResult;
Match match = subExpression.Match(equation);
while (match.Success) { if (match.Groups[1].Length > 0) { //recursively solve for subexpressions -- match group 1 excludes outer brackets subResult = Solve(match.Groups[1].Value); } else { //no more nested expressions - get final result for this subExpression subResult = ParseEquation(match.Value); }
//replace subexpression with resolved answer
equation = equation.Replace(match.Value, subResult.ToString());
//retest updated equation string match = subExpression.Match(equation); }
return equation; }
float ParseEquation(string equation) {
Match match = token.Match(equation);
float leftSide = leftSide = float.Parse(match.Value);
string symbol;
float rightSide;
match = match.NextMatch();
while (match.Success) { symbol = match.Value; match = match.NextMatch();
if (match.Success) { rightSide = float.Parse(match.Value); leftSide = Calculate(leftSide, symbol, rightSide); match = match.NextMatch(); } }
return leftSide; }
float Calculate(float leftSide, string symbol, float rightSide) {
float answer;
switch (symbol) { case "/": answer = leftSide / rightSide; break;
case "*": answer = leftSide * rightSide; break;
case "-": answer = leftSide - rightSide; break;
case "+": answer = leftSide + rightSide; break;
default: throw new ArgumentException(); }
return answer; } } </lang>
This is the main class that handles puzzle generation and user interaction
<lang csharp>
/// <summary>
/// The Game. Handles user interaction and puzzle generation.
/// </summary>
class TwentyFourGame {
//puzzle parameters
private const int listSize = 4;
private const int minValue = 1;
private const int maxValue = 9;
//signals end of game private const string quitToken = "Q";
//the only valid puzzle solution private const float targetValue = 24;
//Regular Expressions for evaluating math input private const string dictionaryBlacklistPattern = @"[^1-9/*\-+()]"; private const string inputDigitsPattern = @"(?:(?<=[+-]|^)[+-]?)?(?:[0-9]+(?:\.[0-9]*)?)"; Regex dictionaryBlackList; Regex inputDigits; I24MathParser mathParser;
public TwentyFourGame() { //initialize reusable regular expressions dictionaryBlackList = new Regex(dictionaryBlacklistPattern, RegexOptions.Compiled); inputDigits = new Regex(inputDigitsPattern, RegexOptions.Compiled);
//define instance of math evaluator provider //custom parser //mathParser = new MathParser();
//xpath parser mathParser = new XPathEval(); }
static void Main(string[] args) {
TwentyFourGame game = new TwentyFourGame();
game.PrintInstructions();
game.PlayGame();
}
void PlayGame() {
string input;
bool endGame = false;
//repeat play cycle until user signals the end
do {
string puzzle = GetPuzzle();
bool isValid = false;
//continue prompting user until valid input is received do { float answer; string message = String.Empty;
try { //show user puzzle and get read their solution input = GetInput(puzzle);
if (input.Length == 0) { //skip current puzzle - perhaps there is no solution isValid = true; message = "Skipping this puzzle"; } else if (String.Compare(input, quitToken, true) == 0) { //user wishes to quit isValid = true; message = "End Game"; } else if (ValidateInput(input, puzzle)) { //interpret user input and calculate answer answer = mathParser.Evaluate(input);
if (answer == targetValue) { isValid = true; message = String.Format("Good work. {0} = {1}.", input, answer); } else { isValid = false; message = String.Format("Incorrect. {0} = {1}. Try again.", input, answer); } } else { isValid = false; message = "Invalid input. Try again."; } } catch { message = "An error occurred. Check your input and try again."; isValid = false; } finally { PrintMessage(message); PrintMessage(String.Empty); PrintMessage(String.Empty); } } while (!isValid); } while (!endGame);
//pause GetInput(String.Empty); }
bool ValidateInput(string input, string puzzle) {
bool isValid;
if (dictionaryBlackList.IsMatch(input)) { //illegal characters used isValid = false; } else { //get inputted digits and compare to those in puzzle string inputNumbers = String.Join(" ", from Match m in inputDigits.Matches(input) orderby float.Parse(m.Value) select m.Value);
isValid = inputNumbers.CompareTo(puzzle) == 0; }
return isValid; }
string GetPuzzle() {
int[] digits = new int[listSize];
//randomly choose 4 digits (from 1 to 9) Random rand = new Random();
for (int i = 0; i < digits.Length; i++) { digits[i] = rand.Next(minValue, maxValue); }
//format for display Array.Sort(digits); string puzzle = String.Join(" ", digits); return puzzle; }
string GetInput(string prompt) {
Console.Write(String.Concat(prompt, ": "));
return Console.ReadLine();
}
void PrintMessage(string message) {
Console.WriteLine(message);
}
void PrintInstructions() {
PrintMessage("--------------------------------- 24 Game ---------------------------------");
PrintMessage(String.Empty);
PrintMessage("------------------------------- Instructions ------------------------------");
PrintMessage("Four digits will be displayed.");
PrintMessage("Enter an equation using all of those four digits that evaluates to 24");
PrintMessage("Only * / + - operators and () are allowed");
PrintMessage("Digits can only be used once, but in any order you need.");
PrintMessage("Digits cannot be combined - i.e.: 12 + 12 when given 1,2,2,1 is not allowed");
PrintMessage("Submit a blank line to skip the current puzzle.");
PrintMessage("Type 'Q' to quit");
PrintMessage(String.Empty);
PrintMessage("Example: given 2 3 8 2, answer should resemble 8*3-(2-2)");
PrintMessage("---------------------------------------------------------------------------");
PrintMessage(String.Empty);
PrintMessage(String.Empty);
}
}
</lang>
Example output:
--------------------------------- 24 Game --------------------------------- ------------------------------- Instructions ------------------------------ Four digits will be displayed. Enter an equation using all of those four digits that evaluates to 24 Only * / + - operators and () are allowed Digits can only be used once, but in any order you need. Digits cannot be combined - i.e.: 12 + 12 when given 1,2,2,1 is not allowed Submit a blank line to skip the current puzzle. Type 'Q' to quit Example: given 2 3 8 2, answer should resemble 8*3-(2-2) --------------------------------------------------------------------------- 1 3 3 4: 4*(3-1)*3 Good work. 4*(3-1)*3 = 24. 1 3 5 6: