24 game/Solve: Difference between revisions

{{task}}

Write a program that takes four digits, either from user input or by random generation, and computes arithmetic expressions following the rules of the [[24 game]].

 

 

 

=={{header|ABAP}}==

 

Note: the permute function was locally from [[Permutations#ABAP|here]]

lv_number type i,

lt_numbers type table of i.

modify iv_set index lv_perm from lv_temp_2.

modify iv_set index lv_len from lv_temp.

 

Sample Runs:

=={{header|Argile}}==

{{works with|Argile|1.0.0}}

 

print a function that given four digits argv[1] subject to the rules of \

(roperators[(rrop[rpn][2])]) (rdigits[3]);

return buffer as text

Examples:

<pre>$ arc 24_game_solve.arg -o 24_game_solve.c

$ ./24_game_solve 1127

(1+2)*(1+7)</pre>

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

Output is in RPN.

InputBox, NNNN ; user input 4 digits

NNNN := RegExReplace(NNNN, "(\d)(?=\d)", "$1,") ; separate with commas for the sort command

o := A_LoopField o

return o

{{out}}for 1127:

<pre>

 

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

PROCsolve24("1234")

PROCsolve24("6789")

IF I% > 4 PRINT "No solution found"

ENDPROC

{{out}}

<pre>

 

=={{header|C}}==

 

 

 

 

}

}

 

}

}

 

}

 

 

 

 

 

 

 

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

{{works with|C++11}}

 

This code may be extended to work with more than 4 numbers, goals other than 24, or different digit ranges. Operations have been manually determined for these parameters, with the belief they are complete.

 

#include <iostream>

#include <ratio>

if(d[0] * d[1] == gameGoal * (d[2] - d[3])) printOperation("( ", " * ", " ) / ( ", " - ", " )");

// Operations with 2 symbols *, one symbol /:

if(d[0] * d[1] == gameGoal * d[2] * d[3]) printOperation("", " * ", " / ( ", " * ", " )");

// Operations with 2 symbols /, one symbol -:

if(d[0] * d[3] == gameGoal * (d[1] * d[3] - d[2])) printOperation("", " / ( ", " - ", " / ", " )");

} while(std::next_permutation(d.begin(), d.end())); // All operations are repeated for all possible permutations of the numbers.

}

return 0;

}

 

{{out}}

(( 5 + 3 ) * 3 ) / 1

</pre>

 

=={{header|Clojure}}==

(:require [clojure.math.combinatorics :as c]

[clojure.walk :as w]))

(map println)

doall

 

The function <code>play24</code> works by substituting the given digits and the four operations into the binary tree patterns (o (o n n) (o n n)), (o (o (o n n) n) n), and (o n (o n (o n n))).

The substitution is the complex part of the program: two pairs of nested maps (the function) are used to substitute in operations and digits, which are replaced into the tree patterns.

 

=={{header|CoffeeScript}}==

# This program tries to find some way to turn four digits into an arithmetic

# expression that adds up to 24.

solution = solve_24_game a, b, c, d

console.log "Solution for #{[a,b,c,d]}: #{solution ? 'no solution'}"

{{out}}

<pre>

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

 

 

(defun digits ()

digits which evaluates to 24. The first form found is returned, or

NIL if there is no solution."

 

{{out}}

This uses the Rational struct and permutations functions of two other Rosetta Code Tasks.

{{trans|Scala}}

 

string solve(in int target, in int[] problem) {

 

}

}

 

}

 

