24 game: Difference between revisions

{{task}}

The [[wp:24 Game|24 Game]] tests one's mental arithmetic.

 

 

* The type of expression evaluator used is not mandated. An [[wp:Reverse Polish notation|RPN]] evaluator is equally acceptable for example.

* The task is not for the program to generate the expression, or test whether an expression is even possible.

 

 

 

=={{header|ABAP}}==

See [[24 game/ABAP]]

=={{header|Ada}}==

game24.adb:

with Ada.Numerics.Discrete_Random;

procedure Game_24 is

package Random_Digit is new Ada.Numerics.Discrete_Random (Digit);

Digit_Generator : Random_Digit.Generator;

Given_Digits : array (1 .. 4) of Digit;

begin

Ada.Text_IO.Put_Line ("24 Game");

Random_Digit.Reset (Digit_Generator);

for I in Given_Digits'Range loop

Given_Digits (I) := Random_Digit.Random (Digit_Generator);

end loop;

Ada.Text_IO.Put ("Your Digits:");

for I in Given_Digits'Range loop

end loop;

Ada.Text_IO.New_Line;

Ada.Text_IO.Put ("Enter your Expression: ");

declare

Unused_Digits : array (Given_Digits'Range) of Boolean :=

(others => True);

begin

-- check input

declare

begin

end if;

end if;

end;

end loop;

end loop;

else

Ada.Text_IO.Put_Line ("You won!");

end if;

end;

 

<pre>24 Game

Generating 4 digits...

Generating 4 digits...

 

=={{header|Argile}}==

{{works with|Argile|1.0.0}}

 

do

error "unclosed parenthesis"

return x

compile with:

arc 24_game.arg -o 24_game.c && gcc 24_game.c -o 24_game /usr/lib/libargrt.a

 

=={{header|AutoHotkey}}==

Title := "24 Game"

Gui, -MinimizeBox

FileDelete, %File%

Return, Result

 

=={{header|BBC BASIC}}==

DIM digits%(4), check%(4)

FOR choice% = 1 TO 4

INPUT '"Play again", answer$

IF LEFT$(answer$,1) = "y" OR LEFT$(answer$,1) = "Y" THEN CLS : RUN

 

=={{header|C}}==

Simple recursive descent parser. It doesn't have a real lexer, because all tokens are single character (digits, operators and parens). Code is a little too long.

#include <ctype.h>

#include <stdlib.h>

enum { OP_NONE = 0, OP_NUM, OP_ADD, OP_SUB, OP_MUL, OP_DIV };

typedef struct expr_t *expr, expr_t;

struct expr_t {

expr left, right;

};

#define N_DIGITS 4

expr_t digits[N_DIGITS];

void gen_digits()

{

digits[i].val = 1 + rand() % 9;

}

#define MAX_INPUT 64

char str[MAX_INPUT];

int pos;

#define POOL_SIZE 8

expr_t pool[POOL_SIZE];

int pool_ptr;

void reset()

{

digits[i].used = 0;

}

/* longish jumpish back to input cycle */

{

msg = s;

}

expr new_expr()

{

return 0;

}

/* check next input char */

int next_tok()

return str[pos];

}

/* move input pointer forward */

int take()

return 0;

}

/* BNF(ish)

expr = term { ("+")|("-") term }

| '(' expr ')'

*/

expr get_fact();

expr get_term();

expr get_expr();

expr get_expr()

{

if (!take()) bail("Unexpected end of input");

if (!(r = get_term())) bail("Expected term");

l = ret;

ret = new_expr();

return ret;

}

expr get_term()

{

while((c = next_tok()) == '*' || c == '/') {

if (!take()) bail("Unexpected end of input");

r = get_fact();

l = ret;

return ret;

}

expr get_digit()

{

return 0;

}

expr get_fact()

{

return 0;

}

expr parse()

{

return ret;

}

typedef struct frac_t frac_t, *frac;

struct frac_t { int denom, num; };

int gcd(int m, int n)

{

return n;

}

/* evaluate expression tree. result in fraction form */

void eval_tree(expr e, frac res)

return;

}

eval_tree(e->left, &l);

eval_tree(e->right, &r);

switch(e->op) {

case OP_ADD:

}

}

void get_input()

{

printf(". Type an expression and I'll check it for you, or make new numbers.\n"

"Your choice? [Expr/n/q] ");

while (1) {

for (i = 0; i < MAX_INPUT; i++) str[i] = '\n';

if (str[MAX_INPUT - 1] != '\n')

bail("string too long");

for (i = 0; i < MAX_INPUT; i++)

if (str[i] == '\n') str[i] = '\0';

}

}

int main()

{

frac_t f;

srand(time(0));

gen_digits();

while(1) {

get_input();

if (msg) {

/* after error jump; announce, reset, redo */

continue;

}

eval_tree(parse(), &f);

if (f.denom == 0) bail("Divide by zero");

if (f.denom == 1 && f.num == 24)

}

return 0;

Your choice? [Expr/n/q] 5*2*3/9

Eval to: 10/3, no good. Try again.

Bye</pre>

See [[24 game/C]]

 

=={{header|C++}}==

This uses the C++11 standard to simplify several parts of the code. Input is given in RPN format.

 

#include <iostream>

#include <stack>

}

return 0;

 

<pre>

Make 24 with the digits: 1 4 9 9

</pre>

 

 

=={{header|Clojure}}==

(ns rosettacode.24game)

 

 

 

 

 

 

=={{header|CoffeeScript}}==

{{works with|node.js}}

tty.setRawMode true

 

# begin taking input

process.stdin.resume()

 

=={{header|Common Lisp}}==

(define-condition bad-equation (error) ())

 

(read))

(lose () (error 'bad-equation))

(check (e)

(typecase e

(if (= 24 (eval (check (prompt)))) (win) (lose))

(error () (format t "Bad equation, try again.~%"))

 

'''Verbose Implementation'''

 

{{works with|clisp|2.47}}

(defconstant +ops+ '(* / + -))

 

(emit "Sorry, the form you entered did not ~

compute.~%~%")))))

 

Example Usage:

 

NIL</pre>

=={{header|D}}==

 

void main() {

if (stack.length < 2)

throw new Exception("Wrong expression.");

}

 

 

double[] stack;

switch (c) {

case '1': .. case '9':

stack ~= c - '0';

break;

default: throw new Exception("Wrong char: " ~ c);

}

 

throw new Exception("Not using the given digits.");

if (stack.length != 1)

throw new Exception("Wrong expression.");

Example:

Result: 24

Good job!</pre>