void main() {

{{out}}

<pre>[6, 7, 9, 5]: (6+(9*(7-5)))

[3, 3, 8, 8]: (8/(3-(8/3)))

[1, 1, 1, 1]: No solution</pre>

 

=={{header|Euler Math Toolbox}}==

Via brute force.

 

>function try24 (v) ...

$n=cols(v);

$return 0;

$endfunction

 

>try24([1,2,3,4]);

Solved the problem

-1+5=4

3-4=-1

 

=={{header|F_Sharp|F#}}==

It eliminates all duplicate solutions which result from transposing equal digits.

The basic solution is an adaption of the OCaml program.

 

let rec gcd x y = if x = y || x = 0 then y else if x < y then gcd y x else gcd y (x-y)

|> Seq.groupBy id

|> Seq.iter (fun x -> printfn "%s" (fst x))

{{out}}

<pre>>solve24 3 3 3 4

3 * 8 / (9 - 8)

3 / ((9 - 8) / 8)</pre>

 

=={{header|Fortran}}==

use helpers

implicit none

end function op

 

 

 

contains

end subroutine nextpermutation

 

{{out}} (using g95):

<pre> 3 6 7 9 : 3 *(( 6 - 7 )+ 9 )

2 4 6 8 : (( 2 / 4 )* 6 )* 8

</pre>

 

=={{header|GAP}}==

check := function(x, y, z)

local r, c, s, i, j, k, a, b, p;

# A tricky one:

Player24([3,3,8,8]);

 

=={{header|Go}}==

 

import (

}

}

{{out}}

<pre> 8 6 7 6: No solution

 

=={{header|Gosu}}==

uses java.lang.Integer

uses java.lang.Double

print( "No solution!" )

}

 

=={{header|Haskell}}==

 

import Data.Ratio

import Control.Monad

nub $ permutations $ map Constant r4

 

 

Example use:

(8 / (2 / (9 - 3)))</pre>

===Alternative version===

import Data.List

import Text.PrettyPrint

 

{{out}}

<pre>((8 / 2) * (9 - 3))

(((9 - 3) * 8) / 2)</pre>

 

This shares code with and solves the [[24_game#Icon_and_Unicon|24 game]]. A series of pattern expressions are built up and then populated with the permutations of the selected digits. Equations are skipped if they have been seen before. The procedure 'eval' was modified to catch zero divides. The solution will find either all occurrences or just the first occurrence of a solution.

 

link strings # for csort, deletec, permutes

 

suspend 2(="(", E(), =")") | # parenthesized subexpression, or ...

tab(any(&digits)) # just a value

 

 

 

=={{header|J}}==

ops=: ' ',.'+-*%' {~ >,{i.each 4 4 4

cmask=: 1 + 0j1 * i.@{:@$@[ e. ]

parens=: ], 0 paren 3, 0 paren 5, 2 paren 5, [: 0 paren 7 (0 paren 3)

all=: [: parens [:,/ ops ,@,."1/ perm { [:;":each

 

This implementation tests all 7680 candidate sentences.

 

The answer will be either a suitable J sentence or blank if none can be found. "J sentence" means that, for example, the sentence <code>8*7-4*1</code> is equivalent to the sentence <code>8*(7-(4*1))</code>. [Many infix languages use operator precedence to make polynomials easier to express without parenthesis, but J has other mechanisms for expressing polynomials and minimal operator precedence makes the language more regular.]

 

=={{header|Java}}==

{{works with|Java|7}}

Playable version, will print solution on request.

 

public class Game24Player {

res.add(Arrays.asList((i / npow), (i % npow) / n, i % n));

}

 

{{out}}

=={{header|JavaScript}}==

This is a translation of the C code.

var NOVAL=9999,oper="+-*/",out;

 

solve24("1234");

solve24("6789");

 

Examples:

((6*8)/((9-7)))

(((1+7))*(2+1))</pre>

 

=={{header|Julia}}==

length(nums) != 4 && error("Input must be a 4-element Array")

syms = [+,-,*,/]

end

return "0"

{{out}}

 

 

 

 

 

 

 

 

 

=={{header|Liberty BASIC}}==

input "Enter 4 digits: "; a$

nD=0

exit function

[handler]

 

=={{header|Lua}}==

Generic solver: pass card of any size with 1st argument and target number with second.

 

local SIZE = #arg[1]

local GOAL = tonumber(arg[2]) or 24

 

permgen(input, SIZE)

 

{{out}}

</pre>

 

The code:

treeR[n_] := Table[o[trees[a], trees[n - a]], {a, 1, n - 1}]

treeR[1] := n

Permutations[Array[v, 4]], 1]],

Quiet[(# /. v[q_] :> val[[q]]) == 24] &] /.

 

The <code>treeR</code> method recursively computes all possible operator trees for a certain number of inputs. It does this by tabling all combinations of distributions of inputs across the possible values. (For example, <code>treeR[4]</code> is allotted 4 inputs, so it returns <code>{o[treeR[3],treeR[1]],o[treeR[2],treeR[2]],o[treeR[1],treeR[3]]}</code>, where <code>o</code> is the operator (generic at this point).

**For each result, turn the expression into a string (for easy manipulation), strip the "<code>HoldForm</code>" wrapper, replace numbers like "-1*7" with "-7" (a idiosyncrasy of the conversion process), and remove any lingering duplicates. Some duplicates will still remain, notably constructs like "3 - 3" vs. "-3 + 3" and trivially similar expressions like "(8*3)*(6-5)" vs "(8*3)/(6-5)". Example run input and outputs:

 

 

{{out}}

*<code>Permutations[Array[v, n]]</code> returns <math>n!</math> permutations.

Therefore, the size of the working set is <math>64 \cdot n!\, C_{n-1} = 64 \cdot (n-1)!!!! = 64 \frac{(2n-2)!}{(n-1)!}</math>, where <math>n!!!!</math> is the [[wp:quadruple factorial|quadruple factorial]]. It goes without saying that this number increases very fast. For this game, the total is 7680 elements. For higher numbers of inputs, it is {7 680, 107 520, 1 935 360, 42 577 920, 1 107 025 920, ...}.

 

=={{header|OCaml}}==

 

| Const of float

| Sum of expression * expression (* e1 + e2 *)

| x::xs -> comp x xs

| [] -> assert false

 

<pre>

 

Note: the <code>permute</code> function was taken from [http://faq.perl.org/perlfaq4.html#How_do_I_permute_N_e here]

# http://faq.perl.org/perlfaq4.html#How_do_I_permute_N_e

my $code = shift;

my @idx = 0..$#_;

}

}

{{out}}

<pre>E:\Temp>24solve.pl

E:\Temp></pre>

 

 

 

 

 

 

 

 

 

 

 

{{out}}

<pre>